第一部分：Collection集合
1 collection集合概述
集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map。
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法和举例如下：
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;/*
java.util.Collection接口
所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法
任意的单列集合都可以使用Collection接口中的方法 共性的方法:
public boolean add(E e)： 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。
*/
public class Demo01Collection {
public static void main(String[] args) {
//创建集合对象,可以使用多态
Collection<String> coll = new ArrayList<>();
Collection<String> coll = new HashSet<>();
System.out.println(coll);//重写了toString方法 [] /*
public boolean add(E e)： 把给定的对象添加到当前集合中 。
返回值是一个boolean值,一般都返回true,所以可以不用接收
*/
boolean b1 = coll.add("张三");
System.out.println("b1:"+b1);//b1:true
System.out.println(coll);//[张三]
coll.add("李四");
coll.add("李四");
coll.add("赵六");
coll.add("田七");
System.out.println(coll);//[张三, 李四, 赵六, 田七] /*
public boolean remove(E e): 把给定的对象在当前集合中删除。
返回值是一个boolean值,集合中存在元素,删除元素,返回true
集合中不存在元素,删除失败,返回false
*/
boolean b2 = coll.remove("赵六");
System.out.println("b2:"+b2);//b2:true boolean b3 = coll.remove("赵四");
System.out.println("b3:"+b3);//b3:false
System.out.println(coll);//[张三, 李四, 田七] /*
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
包含返回true
不包含返回false
*/
boolean b4 = coll.contains("李四");
System.out.println("b4:"+b4);//b4:true boolean b5 = coll.contains("赵四");
System.out.println("b5:"+b5);//b5:false //public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回false
boolean b6 = coll.isEmpty();
System.out.println("b6:"+b6);//b6:false //public int size(): 返回集合中元素的个数。
int size = coll.size();
System.out.println("size:"+size);//size:3 //public Object[] toArray(): 把集合中的元素，存储到数组中。
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);//张三 李四 田七
} //public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在
coll.clear();
System.out.println(coll);//[]
System.out.println(coll.isEmpty());//true
}
}
2 Collection集合之Iterator迭代器
2.1 Iterator接口
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。
Iterator接口的常用方法如下：
public E next():返回迭代的下一个元素。public boolean hasNext():如果仍有元素可以迭代，则返回 true。
迭代器的代码实现：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;/*
java.util.Iterator接口:迭代器(对集合进行遍历)
有两个常用的方法
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
判断集合中还有没有下一个元素,有就返回true,没有就返回false
E next() 返回迭代的下一个元素。
取出集合中的下一个元素
Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。 迭代器的使用步骤:
1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
3.使用Iterator接口中的方法next取出集合中的下一个元素
*/
public class Demo01Iterator {
public static void main(String[] args) {
//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("姚明");
coll.add("科比");
coll.add("麦迪");
coll.add("詹姆斯");
coll.add("艾弗森"); /*
1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
注意:
Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
*/
//1. 多态 接口 实现类对象
Iterator<String> it = coll.iterator();
//2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
boolean b = it.hasNext();
System.out.println(b);//true
//3.使用Iterator接口中的方法next取出集合中的下一个元素
String s = it.next();
System.out.println(s);//姚明 b = it.hasNext();
System.out.println(b);
s = it.next();
System.out.println(s); b = it.hasNext();
System.out.println(b);
s = it.next();
System.out.println(s); b = it.hasNext();
System.out.println(b);
s = it.next();
System.out.println(s); b = it.hasNext();
System.out.println(b);
s = it.next();
System.out.println(s); b = it.hasNext();
System.out.println(b);//没有元素,返回false
s = it.next();//没有元素,再取出元素会抛出NoSuchElementException没有元素异常
System.out.println(s);*/
/*
发现使用迭代器取出集合中元素的代码,是一个重复的过程
所以可以使用循环优化
不知道集合中有多少元素,使用while循环
循环结束的条件,hasNext方法返回false
*/
while(it.hasNext()){
String e = it.next();
System.out.println(e);
}
System.out.println("----------------------");
for(Iterator<String> it2 = coll.iterator();it2.hasNext();){
String e = it2.next();
System.out.println(e);
}
}
}
迭代器的实现原理：
3 泛型
3.1 泛型的概念：
3.2 泛型的定义和使用
3.2.1 定义和使用含有泛型的类
//定义一个泛型
public class GenericClass<g> {//g随便改成一个字母都行，主要是尖括号
private g name; public g getName() {
return name;
} public void setName(g name) {
this.name = name;
}
}//测试
public class GenericClassTest {
public static void main(String[] args) {
GenericClass<Integer> gc = new GenericClass<>();//创建对象的时候才确定泛型的实际类型，这里使用的是Integer
gc.setName();
System.out.println(gc.getName()); GenericClass<String> gc1 = new GenericClass<>();//也可以使用String类型
gc1.setName("小明明");
System.out.println(gc1.getName());
}
}
3.2.2 定义和使用含有泛型的方法
//创建一个含有泛型方法的类
public class GenericMethod {
public <e> void gmMethod(e ele){
System.out.println(ele);
} public static <m> void staticGm(m mm){
System.out.println(mm);
}
}
//测试
public class GenericMethodTest {
public static void main(String[] args) {
GenericMethod method1 = new GenericMethod();
method1.gmMethod();
method1.gmMethod("aaaaaaa");
method1.gmMethod(true); GenericMethod method2 = new GenericMethod();
method2.staticGm();
GenericMethod.staticGm("静态方法建议用类名.静态方法名调用");
}
}
3.2.3 定义和使用含有泛型的接口
//创建一个含有泛型的接口
public interface GenericInterface<e> {
void method(e m);
}//第一个方法：创建实现类的时候就指明实现类的类型
public class GenericInterfaceImp implements GenericInterface<String > { @Override
public void method(String m) {
System.out.println("重写了抽象类的方法");
System.out.println(m);
}
}//第二个方法：创建实现类的时候，泛型跟着接口的泛型走，创建对象的时候才指明泛型的具体类型
public class GenericInterfaceImp2<e> implements GenericInterface<e> {//注意这两个地方都需要加尖括号<>，而且里面的类型与接口的泛型一致
@Override
public void method(e m) {
System.out.println(m);
}
}//测试
public class GenericInterfaceImpTest {
public static void main(String[] args) {
GenericInterfaceImp imp = new GenericInterfaceImp();
imp.method("传递的参数就是这个" ); GenericInterfaceImp2<Integer> imp2 = new GenericInterfaceImp2<Integer>();//注意要在这里创建时指明泛型的具体类型，
//否则下面的方法调用的参数会是Object类型
imp2.method(1111);
}
}
3.2.4 泛型的通配符
import java.util.ArrayList;
import java.util.Iterator;public class GenericInterfaceImpTest {
public static void main(String[] args) {
GenericInterfaceImp imp = new GenericInterfaceImp();
imp.method("传递的参数就是这个" ); GenericInterfaceImp2<Integer> imp2 = new GenericInterfaceImp2<Integer>();
imp2.method(1111); System.out.println("====测试通配符====");
ArrayList<String> list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(123);
list2.add(456);
printArrayList(list1);
printArrayList(list2);
} public static void printArrayList(ArrayList<?> list){ //Iterator iterator = new Iterator();//Iterator是一个接口，不能直接new，
Iterator<?> it = list.iterator();//集合list是什么类型，迭代器就是什么类型。测试中发现，问号不写也不会报错
//Iterator it = list.iterator();//需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊：
// Collection对象（可以换成具体的如ArrayList对象，也可以就用Collection对象）有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
while (it.hasNext()){
System.out.println(it.next());
}
}
}//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 哈希值
/*
哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)
在Object类有一个方法,可以获取对象的哈希值
int hashCode() 返回该对象的哈希码值。
hashCode方法的源码:
public native int hashCode();
native:代表该方法调用的是本地操作系统的方法
*/
public class Demo01HashCode {
public static void main(String[] args) {
//Person类继承了Object类,所以可以使用Object类的hashCode方法
Person p1 = new Person();
int h1 = p1.hashCode();
System.out.println(h1);// Person p2 = new Person();
int h2 = p2.hashCode();
System.out.println(h2);//42121758 /*
toString方法的源码:
return getClass().getName() + "@" + Integer.toHexString(hashCode());
*/
System.out.println(p1);//@75412c2f
System.out.println(p2);//@282ba1e
System.out.println(p1==p2);//false /*
String类的哈希值
String类重写了Obejct类的hashCode方法
*/
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());//
System.out.println(s2.hashCode());// System.out.println("重地".hashCode());//1179395 巧合
System.out.println("通话".hashCode());//
}
}
5.1.2 HashSet集合存储数据的结构（哈希表）
Set集合（如java.util.HashSet 、java.util.LinkedHashSet 这两个集合）不允许存储重复元素的原理：
注意：使用set集合，需要重写hashcode和equals方法。因为要保证set中元素唯一，重写的方法可以保证。使用list集合则不必重写。
6 Collections 集合工具类
- `public static <T> boolean addAll(Collection<T> c, T... elements) `:一次性往集合中添加一些元素，不必使用add添加多次
- `public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。
- `public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序（默认升序或者降序）。
- `public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。（comparator就是比较器的规则）
addall和shuffle方法实例：
import java.util.ArrayList;
import java.util.Collections;/*
- java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
- public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
- public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
*/
public class Demo01Collections {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//往集合中添加多个元素
/*list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");*/ //public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
Collections.addAll(list,"a","b","c","d","e"); System.out.println(list);//[a, b, c, d, e] //public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
Collections.shuffle(list);
System.out.println(list);//[b, d, c, a, e], [b, d, c, a, e]
}
}
两种比较方法的实例：
//第一种：public static <T> void sort(List<T> list)
//对自定义的Person类进行排序。
//首先定义一个Person类
public class Person implements Comparable<Person>{
private String name;
private int age; public Person() {
} public Person(String name, int age) {
this.name = name;
this.age = age;
} @Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} //重写排序的规则
@Override
public int compareTo(Person o) {
//return 0;//认为元素都是相同的
//自定义比较的规则,比较两个人的年龄(this,参数Person)
//return this.getAge() - o.getAge();//年龄升序排序
return o.getAge() - this.getAge();//年龄升序排序
}
}
import java.util.ArrayList;
import java.util.Collections;/*
- java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。 注意:
sort(List<T> list)使用前提
被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则 Comparable接口的排序规则:
自己(this)-参数:升序
*/
public class Demo02Sort {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
System.out.println(list01);//[1, 3, 2] //public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
Collections.sort(list01);//默认是升序 System.out.println(list01);//[1, 2, 3] ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("c");
list02.add("b");
System.out.println(list02);//[a, c, b] Collections.sort(list02);
System.out.println(list02);//[a, b, c] ArrayList<Person> list03 = new ArrayList<>();
list03.add(new Person("张三",18));
list03.add(new Person("李四",20));
list03.add(new Person("王五",15));
System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}] Collections.sort(list03);
System.out.println(list03);
}
}
//第二种：
//首先自定义学生类
public class Student {
private String name;
private int age; public Student() {
} public Student(String name, int age) {
this.name = name;
this.age = age;
} @Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;/*
- java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。 Comparator和Comparable的区别
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个 Comparator的排序规则:
o1-o2:升序
*/
public class Demo03Sort {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
System.out.println(list01);//[1, 3, 2] Collections.sort(list01, new Comparator<Integer>() {
//重写比较的规则
@Override
public int compare(Integer o1, Integer o2) {
//return o1-o2;//升序
return o2-o1;//降序
}
}); System.out.println(list01); ArrayList<Student> list02 = new ArrayList<>();
list02.add(new Student("a迪丽热巴",18));
list02.add(new Student("古力娜扎",20));
list02.add(new Student("杨幂",17));
list02.add(new Student("b杨幂",18));
System.out.println(list02); /*Collections.sort(list02, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//按照年龄升序排序
return o1.getAge()-o2.getAge();
}
});*/ //扩展:
Collections.sort(list02, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//按照年龄升序排序
int result = o1.getAge()-o2.getAge();
//如果两个人年龄相同,再使用姓名的第一个字比较
if(result==0){
result = o1.getName().charAt(0)-o2.getName().charAt(0);
}
return result;
} }); System.out.println(list02);
}
}
第二部分 Map集合
1 Map集合概述
Collection 中的集合称为单列集合， Map 中的集合称为双列集合。
Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
总结：Map中， K不允许重复，V可以重复
Map接口有多个子类，常用的是HashMap集合、LinkedHashMap集合。
HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需
要重写键的hashCode()方法、equals()方法。
LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链
表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的
hashCode()方法、equals()方法。
tips：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数
据类型可以相同，也可以不同。
import java.util.HashMap;
import java.util.Map;/*
java.util.Map<k,v>集合
Map集合的特点:
1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
3.Map集合中的元素,key是不允许重复的,value是可以重复的
4.Map集合中的元素,key和value是一一对应
java.util.HashMap<k,v>集合 implements Map<k,v>接口
HashMap集合的特点:
1.HashMap集合底层是哈希表:查询的速度特别的快
JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
LinkedHashMap的特点:
1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的
*///Map集合中常用的方法演示
public class DemoMap {
public static void main(String[] args) {
show04();
} /*
boolean containsKey(Object key) 判断集合中是否包含指定的键。
包含返回true,不包含返回false
*/
private static void show04() {
//创建Map集合对象
Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178); boolean b1 = map.containsKey("赵丽颖");
System.out.println("b1:"+b1);//b1:true boolean b2 = map.containsKey("赵颖");
System.out.println("b2:"+b2);//b2:false
} /*
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
返回值:
key存在,返回对应的value值
key不存在,返回null
*/
private static void show03() {
//创建Map集合对象
Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178); Integer v1 = map.get("杨颖");
System.out.println("v1:"+v1);//v1:165 Integer v2 = map.get("迪丽热巴");
System.out.println("v2:"+v2);//v2:null
} /*
public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
返回值:V
key存在,v返回被删除的值
key不存在,v返回null
*/
private static void show02() {
//创建Map集合对象
Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178);
System.out.println(map);//{林志玲=178, 赵丽颖=168, 杨颖=165} Integer v1 = map.remove("林志玲");
System.out.println("v1:"+v1);//v1:178 System.out.println(map);//{赵丽颖=168, 杨颖=165} //int v2 = map.remove("林志颖");//自动拆箱 NullPointerException
Integer v2 = map.remove("林志颖");
System.out.println("v2:"+v2);//v2:null System.out.println(map);//{赵丽颖=168, 杨颖=165}
} /*
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
返回值:v
存储键值对的时候,key不重复,返回值V是null
存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
*/
private static void show01() {
//创建Map集合对象,多态
Map<String,String> map = new HashMap<>(); String v1 = map.put("李晨", "范冰冰1");
System.out.println("v1:"+v1);//v1:null String v2 = map.put("李晨", "范冰冰2");
System.out.println("v2:"+v2);//v2:范冰冰1 System.out.println(map);//{李晨=范冰冰2} map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");
System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
}
}
2 Map集合遍历–键找值方式
分析步骤：
1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法: keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法: get(K key)
public class MapDemo {
public static void main(String[] args) {
//创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
//添加元素到集合
map.put("胡歌", "霍建华");
map.put("郭德纲", "于谦");
map.put("薛之谦", "大张伟");Set<String> keys = map.keySet();
// 遍历键集 得到 每一个键
for (String key : keys) {
//key 就是键
//获取对应值
String value = map.get(key);
System.out.println(key+"的CP是："+value);
}
}
}
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集合遍历–键值对方式 实例
public class MapDemo02 {
public static void main(String[] args) {
// 创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
// 添加元素到集合
map.put("胡歌", "霍建华");
map.put("郭德纲", "于谦");
map.put("薛之谦", "大张伟");
// 获取 所有的 entry对象 entrySet
Set<Entry<String,String>> entrySet = map.entrySet();
// 遍历得到每一个entry对象
for (Entry<String, String> entry : entrySet) {
// 解析
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"的CP是:"+value);
}
}
}
