黑马程序员-学习笔记-集合

  ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Map集合

该集合存储键值对。一对一对往里存，而且要保证键的唯一性(与Set集合保证元素唯一性一致)。一个映射不能包含重复的键。每个键最多只能映射到一个值。

Collection是单列对象集合，而Map是键值对集合。

添加，删除，判断，获取元素。

clear() 
从此映射中移除所有映射关系（可选操作）。

remove(Object key) 
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

Containskey（）

ContainsValue（）

判断键和值是否在集合中存在。

get(Object key) 
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

values() 
返回此映射中包含的值的 Collection 视图。

添加

put(Kkey, Vvalue) 
将指定的值与此映射中的指定键关联（可选操作）。

putAll(Map<? extends K,?extends V>m) 
从指定映射中将所有映射关系复制到此映射中（可选操作）。

 

Map集合中常见的三个子类对象

HashMap：底层是哈希表数据结构，线程不同步。允许使用null值和null键，效率高

HashTable：线程同步。不允许存入null值和null键，效率低

为了成功的在哈希表中存储和获取对象，用作键的对象必须实现hashCode方法和equals方法。

TreeMap：底层是二叉树数据结构，线程不同步，给键排序是它的主要特点。

 

其实Set底层就是使用了Map集合。

当Map仅存入一个键值的 时候，就是Set。

下边具体写一个例子来使用上述方法

[java]  view plain copy

1. import java.util.*;  
2. public class MapDemo   
3. {  
4.   
5.     public static void main(String[] args)   
6.     {  
7.         Map<String,String> mp = new HashMap<String,String>();  
8.         System.out.println(mp.put("01","001"));  
9.         System.out.println(mp.put("01","0001"));  
10. //在Map中存入一个键相同的值后，新的值会替换旧的值，这与set集合不同。  
11. //旧的值通过put方法返回  
12.         mp.put("02", "002");  
13.         mp.put("03","003");  
14.         mp.put("04","004");  
15.         System.out.println(mp.containsKey("02"));  
16.         System.out.println(mp.remove("01"));  
17. //当remove删除键在集合中不存在时候，返回null  
18. //当remove删除的键在集合中存在时，返回这个键所对应的值  
19.         System.out.println(mp);  
20.         String s = mp.get("04");  
21.             //通过键去得到键所对应的值  
22.         System.out.println(s);        
23.         mp.put(null,null);  
24.         //HashMap中能存null键与null值  
25.         //获取map中所有的值  
26.                 Collection<String> c = mp.values();  
27.         System.out.println(c);  
28.         c.remove("002");  
29.         System.out.println(c);  
30.         System.out.println(mp);  
31.     }  
32. }  

 

在Map中不能通过迭代器的方式去取出所有的元素，只用Collection体系下的集合才能使用Iterator去迭代取出。

有两种方式

keySet() 
返回此映射中包含的键的 Set 视图。

将map中所有的键存入到Set集合中，由于Set具备迭代器，所以可以使用迭代方式取出所有的键，在根据get方法，获取每一个键对应的值。

例如

[java]  view plain copy

1. Map<String,String> mp = new HashMap<String,String>();  
2.         mp.put("02", "002");  
3.         mp.put("03","003");  
4.         mp.put("04","004");  
5.         Set<String> set = mp.keySet();  
6.         Iterator<String> it = set.iterator();  
7.         while(it.hasNext())  
8.         {  
9.             String key = it.next();  
10.             System.out.println(key+"...."+mp.get(key));  
11.         }  

entrySet() 
返回此映射中包含的映射关系的 Set 视图。

[java]  view plain copy

1. Map<String,String> mp = new HashMap<String,String>();  
2.         mp.put("02", "002");  
3.         mp.put("03","003");  
4.         mp.put("04","004");  
5.         Set<Map.Entry<String,String>> set = mp.entrySet();  
6.         Iterator<Map.Entry<String,String>> it  = set.iterator();  
7.         while(it.hasNext())  
8.         {  
9.             Map.Entry<String,String> mpe = it.next();  
10.             System.out.println(mpe.getKey()+".."+mpe.getValue());  
11.         }  

Map集合的取出原理，将Map集合转成Set集合，再通过迭代器取出。

在Map集合的子类中实现了Map.entry，对应集合的特定取出方式。跟迭代器原理一样。

上边的Map.entry类型其实就是关系类型。每一个键值对组成了一个关系。

 

Map集合的练习：

[java]  view plain copy

1. import java.util.*;  
2. public class Test  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.     Map<Student,String> mp = new HashMap<Student,String>();  
7.     mp.put(new Student("01",9),"0001");  
8.     mp.put(new Student("02",10),"0002");  
9.     mp.put(new Student("01",10),"0001");  
10.     mp.put(new Student("001",9),"0001");  
11.     mp.put(new Student("001",9),"002");  
12.     //第一种取出方式 keySet  
13.     Set<Student> set = mp.keySet();  
14.     Iterator<Student> it = set.iterator();  
15.     while(it.hasNext())  
16.     {  
17.        Student s = it.next();  
18.        System.out.println(s+"......."+mp.get(s));  
19.     }  
20.     //第二种取出方式entrySet  
21.     Set<Map.Entry<Student,String>> setMapEntry = mp.entrySet();  
22.       
23.     Iterator<Map.Entry<Student,String>> itEntry = setMapEntry.iterator();  
24.       
25.     while(itEntry.hasNext())  
26.     {  
27.       Map.Entry<Student,String> me = itEntry.next();  
28.         
29.       System.out.println(me.getKey()+"...."+me.getValue());  
30.         
31.     }  
32.     }  
33.   
34. }  
35. class Student implements Comparable<Student>  
36. {  
37.    private String name;  
38.    private int age;  
39.    public Student(String name,int age)  
40.    {  
41.        this.name = name;  
42.        this.age = age;     
43.    }  
44.    @Override  
45.    public int hashCode()  
46.    {  
47.        final int prime = 31;  
48.        int result = 1;  
49.        result = prime * result + age;  
50.        result = prime * result + ((name == null) ? 0 : name.hashCode());  
51.        return result;  
52.    }  
53.    @Override  
54.    public boolean equals(Object obj)  
55.    {  
56.        if (this == obj)  
57.        return true;  
58.        if (obj == null)  
59.        return false;  
60.        if (getClass() != obj.getClass())  
61.        return false;  
62.        Student other = (Student) obj;  
63.        if (age != other.age)  
64.        return false;  
65.        if (name == null)  
66.        {  
67.        if (other.name != null)  
68.            return false;  
69.        }  
70.        else if (!name.equals(other.name))  
71.        return false;  
72.        return true;  
73. }  
74.    @Override  
75.    public String toString()  
76.    {  
77.       return "{"+this.name+"."+this.age+"}";   
78.    }  
79.     
80.     @Override  
81.     public int compareTo(Student o)  
82.     {  
83.     int num = this.name.compareTo(o.name);  
84.       
85.     if(num==0)  
86.     {  
87.         return this.age-o.age;  
88.     }  
89.     return num;  
90.     }  
91. }  

下边，我们来看一个关于Map集合的高级应用。

需求:

一个公司的名字叫WDB，底下有很多的部门，比如说有财务部，信息部。

每个部下边又有很多的人。现在用集合中嵌套集合的方式来实现这个需求。

 

[java]  view plain copy

1. import java.util.*;  
2. public class JJ   
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         HashMap<String,List<Person1>> WDB = new HashMap<String,List<Person1>>();  
7.         //创建了一个公司         
8.         ArrayList<Person1> caiwu = new ArrayList<Person1>();  
9.         ArrayList<Person1> xinxi = new ArrayList<Person1>();  
10.         //创建了两个部门  
11.         //给两个部门分别添加各自的员工。  
12.         caiwu.add(new Person1("wangdbain",10));  
13.         caiwu.add(new Person1("wangdbain1",11));  
14.         xinxi.add(new Person1("zhaojianrun",10));  
15.         xinxi.add(new Person1("wangfangfang",20));  
16.         //给公司添加部门  
17.         WDB.put("caiwu",caiwu);  
18.         WDB.put("xinxi",xinxi);  
19.         //这里使用迭代器去分别去取公司每个部门的员工  
20.         Set<Map.Entry<String,List<Person1>>> set = WDB.entrySet();  
21.                 Iterator<Map.Entry<String,List<Person1>>> it = set.iterator();      
22.         while(it.hasNext())  
23.         {         
24.             Map.Entry<String,List<Person1>> me = it.next();  
25.             System.out.println(me.getKey());//得到部门的名称  
26.             List<Person1> li = me.getValue();//得到部门员工的集合    
27.             Iterator<Person1> it1 = li.iterator();  
28.             while(it1.hasNext())  
29.             {  
30.                   System.out.println(it1.next());  
31.                   //得到一个部门的所有员工     
32.             }         
33.         }  
34.     }  
35. }  
36. class Person1  
37. {  
38.     private String name;  
39.     private int age;  
40.     public Person1(String name,int age)  
41.     {  
42.         this.name = name;  
43.         this.age = age;  
44.     }  
45.     public String getName() {  
46.         return name;  
47.     }  
48.     public void setName(String name) {  
49.         this.name = name;  
50.     }  
51.     public int getAge() {  
52.         return age;  
53.     }  
54.     public void setAge(int age) {  
55.         this.age = age;  
56.     }  
57.     public String toString()  
58.     {  
59.         return this.name+"..."+this.age;  
60.     }  
61. }  

下边来讲解集合中的两个工具类：Collections，Arrays

Collections

作用:专门用来对集合进行操作的类,如对List集合排序sort();

sort(List<T>list)

根据元素的自然顺序 对指定列表按升序进行排序。

sort(List<T>list, Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。

例子

[java]  view plain copy

1. public class CollectionsDemo {  
2.     public static void main(String[] args) {  
3.         ArrayList<String> al = new ArrayList<String>();  
4.         al.add("4");  
5.         al.add("111");  
6.         al.add("1");  
7.         al.add("3");   
8.         Collections.sort(al);  
9.         System.out.println(al);  
10.         Collections.sort(al,new Mycom2());  
11.         System.out.println(al);  
12.     }  
13. }  
14. class Mycom2 implements Comparator<String>  
15. {  
16.     public int compare(String o1, String o2) {  
17.         int num = o1.length()-o2.length();  
18.         if(num==0)  
19.         {  
20.             return o1.compareTo(o2);  
21.         }  
22.         return num;  
23.     }  
24. }  

输出为:

[1, 111, 3, 4]

[1, 3, 4, 111]

介绍其中几个比较重要的方法

public static<T> Comparator<T> reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 Collection 的自然顺序。

如下:

[java]  view plain copy

1. TreeSet<String> ts  = new TreeSet<String>();  
2.         ts.add("2");  
3.         ts.add("1");  
4.         ts.add("4");  
5.         ts.add("8");  
6.         System.out.println(ts);  
7. //输出 1,2,3,8  
8. TreeSet<String> ts  = new TreeSet<String>(Collections.reverseOrder());  
9.         ts.add("2");  
10.         ts.add("1");  
11.         ts.add("4");  
12.         ts.add("8");  
13.         System.out.println(ts);  
14. 则//输出 8，3，2，1  

public static<T> Comparator<T> reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

例如：

[java]  view plain copy

1. public class Collectionnn {  
2.     public static void main(String[] args)   
3.     {  
4.         TreeSet<String> ts  = new TreeSet<String>(new Mycom());  
5.         ts.add("2");  
6.         ts.add("11");  
7.         ts.add("422");  
8.         ts.add("8888");  
9.         System.out.println(ts);   
10.         //得到 [2, 11, 422, 8888]  
11.                 TreeSet<String> ts  = new TreeSet<String>(Collections. reverseOrder(new Mycom()));  
12.         ts.add("2");  
13.         ts.add("11");  
14.         ts.add("422");  
15.         ts.add("8888");  
16.         System.out.println(ts);  
17. //得到 [ 8888,422,11,2]  
18.     }  
19. }  
20. class Mycom implements Comparator<String>  
21. {  
22.     public int compare(String o1, String o2) {  
23.         return o1.length()-o2.length();  
24.     }  
25. }  

Arrays

用于操作数组的工具类

1.   对基本数据类型的折半查找的方法。

例如

binarySearch(byte[]a, byte key)

使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。

2.对数组的复制

copyOf(boolean[]original, int newLength)

复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。 

最重要的方法,将数组变成List集合

使用Arrays.asList();

[java]  view plain copy

1. String [] arre={"11","23","22"};  
2. List<String> list = Arrays.asList(arre);   
3. System.out.println(list);  
4. //结果为  [11, 23, 22]  

为什么将数组变为集合？

可以使用集合的思想和方法来操作数组中的元素。

数组是一个对象，但是它的功能比较少,而集合的方法很多。

注意：将数组变成集合，不可以使用集合的增删方法

因为数组的长度是固定的。

如果使用增删，会发生UnsupportedOperationException

注意当使用

[java]  view plain copy

1. int []arr ={1,33,3,4,5};  
2. List list =Arrays.asList(arr);   
3. System.out.println(list);  

打印的不是元素，而是这个数组地址值。。

它是将arr作为一个集合的元素存在，而这个集合的类型就是int[]

所以当使用泛型的时候，应该这样去定义

List<int[]> list = Arrays.asList(arr);       

如果数组中的元素都是对象，变成集合时候，数组中的元素就直接转成集合中的元素

比如说String，如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

当我们这样定义时候

[java]  view plain copy

1. Integer []arr = {1,33,3,4,5};  
2. List<Integer>  list= Arrays.asList(arr);  
3. System.out.println(list);  

结果为[1, 33, 3, 4, 5]

上述是数组变成集合使用Arrays中的asList方法。

当集合变为数组的时候，就用到了Collection接口中的toArray方法。

[java]  view plain copy

1. ArrayList<String> al  = new ArrayList<String>();  
2.         al.add("1");  
3.         al.add("2");  
4.         al.add("3");  
5.         String [] arr=al.toArray(new String[0]);  
6.         System.out.println(Arrays.toString(arr));  

输出为 [1, 2, 3]

这里指定类型的数组要定义多长呢？当指定类型数组小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size，当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。

所以应该这样创建。String [] arr=al.toArray(new String[al.size()])；

为什么要将集合变成数组？

是为了限定对元素的操作。当返回一个集合时候，使用者对这个集合依然可以使用增删的方法对集合进行修改。当返回一个数组的时候，就不能改变其集合的大小了，限定了对使用着的操作。

 

高级for循环，方便对集合进行操作。

前提：只有继承自Iterable接口的集合接口才能使用foreach（高级for循环），比如Collection，而Map集合不能使用这个高级for循环。

格式

for(数据类型   变量名 ：被遍历的集合(Collection)或者数组)

{

}

这个遍历的局限性：只能对集合中的元素进行取出，而不能做修改动作。

迭代器至少有remove，如果使用列表迭代器的话，增删改查都行。

例子：

[java]  view plain copy

1.   ArrayList<Integer> al = new ArrayList<Integer>();  
2. al.add(1);  
3. al.add(31);  
4. for(int a:al)  
5. {  
6.     System.out.println(a);  
7. }  

还可以对数组进行遍历，例子：

[java]  view plain copy

1.  int[] arr = {1,2,3,4,5};   
2. for(int num:arr)  
3. {  
4.     System.out.println(num);  
5. }  

传统for循环和高级for循环的区别：高级for有一个局限性。必须有被遍历的目标。

对HashMap进行高级for循环遍历的例子：

由于Map不能使用高级for循环，所以必须将Map转成Set后，再使用高级for循环。

[java]  view plain copy

1.    HashMap<String,String> hm = new HashMap<String,String>();  
2. hm.put("1","2");  
3. hm.put("2", "3");  
4. Set<Map.Entry<String,String>> set = hm.entrySet();    
5. for(Map.Entry<String,String> me:set)  
6. {  
7.    System.out.println(me.getKey()+"....."+me.getValue());   
8. }