首页 技术 正文
技术 2022年11月23日
0 收藏 874 点赞 3,600 浏览 16797 个字

第一部分: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);
}
    }
}

迭代器的实现原理:

java基础(7)集合与泛型

3 泛型

3.1 泛型的概念:

java基础(7)集合与泛型

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集合存储数据的结构(哈希表)

java基础(7)集合与泛型

Set集合(如java.util.HashSet 、java.util.LinkedHashSet 这两个集合)不允许存储重复元素的原理:

java基础(7)集合与泛型

注意:使用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);
}
}
}

 

相关推荐
python开发_常用的python模块及安装方法
adodb:我们领导推荐的数据库连接组件bsddb3:BerkeleyDB的连接组件Cheetah-1.0:我比较喜欢这个版本的cheeta…
日期:2022-11-24 点赞:878 阅读:9,116
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接:http://www.codeforces.com/contest/660/problem/CDes…
日期:2022-11-24 点赞:807 阅读:5,588
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
日期:2022-11-24 点赞:569 阅读:6,434
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
日期:2022-11-24 点赞:733 阅读:6,204
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式,并且由于涉及到要把拍到的照片显…
日期:2022-11-24 点赞:512 阅读:7,840
Struts的使用
一、Struts2的获取  Struts的官方网站为:http://struts.apache.org/  下载完Struts2的jar包,…
日期:2022-11-24 点赞:671 阅读:4,925