java基础（7）集合与泛型
第一部分：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(1); 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(1); method1.gmMethod("aaaaaaa"); method1.gmMethod(true); GenericMethod method2 = new GenericMethod(); method2.staticGm(222); 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);//1967205423 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());//96354 System.out.println(s2.hashCode());//96354 System.out.println("重地".hashCode());//1179395 巧合 System.out.println("通话".hashCode());//1179395 } }
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); } } }
