黑马程序员_集合框架(二)

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ --------------------

Map概述    Map子类对象特点
    Map集合：该集合存储键值对，成对存储，而且要保证键的唯一性。

    1.添加

                put(K key, V value)

                putAll(Map<? extends K, ? extends V> m)

                    添加元素，如果添加相同的键，后添加的值会覆盖原有的值，并put会返回被覆盖的值。

    2.删除

                clear();
                remove(Object key)

    3.判断

                containsValue(Object value)

                containsKey(Object key)

    4.获取

                get(Object key)

                size()

                values()

                entrySet()

                keySet()

    Map

        |--Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的

        |--HashMap：底层是哈希表数据结构，允许是用null键null值，该集合是不同步的

        |--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

    Set底层就是使用了Map集合

Map共性方法

public class MapDemo {

public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
//添加元素
map.put("01", "java1");
map.put("02", "java2");
map.put("03", "java3");
//判断
System.out.println("containKey:"+map.containsKey("02"));
//获取
System.out.println("get:"+map.get("02"));
//删除
System.out.println("remove:"+map.remove("03"));
//打印
System.out.println("map:"+map);
//获取map集合中所有值
Collection<String> coll = map.values();
System.out.println(coll);
}
}

Map-keySet    Map-entrySet
    map集合两种取出方式：

       1.Set<k>    keySet：将map中所有的键存入Set集合，因为具备迭代器，所以可以通过迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
        2.Set<Map.Entry<k,v>>    entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是Map.Entry

    map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

    keySet

public class MapDemo2 {

public static void main(String[] args) {

Map<String,String> map = new HashMap<String,String>();

map.put("01", "java1");
map.put("02", "java2");
map.put("03", "java3");
map.put("04", "java4");
//先获取map集合中所有键的Set集合，keySet();
Set<String> keySet = map.keySet();
//用Set集合获取迭代器
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
//用键通过map集合的get方法获取其对应的值
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
}
}

    Map.Entry：Entry也是一个接口，它是Map接口中的一个内部接口

    entrySet

public class MapDemo202 {

public static void main(String[] args) {

Map<String,String> map = new HashMap<String,String>();

map.put("01", "java1");
map.put("02", "java2");
map.put("03", "java3");
map.put("04", "java4");
//将Map集合中的映射关系取出，存入到Set集合中
Set<Map.Entry<String, String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String, String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
}
}

Map练习

/*
每个学生都有对应的归属地
学生Student,地址String
学生属性：姓名。年龄。
姓名和年龄相同的视为同一个学生。
保证学生的唯一性

1.描述学生
2.定义map容器，将学生作为键，地址作为值，存入
3.获取map集合中的元素
*/

class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name, int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Student s)
{
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
{
return this.name.compareTo(s.name);
}
return num;
}
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
{
throw new ClassCastException("类型不匹配");
}
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
}
public class MapTest {

public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"guangzhou");
hm.put(new Student("lisi4",24),"tianjin");

//第一种取出方式	ketSet
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);
System.out.println(stu+".."+addr);
}

//第二种取出方式	entrySet
Set<Map.Entry<Student, String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student, String>> iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student, String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"...."+addr);
}
}
}

TreeMap练习

/*
对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的
所以要使用可以排序的Map集合	TreeMap
*/

class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name, int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Student s)
{
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
{
return this.name.compareTo(s.name);
}
return num;
}
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
{
throw new ClassCastException("类型不匹配");
}
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
}
public class MapTest2 {

public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<Student,String>();
tm.put(new Student("lisi4",24),"tianjin");
tm.put(new Student("lisi2",22),"shanghai");
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("lisi3",23),"guangzhou");

Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student, String> me = it.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+".."+addr);
}
}
}

TreeMap练习-字母出现的次数

/*
"abcdabcdabcdabbccc"获取该字符串中的字母出现的次数
希望打印结果：a(1)b(2)...

字母和次数有映射关系
可以选择map集合
map集合中存放的就是映射关系

当数据之间存在映射关系时，要先想到map集合

思路：
1.将字符串转换成字符数组，因为要对每一个字母进行操作
2.定义一个map集合，因为打印结果的字母有顺序，所以使用treeMap集合
3.遍历字符数组，将每一个字母作为键去查map集合，
如果返回null，将该字母和1存入到map集合中
如果返回不是null，说明该字母在map集合中已经存在并有对应的次数
那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖原键的对应值。
4.将map集合中的数据变成指定的字符串形式返回
*/

public class MapTest3 {

public static String charCount(String str)
{
char[] chs = str.toCharArray();

TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

int count = 0;
for(int x=0; x<chs.le
b5a0
ngth; x++)
{
if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
continue;
Integer value = tm.get(chs[x]);
if(value!=null)
count = value;
count++;
tm.put(chs[x], count);
count = 0;
}

StringBuilder sb = new StringBuilder();

Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();

Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character, Integer> me = it.next();
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch+"("+value+")");
}
return sb.toString();
}

public static void main(String[] args) {
String s = charCount("abcdabcdabcdabbccc");
System.out.println(s);
}
}

Map扩展
    map集合被使用是因为具备映射关系

/*
"yiban" "01" "zhangsan"
"yiban" "02" "lisi"
"erban" "01" "wangwu"
"erban" "02" "zhaoliu"
*/

public class MapDemo3 {

public static void main(String[] args) {
HashMap<String,HashMap<String,String>> school = new HashMap<String,HashMap<String,String>>();
HashMap<String,String> yiban = new HashMap<String,String>();
HashMap<String,String> erban = new HashMap<String,String>();

school.put("yiban", yiban);
school.put("erban", erban);

yiban.put("01", "zhangsan");
yiban.put("02", "lisi");

erban.put("01", "wangwu");
erban.put("02", "zhaoliu");

Iterator<String> it = school.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
HashMap<String,String> room = school.get(roomName);
System.out.println(roomName);
getStudentInfo(room);
}
}
public static void getStudentInfo(HashMap<String,String> roomMap)
{
Iterator<String> it = roomMap.keySet().iterator();
while(it.hasNext())
{
String id = it.next();
String name = roomMap.get(id);
System.out.println(id+":"+name);
}
}
}

Collections-sort    Collections-max    Collections-binarySearch

class StrLenComparator implements Comparator<String>
{
public int compare(String s1, String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
public class CollectionsDemo {

public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

sop(list);

Collections.sort(list);

sop("Collections.sort:"+list);

Collections.sort(list,new StrLenComparator());

sop("StrLenComparator:"+list);

}
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

String max = Collections.max(list);

sop("max="+max);
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

Collections.sort(list);

int index = Collections.binarySearch(list,"gg");

sop("index="+index);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) {
sortDemo();
maxDemo();
binarySearchDemo();
}
}

Collections-替换反转    Collections-reverseOrder

public class CollectionsDemo2 {

public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

sop(list);
Collections.fill(list,"oo");
sop(list+"-Collections.fill");
}
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

Collections.replaceAll(list, "gg", "vv");
sop(list+"-Collections.replaceAll");
}
public static void reverseDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("gg");
list.add("z");
list.add("xc");

Collections.reverse(list);
sop(list+"-Collections.reverse");
}
public static void reverseOrderDemo()
{
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
ts.add("abcd");
ts.add("aaa");
ts.add("z");
ts.add("gg");
ts.add("z");
ts.add("xc");

sop(ts+"-Collections.reverseOrder()");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) {
fillDemo();
replaceAllDemo();
reverseDemo();
reverseOrderDemo();
}
}

Collections-SynList

Arrays
    用于操作数组的工具类，内部都是静态方法。

    asList：将数组变成list集合，可以使用集合的思想和方法来操作数组中的元素。
            将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。

            如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，呢么会将该数组作为集合中的元素存在。

public class ArraysDemo {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) {
String[] arr = {"abc","def","gh"};
List<String> list = Arrays.asList(arr);
sop("contains:"+list.contains("gh"));
sop(list);

Integer[] nums = {2,4,6};
List li = Arrays.asList(nums);
sop(li);
}
}

集合转成数组
    collection接口中的toArray方法

public class CollectionToArray {

public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aaa");
al.add("bbb");
al.add("ccc");

/*
1.当制定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于集合的size，就不会新创建数组，而使用传递进来的数组。
所以创建一个刚好的数组最优
2.将集合变数组，为了限定对元素的操作，不可以进行增删。

*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));

}
}

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ --------------------

详细请查看：http://edu.csdn.net