第一部分：Collection集合
1 collection集合概述
集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map。
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法和举例如下：
1import java.util.ArrayList; 2import java.util.Collection; 3import java.util.HashSet; 4 5/* 6 java.util.Collection接口 7 所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法 8 任意的单列集合都可以使用Collection接口中的方法 9 10 11 共性的方法: 12 public boolean add(E e)： 把给定的对象添加到当前集合中 。 13 public void clear() :清空集合中所有的元素。 14 public boolean remove(E e): 把给定的对象在当前集合中删除。 15 public boolean contains(E e): 判断当前集合中是否包含给定的对象。 16 public boolean isEmpty(): 判断当前集合是否为空。 17 public int size(): 返回集合中元素的个数。 18 public Object[] toArray(): 把集合中的元素，存储到数组中。 19 */ 20public class Demo01Collection { 21 public static void main(String[] args) { 22 //创建集合对象,可以使用多态 23 Collection<String> coll = new ArrayList<>(); 24 Collection<String> coll = new HashSet<>(); 25 System.out.println(coll);//重写了toString方法 [] 26 27 /* 28 public boolean add(E e)： 把给定的对象添加到当前集合中 。 29 返回值是一个boolean值,一般都返回true,所以可以不用接收 30 */ 31 boolean b1 = coll.add("张三"); 32 System.out.println("b1:"+b1);//b1:true 33 System.out.println(coll);//[张三] 34 coll.add("李四"); 35 coll.add("李四"); 36 coll.add("赵六"); 37 coll.add("田七"); 38 System.out.println(coll);//[张三, 李四, 赵六, 田七] 39 40 /* 41 public boolean remove(E e): 把给定的对象在当前集合中删除。 42 返回值是一个boolean值,集合中存在元素,删除元素,返回true 43 集合中不存在元素,删除失败,返回false 44 */ 45 boolean b2 = coll.remove("赵六"); 46 System.out.println("b2:"+b2);//b2:true 47 48 boolean b3 = coll.remove("赵四"); 49 System.out.println("b3:"+b3);//b3:false 50 System.out.println(coll);//[张三, 李四, 田七] 51 52 /* 53 public boolean contains(E e): 判断当前集合中是否包含给定的对象。 54 包含返回true 55 不包含返回false 56 */ 57 boolean b4 = coll.contains("李四"); 58 System.out.println("b4:"+b4);//b4:true 59 60 boolean b5 = coll.contains("赵四"); 61 System.out.println("b5:"+b5);//b5:false 62 63 //public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回false 64 boolean b6 = coll.isEmpty(); 65 System.out.println("b6:"+b6);//b6:false 66 67 //public int size(): 返回集合中元素的个数。 68 int size = coll.size(); 69 System.out.println("size:"+size);//size:3 70 71 //public Object[] toArray(): 把集合中的元素，存储到数组中。 72 Object[] arr = coll.toArray(); 73 for (int i = 0; i < arr.length; i++) { 74 System.out.println(arr[i]);//张三 李四 田七 75 } 76 77 //public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在 78 coll.clear(); 79 System.out.println(coll);//[] 80 System.out.println(coll.isEmpty());//true 81 } 82}
2 Collection集合之Iterator迭代器
2.1 Iterator接口
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。
Iterator接口的常用方法如下：
public E next():返回迭代的下一个元素。public boolean hasNext():如果仍有元素可以迭代，则返回 true。
迭代器的代码实现：
1import java.util.ArrayList; 2import java.util.Collection; 3import java.util.Iterator; 4 5/* 6 java.util.Iterator接口:迭代器(对集合进行遍历) 7 有两个常用的方法 8 boolean hasNext() 如果仍有元素可以迭代，则返回 true。 9 判断集合中还有没有下一个元素,有就返回true,没有就返回false 10 E next() 返回迭代的下一个元素。 11 取出集合中的下一个元素 12 Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊 13 Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象 14 Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。 15 16 迭代器的使用步骤: 17 1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态) 18 2.使用Iterator接口中的方法hasNext判断还有没有下一个元素 19 3.使用Iterator接口中的方法next取出集合中的下一个元素 20 */ 21public class Demo01Iterator { 22 public static void main(String[] args) { 23 //创建一个集合对象 24 Collection<String> coll = new ArrayList<>(); 25 //往集合中添加元素 26 coll.add("姚明"); 27 coll.add("科比"); 28 coll.add("麦迪"); 29 coll.add("詹姆斯"); 30 coll.add("艾弗森"); 31 32 /* 33 1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态) 34 注意: 35 Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型 36 */ 37 //1. 多态 接口 实现类对象 38 Iterator<String> it = coll.iterator(); 39 //2.使用Iterator接口中的方法hasNext判断还有没有下一个元素 40 boolean b = it.hasNext(); 41 System.out.println(b);//true 42 //3.使用Iterator接口中的方法next取出集合中的下一个元素 43 String s = it.next(); 44 System.out.println(s);//姚明 45 46 b = it.hasNext(); 47 System.out.println(b); 48 s = it.next(); 49 System.out.println(s); 50 51 b = it.hasNext(); 52 System.out.println(b); 53 s = it.next(); 54 System.out.println(s); 55 56 b = it.hasNext(); 57 System.out.println(b); 58 s = it.next(); 59 System.out.println(s); 60 61 b = it.hasNext(); 62 System.out.println(b); 63 s = it.next(); 64 System.out.println(s); 65 66 b = it.hasNext(); 67 System.out.println(b);//没有元素,返回false 68 s = it.next();//没有元素,再取出元素会抛出NoSuchElementException没有元素异常 69 System.out.println(s);*/ 70 71 /* 72 发现使用迭代器取出集合中元素的代码,是一个重复的过程 73 所以可以使用循环优化 74 不知道集合中有多少元素,使用while循环 75 循环结束的条件,hasNext方法返回false 76 */ 77 while(it.hasNext()){ 78 String e = it.next(); 79 System.out.println(e); 80 } 81 System.out.println("----------------------"); 82 for(Iterator<String> it2 = coll.iterator();it2.hasNext();){ String e = it2.next(); System.out.println(e); } 83 84 } 85}
迭代器的实现原理：
3 泛型
3.1 泛型的概念：
3.2 泛型的定义和使用
3.2.1 定义和使用含有泛型的类
1//定义一个泛型 2public class GenericClass<g> {//g随便改成一个字母都行，主要是尖括号 3 private g name; 4 5 public g getName() { 6 return name; 7 } 8 9 public void setName(g name) { 10 this.name = name; 11 } 12} 13 14//测试 15public class GenericClassTest { 16 public static void main(String[] args) { 17 GenericClass<Integer> gc = new GenericClass<>();//创建对象的时候才确定泛型的实际类型，这里使用的是Integer 18 gc.setName(1); 19 System.out.println(gc.getName()); 20 21 GenericClass<String> gc1 = new GenericClass<>();//也可以使用String类型 22 gc1.setName("小明明"); 23 System.out.println(gc1.getName()); 24 } 25}
3.2.2 定义和使用含有泛型的方法
1//创建一个含有泛型方法的类 2public class GenericMethod { 3 public <e> void gmMethod(e ele){ 4 System.out.println(ele); 5} 6 7 public static <m> void staticGm(m mm){ 8 System.out.println(mm); 9 } 10} 11//测试 12public class GenericMethodTest { 13 public static void main(String[] args) { 14 GenericMethod method1 = new GenericMethod(); 15 method1.gmMethod(1); 16 method1.gmMethod("aaaaaaa"); 17 method1.gmMethod(true); 18 19 GenericMethod method2 = new GenericMethod(); 20 method2.staticGm(222); 21 GenericMethod.staticGm("静态方法建议用类名.静态方法名调用"); 22 } 23}
3.2.3 定义和使用含有泛型的接口
1//创建一个含有泛型的接口 2public interface GenericInterface<e> { 3 void method(e m); 4} 5 6//第一个方法：创建实现类的时候就指明实现类的类型 7public class GenericInterfaceImp implements GenericInterface<String > { 8 9 @Override 10 public void method(String m) { 11 System.out.println("重写了抽象类的方法"); 12 System.out.println(m); 13 } 14} 15 16//第二个方法：创建实现类的时候，泛型跟着接口的泛型走，创建对象的时候才指明泛型的具体类型 17public class GenericInterfaceImp2<e> implements GenericInterface<e> {//注意这两个地方都需要加尖括号<>，而且里面的类型与接口的泛型一致 18 @Override 19 public void method(e m) { 20 System.out.println(m); 21 } 22} 23 24//测试 25public class GenericInterfaceImpTest { 26 public static void main(String[] args) { 27 GenericInterfaceImp imp = new GenericInterfaceImp(); 28 imp.method("传递的参数就是这个" ); 29 30 GenericInterfaceImp2<Integer> imp2 = new GenericInterfaceImp2<Integer>();//注意要在这里创建时指明泛型的具体类型， 31 //否则下面的方法调用的参数会是Object类型 32 imp2.method(1111); 33 } 34}
3.2.4 泛型的通配符
1import java.util.ArrayList; 2import java.util.Iterator; 3 4public class GenericInterfaceImpTest { 5 public static void main(String[] args) { 6 GenericInterfaceImp imp = new GenericInterfaceImp(); 7 imp.method("传递的参数就是这个" ); 8 9 GenericInterfaceImp2<Integer> imp2 = new GenericInterfaceImp2<Integer>(); 10 imp2.method(1111); 11 12 System.out.println("====测试通配符===="); 13 ArrayList<String> list1 = new ArrayList<>(); 14 list1.add("aaa"); 15 list1.add("bbb"); 16 ArrayList<Integer> list2 = new ArrayList<>(); 17 list2.add(123); 18 list2.add(456); 19 printArrayList(list1); 20 printArrayList(list2); 21 } 22 23 public static void printArrayList(ArrayList<?> list){ 24 25 //Iterator iterator = new Iterator();//Iterator是一个接口，不能直接new， 26 Iterator<?> it = list.iterator();//集合list是什么类型，迭代器就是什么类型。测试中发现，问号不写也不会报错 27 //Iterator it = list.iterator();//需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊： 28 // Collection对象（可以换成具体的如ArrayList对象，也可以就用Collection对象）有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象 29 while (it.hasNext()){ 30 System.out.println(it.next()); 31 } 32 } 33}//Output
重写了抽象类的方法
传递的参数就是这个
1111
====测试通配符====
aaa
bbb
123
456
4 Collection集合之list集合
4.1 List接口概述
Collection中的常用几个子类包括（ java.util.List 集合、java.util.Set 集合）
List接口特点：
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、
22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
4.2 ArrayList集合
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为
查询数据、遍历数据，所以ArrayList 是最常用的集合。
ArrayList底层是数组结构（所以名字带Array）。
ArrayList不是同步的，多线程的（快）。
1.0版本中的Vector是同步的，单线程（慢）。
1.2以后，Vector被ArrayList代替。
4.2 LinkedList集合
LinkedList是双向链表。由于底层是一个链表结构：元素增删快，查找慢。
5 Collection集合之Set接口
Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
没有索引，没有带索引的方法，不能使用普通的带for循环的遍历。
tips:Set集合取出元素的方式可以采用：迭代器、增强for。
5.1 HashSet集合介绍
java.util.HashSet 是Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序
不一致)。java.util.HashSet 底层的实现其实是一个java.util.HashMap 支持。
5.1.1 哈希值
1/* 2 哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址) 3 在Object类有一个方法,可以获取对象的哈希值 4 int hashCode() 返回该对象的哈希码值。 5 hashCode方法的源码: 6 public native int hashCode(); 7 native:代表该方法调用的是本地操作系统的方法 8 */ 9public class Demo01HashCode { 10 public static void main(String[] args) { 11 //Person类继承了Object类,所以可以使用Object类的hashCode方法 12 Person p1 = new Person(); 13 int h1 = p1.hashCode(); 14 System.out.println(h1);//1967205423 15 16 Person p2 = new Person(); 17 int h2 = p2.hashCode(); 18 System.out.println(h2);//42121758 19 20 /* 21 toString方法的源码: 22 return getClass().getName() + "@" + Integer.toHexString(hashCode()); 23 */ 24 System.out.println(p1);//@75412c2f 25 System.out.println(p2);//@282ba1e 26 System.out.println(p1==p2);//false 27 28 /* 29 String类的哈希值 30 String类重写了Obejct类的hashCode方法 31 */ 32 String s1 = new String("abc"); 33 String s2 = new String("abc"); 34 System.out.println(s1.hashCode());//96354 35 System.out.println(s2.hashCode());//96354 36 37 System.out.println("重地".hashCode());//1179395 巧合 38 System.out.println("通话".hashCode());//1179395 39 } 40}
5.1.2 HashSet集合存储数据的结构（哈希表）
Set集合（如java.util.HashSet 、java.util.LinkedHashSet 这两个集合）不允许存储重复元素的原理：
注意：使用set集合，需要重写hashcode和equals方法。因为要保证set中元素唯一，重写的方法可以保证。使用list集合则不必重写。
6 Collections 集合工具类
1- `public static <T> boolean addAll(Collection<T> c, T... elements) `:一次性往集合中添加一些元素，不必使用add添加多次 2- `public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。 3- `public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序（默认升序或者降序）。 4- `public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。（comparator就是比较器的规则）
addall和shuffle方法实例：
1import java.util.ArrayList; 2import java.util.Collections; 3 4/* 5 - java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： 6 - public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 7 - public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。 8 */ 9public class Demo01Collections { 10 public static void main(String[] args) { 11 ArrayList<String> list = new ArrayList<>(); 12 //往集合中添加多个元素 13 /*list.add("a"); 14 list.add("b"); 15 list.add("c"); 16 list.add("d"); 17 list.add("e");*/ 18 19 //public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 20 Collections.addAll(list,"a","b","c","d","e"); 21 22 System.out.println(list);//[a, b, c, d, e] 23 24 //public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。 25 Collections.shuffle(list); 26 System.out.println(list);//[b, d, c, a, e], [b, d, c, a, e] 27 } 28}
两种比较方法的实例：
1//第一种：public static <T> void sort(List<T> list) 2 3//对自定义的Person类进行排序。//首先定义一个Person类public class Person implements Comparable<Person>{ 4 private String name; 5 private int age; 6 7 public Person() { 8 } 9 10 public Person(String name, int age) { 11 this.name = name; 12 this.age = age; 13 } 14 15 @Override 16 public String toString() { 17 return "Person{" + 18 "name='" + name + '\'' + 19 ", age=" + age + 20 '}'; 21 } 22 23 public String getName() { 24 return name; 25 } 26 27 public void setName(String name) { 28 this.name = name; 29 } 30 31 public int getAge() { 32 return age; 33 } 34 35 public void setAge(int age) { 36 this.age = age; 37 } 38 39 //重写排序的规则 40 @Override 41 public int compareTo(Person o) { 42 //return 0;//认为元素都是相同的 43 //自定义比较的规则,比较两个人的年龄(this,参数Person) 44 //return this.getAge() - o.getAge();//年龄升序排序 45 return o.getAge() - this.getAge();//年龄升序排序 46 } 47} 48 49import java.util.ArrayList; 50import java.util.Collections; 51 52/* 53 - java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： 54 public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。 55 56 注意: 57 sort(List<T> list)使用前提 58 被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则 59 60 Comparable接口的排序规则: 61 自己(this)-参数:升序 62 */ 63public class Demo02Sort { 64 public static void main(String[] args) { 65 ArrayList<Integer> list01 = new ArrayList<>(); 66 list01.add(1); 67 list01.add(3); 68 list01.add(2); 69 System.out.println(list01);//[1, 3, 2] 70 71 //public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。 72 Collections.sort(list01);//默认是升序 73 74 System.out.println(list01);//[1, 2, 3] 75 76 ArrayList<String> list02 = new ArrayList<>(); 77 list02.add("a"); 78 list02.add("c"); 79 list02.add("b"); 80 System.out.println(list02);//[a, c, b] 81 82 Collections.sort(list02); 83 System.out.println(list02);//[a, b, c] 84 85 ArrayList<Person> list03 = new ArrayList<>(); 86 list03.add(new Person("张三",18)); 87 list03.add(new Person("李四",20)); 88 list03.add(new Person("王五",15)); 89 System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}] 90 91 Collections.sort(list03); 92 System.out.println(list03); 93 } 94} 95 96//第二种：//首先自定义学生类public class Student { 97 private String name; 98 private int age; 99 100 public Student() { 101 } 102 103 public Student(String name, int age) { 104 this.name = name; 105 this.age = age; 106 } 107 108 @Override 109 public String toString() { 110 return "Student{" + 111 "name='" + name + '\'' + 112 ", age=" + age + 113 '}'; 114 } 115 116 public String getName() { 117 return name; 118 } 119 120 public void setName(String name) { 121 this.name = name; 122 } 123 124 public int getAge() { 125 return age; 126 } 127 128 public void setAge(int age) { 129 this.age = age; 130 } 131} 132 133import java.util.ArrayList; 134import java.util.Collections; 135import java.util.Comparator; 136 137/* 138 - java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： 139 public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。 140 141 Comparator和Comparable的区别 142 Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法 143 Comparator:相当于找一个第三方的裁判,比较两个 144 145 Comparator的排序规则: 146 o1-o2:升序 147 */ 148public class Demo03Sort { 149 public static void main(String[] args) { 150 ArrayList<Integer> list01 = new ArrayList<>(); 151 list01.add(1); 152 list01.add(3); 153 list01.add(2); 154 System.out.println(list01);//[1, 3, 2] 155 156 Collections.sort(list01, new Comparator<Integer>() { 157 //重写比较的规则 158 @Override 159 public int compare(Integer o1, Integer o2) { 160 //return o1-o2;//升序 161 return o2-o1;//降序 162 } 163 }); 164 165 System.out.println(list01); 166 167 ArrayList<Student> list02 = new ArrayList<>(); 168 list02.add(new Student("a迪丽热巴",18)); 169 list02.add(new Student("古力娜扎",20)); 170 list02.add(new Student("杨幂",17)); 171 list02.add(new Student("b杨幂",18)); 172 System.out.println(list02); 173 174 /*Collections.sort(list02, new Comparator<Student>() { 175 @Override 176 public int compare(Student o1, Student o2) { 177 //按照年龄升序排序 178 return o1.getAge()-o2.getAge(); 179 } 180 });*/ 181 182 //扩展: 183 Collections.sort(list02, new Comparator<Student>() { 184 @Override 185 public int compare(Student o1, Student o2) { 186 //按照年龄升序排序 187 int result = o1.getAge()-o2.getAge(); 188 //如果两个人年龄相同,再使用姓名的第一个字比较 189 if(result==0){ 190 result = o1.getName().charAt(0)-o2.getName().charAt(0); 191 } 192 return result; 193 } 194 195 }); 196 197 System.out.println(list02); 198 } 199}
第二部分 Map集合
1 Map集合概述
Collection 中的集合称为单列集合， Map 中的集合称为双列集合。
Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
总结：Map中， K不允许重复，V可以重复
Map接口有多个子类，常用的是HashMap集合、LinkedHashMap集合。
HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需
要重写键的hashCode()方法、equals()方法。
LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链
表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的
hashCode()方法、equals()方法。
tips：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数
据类型可以相同，也可以不同。
1import java.util.HashMap; 2import java.util.Map; 3 4/* 5 java.util.Map<k,v>集合 6 Map集合的特点: 7 1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value) 8 2.Map集合中的元素,key和value的数据类型可以相同,也可以不同 9 3.Map集合中的元素,key是不允许重复的,value是可以重复的 10 4.Map集合中的元素,key和value是一一对应 11 java.util.HashMap<k,v>集合 implements Map<k,v>接口 12 HashMap集合的特点: 13 1.HashMap集合底层是哈希表:查询的速度特别的快 14 JDK1.8之前:数组+单向链表 15 JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度 16 2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致 17 java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合 18 LinkedHashMap的特点: 19 1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序) 20 2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的 21 *///Map集合中常用的方法演示 22public class DemoMap { 23 public static void main(String[] args) { 24 show04(); 25 } 26 27 /* 28 boolean containsKey(Object key) 判断集合中是否包含指定的键。 29 包含返回true,不包含返回false 30 */ 31 private static void show04() { 32 //创建Map集合对象 33 Map<String,Integer> map = new HashMap<>(); 34 map.put("赵丽颖",168); 35 map.put("杨颖",165); 36 map.put("林志玲",178); 37 38 boolean b1 = map.containsKey("赵丽颖"); 39 System.out.println("b1:"+b1);//b1:true 40 41 boolean b2 = map.containsKey("赵颖"); 42 System.out.println("b2:"+b2);//b2:false 43 } 44 45 /* 46 public V get(Object key) 根据指定的键，在Map集合中获取对应的值。 47 返回值: 48 key存在,返回对应的value值 49 key不存在,返回null 50 */ 51 private static void show03() { 52 //创建Map集合对象 53 Map<String,Integer> map = new HashMap<>(); 54 map.put("赵丽颖",168); 55 map.put("杨颖",165); 56 map.put("林志玲",178); 57 58 Integer v1 = map.get("杨颖"); 59 System.out.println("v1:"+v1);//v1:165 60 61 Integer v2 = map.get("迪丽热巴"); 62 System.out.println("v2:"+v2);//v2:null 63 } 64 65 /* 66 public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。 67 返回值:V 68 key存在,v返回被删除的值 69 key不存在,v返回null 70 */ 71 private static void show02() { 72 //创建Map集合对象 73 Map<String,Integer> map = new HashMap<>(); 74 map.put("赵丽颖",168); 75 map.put("杨颖",165); 76 map.put("林志玲",178); 77 System.out.println(map);//{林志玲=178, 赵丽颖=168, 杨颖=165} 78 79 Integer v1 = map.remove("林志玲"); 80 System.out.println("v1:"+v1);//v1:178 81 82 System.out.println(map);//{赵丽颖=168, 杨颖=165} 83 84 //int v2 = map.remove("林志颖");//自动拆箱 NullPointerException 85 Integer v2 = map.remove("林志颖"); 86 System.out.println("v2:"+v2);//v2:null 87 88 System.out.println(map);//{赵丽颖=168, 杨颖=165} 89 } 90 91 /* 92 public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。 93 返回值:v 94 存储键值对的时候,key不重复,返回值V是null 95 存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值 96 */ 97 private static void show01() { 98 //创建Map集合对象,多态 99 Map<String,String> map = new HashMap<>(); 100 101 String v1 = map.put("李晨", "范冰冰1"); 102 System.out.println("v1:"+v1);//v1:null 103 104 String v2 = map.put("李晨", "范冰冰2"); 105 System.out.println("v2:"+v2);//v2:范冰冰1 106 107 System.out.println(map);//{李晨=范冰冰2} 108 109 map.put("冷锋","龙小云"); 110 map.put("杨过","小龙女"); 111 map.put("尹志平","小龙女"); 112 System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云} 113 } 114}
2 Map集合遍历--键找值方式
分析步骤：
1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法: keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法: get(K key)
1public class MapDemo { 2public static void main(String[] args) { 3//创建Map集合对象 4HashMap<String, String> map = new HashMap<String,String>(); 5//添加元素到集合 6map.put("胡歌", "霍建华"); 7map.put("郭德纲", "于谦"); 8map.put("薛之谦", "大张伟"); 9 10Set<String> keys = map.keySet(); 11// 遍历键集 得到 每一个键 12for (String key : keys) { 13//key 就是键 14//获取对应值 15String value = map.get(key); 16System.out.println(key+"的CP是："+value); 17} 18} 19}
3 Map集合遍历--键值对方式
Entry键值对对象：
Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map 中是一一对应关
系，这一对对象又称做Map 中的一个Entry(项) 。Entry 将键值对的对应关系封装成了对象。即键值对对象，这
样我们在遍历Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，获取对应键和对应值的方法：
- public K getKey() ：获取Entry对象中的键。
- public V getValue() ：获取Entry对象中的值。
在Map集合中获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
///Map集合遍历--键值对方式 实例
1public class MapDemo02 { 2public static void main(String[] args) { 3// 创建Map集合对象 4HashMap<String, String> map = new HashMap<String,String>(); 5// 添加元素到集合 6map.put("胡歌", "霍建华"); 7map.put("郭德纲", "于谦"); 8map.put("薛之谦", "大张伟"); 9// 获取 所有的 entry对象 entrySet 10Set<Entry<String,String>> entrySet = map.entrySet(); 11// 遍历得到每一个entry对象 12for (Entry<String, String> entry : entrySet) { 13// 解析 14String key = entry.getKey(); 15String value = entry.getValue(); 16System.out.println(key+"的CP是:"+value); 17} 18} 19}