集合
如何学习本小节?
根据API文档使用步骤查找集合类;
查找集合类
查看该集合所属接口名
查看构造方法
背诵
创建集合对象
创建元素对象
添加元素到集合中
遍历集合
代码知识∶多练习，多操作
记住集合体系中各接口集合的特点
练习集合的基本操作(四个步骤）(重点)
集合简介
什么是集合?
简称集，是用来存储多个元素的容器
集合和数组的区别
◆元素类型
集合∶引用类型（存储基本类型时自动装箱)
数组:基本类型、引用类型
◆元素个数
集合:不固定，可任意扩容
数组:固定，不能改变容量
◆集合的好处
不受容器大小限制，可以随时添加、删除元素提供了大量操作元素的方法（判断、获取等)
Java的集合体系
-
单例集合(Collection)
List: ArrayList
Set: HashSet
-
双例集合(Map:key,value)
Map: HashMap
Collections工具类
Collections简介
针对集合进行操作的工具类。
成员方法：
sort(List<T>)：根据元素的自然顺序，将指定列表按升序排序
max(Collection<T>)：返回集合的最大元素
reverse(List<T>)：反转List集合元素
shuffle(List<T>)：使用默认的随机源随机置换指定的列表
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
Collections简介
针对集合进行操作的工具类。
成员方法
sort(List<T>):根据元素的自然顺序，将指定列表按升序排序
max(Collection<T>):返回集合的最大元素
reverse(List<T>):反转List集合元素
shuffle(List<T>):使用默认的随机源随机置换指定的列表
*/
public class Test {
public static void main(String[] args) {
//创建集合
List<Integer>list = new ArrayList<>();
//往集合里添加数据
list.add(1);
list.add(3);
list.add(3);
list.add(5);
list.add(2);
list.add(4);
//打印集合
System.out.println("原先的集合："+list);
System.out.println("--------------");
//获取集合中最大元素Collections.max();
Integer max = Collections.max(list);
System.out.println("集合最大元素是："+max);
//对集合进行升序排序Collections.sort();
// System.out.println("------------------");
// Collections.sort(list);
// System.out.println("升序后的排列结果为："+list);
// //对集合进行反转Collections.reverse();
// Collections.reverse(list);
// System.out.println("反转后的结果为："+list);
//需求对集合进行降序排序
//1.先对集合进行升序
// Collections.sort(list);
// //2.再反转集合
// Collections.reverse(list);
// System.out.println("降序后的结果为:"+list);
System.out.println("-------------------");
//随机置换，相当于洗牌
Collections.shuffle(list);
System.out.println("随机置换后的结果是："+list);
}
}
Set集合
HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSet
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet 具有以下特点：
不能保证元素的排列顺序
不可重复
HashSet 不是线程安全的
集合元素可以使 null
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*案例:
Set集合的简单使用
需求:向Set集合中添加五个元素，并遍历打印分析:
A.向集合中添加元素的方法为:add()
B.遍历集合的方式:迭代器
步骤∶
1.创建集合对象∶Set<Student> set = new HashSet<>();
2．分别创建五个Student对象
3．使用add方法将Student对象添加到集合中
4．使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同
注意：
Set集合保证元素的唯一性依赖 equals()和hashCode()两个方法
*/
public class Test {
public static void main(String[] args) {
//需求：往set集合中添加五个学生对象，然后遍历
//创建集合对象
Set<Student> set = new HashSet<>();
//创建元素对象
Student s1 = new Student("乔峰",38);
Student s2 = new Student("乔峰",38);
Student s3 = new Student("虚竹",30);
Student s4 = new Student("段誉",28);
//将元素对象添加添加到集合对象里
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
//遍历集合
/*为什么Set集合没有"去重"?
因为Set集合保证元素的唯一性依赖:equals()和 hashCode()两个方法.
你没有在Student类中重写这两个方法,默认调用的是0bject类中的这两个方法.
而Object类中的equals()方法默认比较的是地址值是否相同.
解决方案:在Student类中重写equals()和hashCode()方法.
*/
System.out.println(set);
System.out.println("-------------");
//通过迭代器遍历Set集合
//1.通过集合对象获取迭代器对象
Iterator<Student> it = set.iterator();
//2.判断集合中是否有元素
while (it.hasNext()){
//3.如果有，获取元素
Student s = it.next();
System.out.println(s);
}
//通过增强for遍历Set集合
System.out.println("------------");
for (Student student : set) {
System.out.println(student);
}
}
}
Map集合
特点∶
双列集合，元素由键值对( Entry )构成:
key -- value
key不可以重复，value可以重复
应用:
Map<T1,T2> map = new HashMap<>();
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*案例:Map集合的简单使用
需求:向Map集合中添加三个元素，并遍历打印分析:
A.向map集合中添加元素的方法为:put()
元素第一次添加，返回null，重复添加，
会用新值覆盖旧值，并返回旧值
B.遍历集合的方式:
获取所有的 key:keySet()
遍历 keySet，
通过key获取 value:get()
C.遍历keySet的方法:iterator()
步骤︰
1.创建集合对象︰
Map <Integer, Student> map = new HashMap<>();
2.分别创建三个Student对象
3．使用put方法将Student对象添加到集合中
4．获取所有的key ，并使用迭代器遍历
5．通过key分别获取对应的value并打印
成员方法:
V put(K key,V value);添加元素(键值对的形式)，
元素第一次添加，返回null,
重复添加，会用新值覆盖旧值，并返回旧值.
v get(Object key)：根据键获取其对应的值
Set<K> keySet()：获取所有键的集合.
遍历步骤:
1．获取所有键的集合. keySet()
2.遍历所有的键,获取到每一个键. 迭代器，增强for.
3.根据键，获取指定的值. get() ;
*/
public class Test {
public static void main(String[] args) {
//需求;往Map集合中添加三个学生对象，然后打印
//创建集合对象
//键：学生的编号 值：具体的学生对象
Map<Integer,Student> map = new HashMap<>();
//创建元素对象
Student s1 = new Student("张三",20);
Student s2 = new Student("李四",22);
Student s3 = new Student("小马",21);
//将元素对象添加到集合对象里 map.put();
/* Student p1 = map.put(1, s1);
System.out.println(p1);
Student p2 = map.put(1, s2);
System.out.println(p2);*/
map.put(1,s1);
map.put(2,s2);
map.put(3,s3);
//根据键，获取值 map.get(键);
Student stu = map.get(2);
System.out.println(stu);
//打印集合
System.out.println(map);
//遍历集合
/* //1．获取所有键的集合. keySet()双例集合变单例集合
Set<Integer> keys = map.keySet();
//2.遍历所有的键,获取到每一个键. 迭代器，增强for.
//获取迭代器对象
Iterator<Integer> it = keys.iterator();
//判断迭代器是否有数据
while (it.hasNext()){
Integer key = it.next();//如果有,就获取
////3.根据键，获取指定的值. get() ;
Student value = map.get(key);
System.out.println("key:"+key+"...value:"+value);
}
*/
//通过增强for遍历
//获取所有键的集合
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
//key是双例集合每一个键