集合
一、Collection
1.集合知识回顾
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可随时发生改变
2.集合类体系结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-siJ53W8C-1617872850877)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210323082455578.png)]
接口不能直接创建对象并且实例化的，必须通过具体的实现类来创建对象并且实例化。
1.3 Collection
Collection集合概述
· 是单例集合的顶层接口，他表示一组对象，这些对象也称为Clollection的元素
· JDK不提供此接口的任何直接实现，他提供更具体的子接口 （如set和list）实现
创建Collection集合的对象
· 多态的方式
· 具体的实现类ArrayList
1.4 Collection集合常用方法
| 方法名 | 说明 |
|---|---|
| boolean add (String) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
1.5 Collection集合的遍历
Iterator：迭代器，集合的专用遍历方式
●Iterator iterator() : 返回此集合中元素的迭代器,通过集合的iterator()方法得到
●迭代器是通过集合的iterator()方法得到的， 所以我们说它是依赖于集合而存在的
Iterator中的常用方法
●E next() : 返回迭代中的下一-个元素
●boolean hasNext():如果迭代具有更多元素,则返回true
1.6 集合的使用步骤
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t7NJ34Ry-1617872850883)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210323111836725.png)]
案例: Collection集合存储学生对象并遍历
需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
思路:
①定义学生类
②创建Collection集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合(迭代器方式)
public class TestCollection {
public static void main(String[] args) {
//创建Collection对象
Collection<Student> c = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",30);
Student s3 = new Student("王祖贤",30);
//把学生添加到集合中
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合（迭代器）
Iterator<Student> it = c.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s.getName() + " " + s.getAge());
}
}
}
二、List
2.1 List集合概述和特点
List集合概述
● 有序集合（也成为序列），用户可以精确控制列表中每一个元素的插入位置。用户可以通过整数索引访问，并搜索列表中的元素
● 与set集合不同，列表通常允许重复的元素
List集合特点
● 有序：存储和取出的元素一致
● 可重复： 存储的元素可以重复
public static void main(String[] args) {
// 创建集合对象
List<String> list = new ArrayList<>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("world");
// System.out.println(list);
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
2.2 List集合特有方法
| 方法名 | 说明 |
|---|---|
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
案例: List集合存储学生对象并遍历
需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
思路:
①定义学生类
②创建List集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合(迭代器方式，for循环方式)
package com.guo.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestList02 {
public static void main(String[] args) {
// 创建List集合
List<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",35);
Student s3 = new Student("王祖贤",33);
//把学生添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
//遍历集合（迭代器）
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s.getName() + " " + s.getAge());
}
System.out.println("---------------------------");
//for循环遍历
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName()+" "+s.getAge());
}
}
}
2.3 并发修改异常
并发修改异常
●ConcurrentModificationException
产生原因
●迭代器遍历的过程中， 通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案.
●用for循环遍历， 然后用集合对象做对应的操作即可
2.4 Listlterator
Listlterator:列表迭代器
●通过List集 合的listlterator () 方法得到，所以说它是List集合特有的迭代器
●用于允许程序员沿任一方向遍历列表的列表迭代器， 在迭代期间修改列表，并获取列表中迭代器的当前位置
Lstlterator中的常用方法
●E next(): 返回迭代中的下一个元素
●boolean hasNext0:如果迭代具有更多元素，则返回true
●E previous（）:返回列表中的上 一个元素
●boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回true
●void add(E e):将指定的元素插入列表
案例: List集合存储学生对象用三种方式遍历
需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
思路:
①定义学生类
②创建List集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合 迭代器：集合特有的遍历方式
for循环：带有索引的遍历方式
增强for：最方便的遍历方式
package com.guo.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestList03 {
public static void main(String[] args) {
// 创建List集合
List<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
//遍历集合（迭代器）
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + " " + s.getAge());
}
System.out.println("---------------------------");
//for循环遍历
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + " " + s.getAge());
}
System.out.println("-------------");
//增强for循环
for (Student s : list){
System.out.println(s.getName()+" "+s.getAge() );
}
}
}
2.6 数据结构
数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率
2.7 常见数据结构之栈
数据进入栈模型的过程称为：压/进栈
数据离开栈模型的过程称为：弹/出栈
栈是一种数据先进后出的模型
2.8 常见数据结构之队列
数据从后端进入队列模型的过程称为:入队列
数据从前端离开队列模型的过程称为:出队列
队列是一种数据先进先出的模型
2.9 常见数据结构之数组
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低
数组是一种查询快，增删慢的模型
2.10 常见数据结构之链表
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bUxZ22tg-1617872850886)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210325103247697.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K2nS40md-1617872850894)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210325103536042.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b0g06sGT-1617872850898)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210325103658569.png)]
2.11 List集合子类特点
List集合常用子类: ArrayList, LinkedList
● ArrayList: 底层数据结构是数组，查询快,增删慢
● LinkedList: 底层数据结构是链表，查询慢,增删快
2.12 LinkedList集合的特有功能
| 方法名 | 说明 |
|---|---|
| public void addFirst(E e) | 在该列表开头插入指定的元素 |
| public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元素 |
| public E getLast(） | 返回此列表中的最后一个元素 |
| public E removeFirst(） | 从此列表中删除并返回第一个元素 |
| public E removeLast(） | 从此列表中删除并返回最后一个元素 |
三、set集合
3.1 Set集合概述和特点
Set集合特点
- 不包含重复元素的集合
- 米有带索引的方法，所以不能使用普通的for循环
HashSet：对集合的迭代顺序不做任何保证
Set集合练习
- 存储字符串并遍历
package com.guo.Set;
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
// 创建集合对象
Set<String> set = new HashSet<String>();
set.add("hello");
set.add("world");
set.add("java");
set.add("world");
for (String s : set){
System.out.println(s);
}
}
}
3.2 哈希值
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
- public int hashCode：返回对象的哈希值
对象的哈希值特点
- 同一个对象多此调用hashCode()方法返回的哈希值是相同的
- 默认情况下，不同对象的哈希值是不同的。而重写的hashCode()方法，可以实现让不同对象的哈希值相同。
package com.guo.Set;
public class hashCodeDemo {
public static void main(String[] args) {
// 创建学生的对象
Student s1 = new Student("林青霞",30);
// 同一个对象多此调用hashCode()方法返回的哈希值是相同的
System.out.println("----------------");
System.out.println(s1.hashCode()); //1163157884
System.out.println(s1.hashCode());//1163157884
System.out.println("----------------");
// 默认情况下，不同对象的哈希值是不同的。
// 重写的hashCode()方法，可以实现让不同对象的哈希值相同。
Student s2 = new Student("林青霞",30);
System.out.println(s2.hashCode()); //1956725890
System.out.println("----------------");
System.out.println("hello".hashCode()); //99162322
System.out.println("world".hashCode()); //113318802
System.out.println("java".hashCode());//3254818
System.out.println("种地".hashCode()); //988931
System.out.println("玉米".hashCode()); //948746
}
}
3.3 HashSet集合概述合特点
HashSet集合特点：
- 底层数据结构是哈希表
- 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有自带索引的方法，所以不能使用普通的for循环（可以使用迭代器和增强for循环）
- 由于是set集合，所以是不包含重复元素的集合
package com.guo.Set;
import java.util.HashSet;
public class hashSetDemo {
public static void main(String[] args) {
// 创建集合对象
HashSet<String> sh = new HashSet<String>();
// 添加元素
sh.add("hello");
sh.add("world");
sh.add("java");
sh.add("world");
System.out.println(sh); //[world, java, hello]
//遍历
for (String s : sh){
System.out.println(s); //world java hello
}
}
}
3.4 hashSet集合保证元素唯一性的源码分析
HashSet集合添加一个元素的过程：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hjWvGafY-1617872850900)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210329100623601.png)]
HashSet集合存储元素：
- 要保证元素唯一性，需要重写哈市Code()和equals()
3.5 常见的数据结构之哈希表
哈希表
- JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
- JDK8以后，在昌都比较长的时候，底层实现了优化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o3ny0oSM-1617872850901)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210329101455937.png)]
HashSet集合存储学生对象并遍历
需求:创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求:学生对象的成员变量值相同，我们就认为是同一个对象
思路:
①定义学生类
②创建HashSet集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合 增强for
⑥在学生类中重写两个方法：
hashcode()和equals() 自动生成
package com.guo.Set;
import java.util.HashSet;
public class hashSetDemo01 {
public static void main(String[] args) {
//创建集合对象
HashSet<Student> s = new HashSet<Student>();
//创建学生对象
Student s1 = new Student("林青霞",30);
Student s2 = new Student("张曼玉",25);
Student s3 = new Student("张国荣",24);
Student s4 = new Student("小鱼儿",18);
//添加学生对象
s.add(s1);
s.add(s2);
s.add(s3);
s.add(s4);
for (Student a : s){
System.out.println(a.getName()+" "+a.getAge());
}
}
}
3.6 LinkedHashSet集合概述和特点
LinkedHashSet集合特点
●哈希表和链表实现的Set接口， 具有可预测的迭代次序
●由链表保证元素有序,也就是说元素的存储和取出顺序是一致的
●由哈希表保证元索唯一 , 也就是说没有重复的元素
LinkedHashSet集合练习
●存储字符串并遍历
package com.guo.Set;
import java.util.LinkedHashSet;
public class LinkedHashCode {
public static void main(String[] args) {
LinkedHashSet<String> str = new LinkedHashSet<String>();
str.add("hello");
str.add("world");
str.add("java");
str.add("hello");
for (String s : str){
System.out.println(s);
}
}
}
3.7 TreeSet集合概述和特点
TreeSet集合特点
元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator comparator):根据指定的比较器进行排序
-
没有带索引的方法, 所以不能使用普通for循环遍历
-
由于是Set集合，所以不包含重复元素的集合
TreeSet集合练习
- 存储整数并遍历
package com.guo.Set;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Integer> it = new TreeSet<>();
it.add(10);
it.add(20);
it.add(30);
it.add(40);
it.add(30);
for (Integer s : it){
System.out.println(s);
}
}
}
3.8自然排序Comparable的使用
●存储学生对象并遍历， 创建TreeSet集合使用无参构造方法
●要求: 按照年龄从小到大排序,年龄相同时，按照姓名的字母顺序排序
结论
●用TreeSet集合存储自定义对象， 无参构造方法使用的是自然排序对元索进行排序的
●自然排序, 就是让元素所属的类实现Compatarable ()接口，重写compareTo(T o)方法
●重写方法时，一 定要注意排序规则必须按照要求的主要条件和次要条件来写
3.9比较器排序Comparator的使用
●存储学生对象并遍历， 创建TreeSet集合使用带参构造方法
要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
结论
●用TreeSet集合存储自定义对象， 带参构造方法使用的是比较器排序对元索进行排序的
●比较器排序, 就是让集合构造方法接收Comparator的实现类对象，重写compare(To 1,To 2)方法
●重写方法时，一定要注意排序规则必须按照要求的主 要条件和次要条件来写
四、泛型
4.1 泛型概述
泛型:是DK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为-一个参数
一提到参数， 最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接[ ]中，分别被称为泛型类泛型方法、泛型接口
泛型定义格式:
●<类型>:指定一种类型的格式。这里的类型可以看成是形参
●<类型1,类型…>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
●将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
泛型的好处:
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
4.2泛型类
泛型类的定义格式:
●格式: 修饰符class类名<类型>{ } .
●范例: public class Generic{ }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
4.3 泛型方法
泛型方法的定义格式:
格式:修饰符<类型>返回值类型方法名(类型变量名){ }
●范例: public void show(T t) { }
public class Generic{
public <T> void show(T t){
System.out.println(t);
}
}
public class GenericDemo {
public static void main(String[] args) {
Generic g = new Generic();
g.show("林青霞");
g.show(30);
g.show(true);
g.show(12.34);
}
}
4.4 泛型接口
泛型接口的定义格式：
- 格式：修饰符interface 接口名<类型>{}
- 范例：public interface Generic{}
4.5 类型通配符
为了表示各种泛型List的父类，可以使用类型通配符
-
类型通配符: <?>
-
List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
-
这种带通配符的List仅表示它是各种泛型List的父类,并环能把元索添加到其中
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类
泛型List的父类,可以使用类型通配符的上限
-
类型通配符上限: <? extends类型>
-
List<? extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的.上限，我们也可以指定类型通配符的下限
-
类型通配符下限: <?super 类型>
-
List<? super Number>:它表示的类型是Number或者其父类型
-
package com.guo.泛型.类型通配符; import java.util.ArrayList; import java.util.List; public class Generic { public static void main(String[] args) { //类型通配符<?> List<?> list1 = new ArrayList<Object>(); List<?> list2 = new ArrayList<Number>(); List<?> list3 = new ArrayList<Integer>(); // 类型通配符上限: <? extends类型> System.out.println("----------------------"); // List<? extends Number> list4 = new ArrayList<Object>(); List<? extends Number> list5 = new ArrayList<Number>(); List<? extends Number> list6 = new ArrayList<Integer>(); // 类型通配符下限: <?super 类型> System.out.println("----------------------"); List<? super Number> list7 = new ArrayList<Number>(); List<? super Number> list8 = new ArrayList<Object>(); // List<? super Number> list9 = new ArrayList<Integer>(); } }
4.6 可变参数
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
●格式: 修饰符返回值类型方法名(数据类型…变量名){ }
●范例: public static int sumit…a) { }
可变参数注意事项
- 这里的变量其实是一个数组
- 如股票一个方法有多个参数，包含可变参数，可变参数要放在最后
package com.guo.泛型.可变参数;
public class ArrayDemo {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println(sum(10,20,30,40));
System.out.println(sum(10,20,30,40,50,60));
}
// public static int sum(int b,int...a){
// return 0;
// }
public static int sum(int...a){
int sum = 0;
for (int i : a){
sum+=i;
}
return sum;
}
// public static int sum(int a, int b){
// return a+b;
// }
// public static int sum(int a, int b,int c ){
// return a+b+c;
// }
// public static int sum(int a, int b,int c ,int d){
// return a+b+c+d;
// }
}
4.7 可变参数的使用
Arrays工具类中有一个静态方法：
- public static List alist(T…a)：返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删改操作，可以做修改操作
List接口中有一个静态方法：
- public static List of(E… elements)：返回包含任何数量元素的不可变列表
- 返回的集合不能做增删改操作
Set接口中有一个静态方法：
- public static Set of(F… elements)：返回一个包含任意数量元素的不可变集合
- 在给元素的时候，不能给重复的元素
- 返回的集合不能做增删改操作，没有 修改的方法
package com.guo.泛型.可变参数;
public class ArrayDemo01 {
public static void main(String[] args) {
// List<String> list = Arrays.asList("hello", "world", "java");
//
// list.add("javaee"); //UnsupportedOperationException 不支持请求的操作
// list.remove("world");//UnsupportedOperationException
// list.set(1,"javaee");
// System.out.println(list);
// List<String> list = List.of("hello","world","java","world");
// list.add("javaee"); //UnsupportedOperationException 不支持请求的操作
// list.remove("java");//UnsupportedOperationException
// list.set(1,"javaee");//UnsupportedOperationException
// Set<String> list = Set.of("hello","world","java","world");
// Set.add("javaee"); //UnsupportedOperationException 不支持请求的操作
// Set.remove("java");//UnsupportedOperationException
// Set.set(1,"javaee");//UnsupportedOperationException
}
}
五、Map集合
5.1 Map集合的概述和使用
Map集合概述
-
Interface Map<K,V> K：键的类型；V：值的类型
-
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
-
举例：学生的学号和姓名
itheima001 林青霞
itheima002 张曼玉
itheima003 王祖贤
创建Map集合的对象
- 多态的方式
- 具体的实现类HashMap
package com.guo.Map集合;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
map.put("itheima001","林青霞");
map.put("itheima002","王祖贤");
map.put("itheima003","张曼玉");
map.put("itheima003","柳岩"); //第一次出现是赋值，第二次出现替换
System.out.println(map);
}
}
5.2 Map集合的基本功能
| 方法名 | 说明 |
|---|---|
| V put(K key,V value) | 添加元素 |
| V remove(Object key) | 根据键删除键值对元素 |
| void clear() | 移除所有的键值对元素 |
| boolean containsKey(Object key) | 判断集合是否包含指定的键 |
| boolean containsValue(Object value) | 判断集合是否包含指定的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中键值对的个数 |
package com.guo.Map集合;
import java.util.HashMap;
import java.util.Map;
public class MapDemo01 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
map.put("白龙马","唐僧");
// System.out.println(map.remove("郭靖"));
// System.out.println(map.remove("郭襄")); // null
// map.clear(); //{}
// System.out.println(map.containsKey("郭靖")); //true
// System.out.println(map.containsKey("郭襄")); //false
// System.out.println(map.isEmpty()); //false
//输出
System.out.println(map);
}
}
5.3 Map集合的获取功能
5.4 Map集合的获取功能
| 方法名 | 说明 |
|---|---|
| V get(Object key) | 根据键获取值 |
| Set keySet() | 获取所有键的集合 |
| Collectionvalues() | 获取所有值的集合 |
| Set<Map.Entry<K,V>>entrySet() | 获取所有键值对对象的集合 |
package com.guo.Map集合;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class MapDemo02 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<>();
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
map.put("白龙马","唐僧");
// String s = map.get("张无忌"); //赵敏
// String s = map.get("张三丰"); //null
// Set<String> keySet = map.keySet();
// for (String s : keySet){
// System.out.println(s);
// }
Collection<String> values = map.values();
for (String s : values){
System.out.println(s);
}
}
}
5.5 Map集合的遍历（2）
元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
遍历思路
- 获取所有结婚证的集合
- 遍历结婚证的集合，得到每一个结婚证
- 根据结婚证获取丈夫和妻子
转换为Map集合中的操作：
-
获取所有键值对对象的集合
Set<Map.Entry<K,V>>entrySet() 获取所有键值对对象的集合
-
遍历键值对对象的集合，得到每一个键值对对象
用增强for实现，得到每一个Map.Entry
-
根据键值对对象获取键和值
用getKey()的到键
用getValue()的到值
package com.guo.Map集合.集合嵌套之ArrayList嵌套;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class ArrayListcludeHashMapDemo {
public static void main(String[] args) {
//创建ArrayList集合
ArrayList<HashMap<String,String>> arr = new ArrayList<HashMap<String,String>>();
//创建HashMap集合，并添加键值对元素
HashMap<String,String> hm1 = new HashMap<String,String>();
hm1.put("孙策","大乔");
hm1.put("周瑜","小乔");
//把HashMap作为元素添加到ArrayList集合
arr.add(hm1);
HashMap<String,String> hm2 = new HashMap<String,String>();
hm1.put("郭靖","黄蓉");
hm1.put("杨过","小龙女");
//把HashMap作为元素添加到ArrayList集合
arr.add(hm2);
HashMap<String,String> hm3 = new HashMap<String,String>();
hm1.put("令狐冲","任盈盈");
hm1.put("零平之","越扣林山");
//把HashMap作为元素添加到ArrayList集合
arr.add(hm3);
//遍历ArrayList集合
for (HashMap<String,String> hm : arr){
Set<String> keySet = hm.keySet();
for (String key : keySet){
String Value = hm.get(key);
System.out.println(key+" "+Value);
}
}
}
}
案例: HashMap集合存储ArrayList元素并遍历
需求:创建一个HashMap集合,存储三E 个键值对元素,每一个键值对元素的键是String, 值是ArrayList,
每一个ArrayList的元索是String，并遍历
思路:
①创建HashMap集合
②创建ArrayList集合, 并添加元素
③把ArrayList作为元素添加到HashMap集合
④遍历HashMap集合
package com.guo.Map集合.集合嵌套之ArrayList嵌套;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
需求:创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String, 值是Arraylist,
每一个ArrayList的元素是String,并遍历
思路:
1:创建HashMap集合
2:创建Arraylist集合，并添加元素
3:把ArrayL ist作为元素添加到HashMap集合
4 :遍历HashMap集合
给出如下的数据:
第一个ArrayL ist集合的元素: (三国演义)
诸葛亮
赵云
第二个ArrayList集合的元素: (西游记)
唐僧
孙悟空
第三个ArrayList集合的元素: (水浒传) I
武松
鲁智深
*/
public class HashMapLinclideArrayListDemo {
public static void main(String[] args) {
//创建HashMap集合
HashMap<String,ArrayList<String>> hm = new HashMap<String,ArrayList<String>>();
// 2:创建Arraylist集合，并添加元素
ArrayList<String> sgyy = new ArrayList<String>();
sgyy.add("诸葛亮");
sgyy.add("赵云");
// 3:把ArrayList作为元素添加到HashMap集合
hm.put("三国演义",sgyy);
ArrayList<String> xyj = new ArrayList<String>();
xyj.add("唐僧");
xyj.add("孙悟空");
hm.put("西游记",xyj);
ArrayList<String> shz = new ArrayList<String>();
shz.add("李逵");
shz.add("史进");
hm.put("水浒传",shz);
// 4 :遍历HashMap集合
Set<String> keySet = hm.keySet();
for (String s : keySet){
System.out.println(s);
ArrayList value = hm.get(s);
for (Object w: value){
System.out.println(w);
}
}
}
}
案例：统计字符串中每个字符出现的次数
需求:键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
思路:
①键盘录入一个字符串
②创建HashMap集合, 键是Character,值是Integer
③遍历字符串,得到每一个字符
④拿得到的每-个字符作为键到HashMap集合中去找对应的值，看其返回值
如果返回值是null:说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果返回值不是null:说明该字符在HashMap集合中存在，把该值加1,然后重新存储该字符和对应的值
⑤遍历HashMap集合，得到键和值，按照要求进行拼接
⑥输出结果
package com.guo.Map集合;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class itheima {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner in = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = in.nextLine();
//创建HashMap集合, 键是Character,值是Integer
TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
//遍历字符串,得到每一个字符
for (int i = 0; i < line.length(); i++) {
char key = line.charAt(i);
//拿得到的每-个字符作为键到HashMap集合中去找对应的值，看其返回值
Integer value = hm.get(key);
if (value==null){
//如果返回值是null:说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
hm.put(key,1);
}else{
//如果返回值不是null:说明该字符在HashMap集合中存在，把该值加1,然后重新存储该字符和对应的值
value++;
hm.put(key,value);
}
}
//遍历HashMap集合，得到键和值，按照要求进行拼接
StringBuilder sb = new StringBuilder();
Set<Character> keySet = hm.keySet();
for (Character key : keySet){
Integer value = hm.get(key);
sb.append(key).append("(").append(value).append(")");
}
String relues = sb.toString();
System.out.println(relues);
}
}
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
