一、ArrayList嵌套
1、定义：
。集合中存放集合，和二维数组类似
2、演示
public static void main(String[] args){
//集合中的元素还是集合
ArrayList<ArrayList<Student>> school = new ArrayList<>();
ArrayList<Studen> clas1 = new ArrayList<>();
clas1.add(new Studen("小红"，18));
clas1.add(new Studen"小刚"，20);
school.add(clas1);
ArrayList<Student> clas2 = new ArrayList<>();
clas2.add(new Student("小张",18));'
clas2.add(new Student("小张",18));
school.add(clas2);
ArrayList<Student> clas3 = new ArrayList<>();
clas2.add(new Student("sim",18));'
clas2.add(new Student("saas",18));
school.add(clas3);
System.out.println(school)
}
二、Set集合
1、定义
。Set集合存储的元素是无序的，而且不予许重复的元素，每当
有新的元素存入的时候，Set集合回显区过滤，如果发现和集
合现有元素出现重复，就不予许添加
2、应用场景
。当我们不想让集合出现重复的元素时，使用Set集合
。当我们需要排除重复数据时，使用Set集合
3、演示
public static void main(String[] args) {
//集合中的元素还是集合
HashSet<Student> s = new HashSet<>();
Student student = new Student("小红", 18);
Student student2 = new Student("小红", 18);
s.add(student);
s.add(student2);
Iterator<Student> it = s.iterator();
while (it.hasNext()) {
Student student3 = it.next();
System.out.println(student3);
}
}
三、HashSet
1、定义：
。HashSet集合中的元素时通过hash值来比较是否相同
。集合通过元素的hashCode和equals方法来比较两个元素是否
相同，不同存入，相同不存入
。元素存入的位置未知，和存入的顺序无关
2、存储原理
。HashSet最后还是存入数组中，只是根据元素的Hash值来确
定存入的角标位置
。元素的hash值^（元素的hash值>>>16）&（数组的长
度-1）。
。HashSet中不是直接存入我们给定的元素，而是用集合中的一
个内部类封装我们存入的元素，所以当我们存入null的时候，
不会因为和数组中角标位置上默认值null起冲突
。如果两个不同的匀速根据不同的hash值计算出同一个角标值，
那么都能存进去
3、构造方法
。HashSet（）构造出一个新的集合，底层数组默认初始容量是
16（扩充一倍），加载银子是0.75
。加载因子：集合中的数组可用的
。角标值的可选范围越小，计算出重复标标志的概率就越
高
。HashSet(Collection<? exends E> c)构造出一个包含指定
collectio中元素的新set
4、常用方法
。boolean add(E e)如果此set集合中尚未包含指定元素，则添
加指定元素
。boolean remove(Object o) 移除某个元素
。int size()获取集合的长度
5、演示：去除arrayList集合中的重复元素
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<>();
al.add("a");
al.add("s");
al.add("x");
al.add("a");
al.add("s");
HashSet<String> hs = new HashSet<>(al);
System.out.println(hs);
}
四、HashSet集合中元素保证唯一性
1、原理解析：
。hashSet是通过调用元素的hashCode方法来比较两个元素
是否相同的。如果要保证引用数据类型逻辑上的唯一性，就
必须重写hashCode和equals方法
2、引用数据类型除重
。重写hashCode和equals方法，自定义比较内容
3、测试题：
需求: 编写程序, 获取10个1到20的随机数, 要求随机数不能重复, 打印结
果
public static void main(String[] args){
Random random = new Random();
HashSet<Iterator> hashSet = new HashSet<>();
while(hashSet.size()<10){//集合中个数小于10
int num = random.nextInt(20)+1;
hashSet.add(num);
}
System.out.println(hashSet);
}
4、测试题
需求: 从键盘录入一行数据, 去掉其中重复的字符,打印结果
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一行字符串:");
String line = sc.nextLine(); //将键盘录入的字符串存储在line中
char[] arr = line.toCharArray(); //将字符串转换成字符数组
HashSet<Character> hs = new HashSet<>(); //创建HashSet集合对象
for (int i = 0; i < arr.length; i++) {
hs.add(arr[i]);
}
Iterator<Character> it = hs.iterator();
while (it.hasNext()) {
System.out.print(it.next());
}
sc.close();
}
五、LinkedHashSet
Linked英 /lɪŋkt/连接的
1、定义：兼顾了linked的有序性和hashSet的唯一性
2、演示：
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<>();
hashSet.add("b");
hashSet.add("c");
hashSet.add("a");
hashSet.add("d");
System.out.println(hashSet); //结果 : [a, b, c, d]
LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.add("b");
lhs.add("c");
lhs.add("a");
lhs.add("d");
System.out.println(lhs); //结果: [b, c, a, d]
}
六、TreeSet集合
1、定义：
。TreeSet是一种顺序的集合，这里的顺序是集合中的元素有顺
序。它是通过比较元素的大小来存放的，大的在右，小的在
左
。存入的元素必须实现Comparable接口，并且重写comparTo
方法
。最后存入的元素会形成一个树状结构
2、构造方法
。TreeSet() 构造一个新的空set，该set根据其元素的而自然顺
序进行排序
。TreeSet(Comparator<? super E> comparator)构建一个空
的TreeSet,它根据指定比较器进行排序
3、常用方法、
。add(E e)将指定元素添加到此set
。first() 返回次set中当前第一个元素
。last() 返回此set中当前最后一个元素
。floor（）返回此set中小于等于给定元素的最大元素，不存在
则返回null。floor英 /flɔː(r)/基底
。higher（）返回此set中大于给定元素的最小元素，不存在则
返回null。higher英 /ˈhaɪə(r)/ 更高的
4、添加原理：
。TreeSet存放的元素最后会是一个树形。它是将第一个添加的
元素作为中心，之后添加的会和中心进行比较，大于放在右
边并紧接着和右边的元素在比较一次类推，小于的相反。直
到没有可比较的元素，才将这个添加的元素放入
5、Comparable接口
。Comparable英 /ˈkɒmpərəbl/类似的，可比较的
comparator英 /kəm'pærətə/比较器
comparTo目标字符串
。存入的元素在比较的时候，如果没有比较器，就会将元素本身
转成Comparator类型并调用comparTo方法进行比较，所以
必须实现comparator接口，并重写comparTo方法
。调用compartTo方法比较
如果方法返回一个小于0的数,表示当前元素小于被比较元
素
如果返回 0 表示当前元素等于被比较元素
如果返回一个大于0的数, 表示当前元素大于被比较元素
6、Comparator比较器
。这是一个接口，定义了一个compare抽象方法
。compare方法可以对两个元素进行比较
public class MyComparator implements Comparator(Student){
@Override
public int compare(Student 01, Student 02){
reutrn 1;
}
}
}
7、注意：
TreeSet集合的存储原理限定了必须要对存入的元素进行比较
要么存入的元素自身实现Comparable接口, 要么提供外部的实现了Comparator接口的比较器, 否则程序运行就会报错
8、测试
需求: 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
public class MyComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int num = o2.getSum() - o1.getSum(); //根据学生的总成绩降序排列
return num ;
}
}
public static void main(String[] args) {
TreeSet<Student> set = new TreeSet<>(new MyComparator());
Student student1 = new Student("小红",100);
Student student2 = new Student("小明",50);
Student student3 = new Student("小李",60);
set.add(student1);
set.add(student2);
set.add(student3);
for (Student student : set) {
System.out.println(student);
}
}
七、超级for
1、定义：
。Iterator的简写形式
。简化数组和Collection集合的遍历
2、格式：
for(元素数据类型 变量 ：数组或者Collection集合){
使用变量即可，该变量就是当前元素
}
3、演示：
public static void main(String[] args){
TreeSet<Student> set = new TreeSet<>(new MyComparator());
Student student1 = new Student("小红");
Student student2 = new Student("小红");
Student student3 = new Student("小红");
set.add(student1);
set.add(student2);
set.add(student3);
for(Student student :set ){
System.out.println(student);
}
}
4、三种迭代方式的删除
。普通for循环，可以删除，但是需要移动角标
。迭代器，可以删除，但是必须使用迭代器自身的remove方
法，否则会出现并发修改错误
。超级for循环不能删除
八、Collections工具类的使用
1、定义
。一个用于操作Collection集合工具类
2、常用方法
。sort(List<t>list)根据元素的自然顺序排序
sort英 /sɔːt/排序
。swap(List<T> list ,int i ,int j )交换集合中两个角标上的值
swap英 /swɒp/交换
。reverse(List<?> list)反转集合中的元素顺序
。replaceAll(List<T>list , T oldVal ,T newVal)替换
public static void main(String[] args){
List<String> cl = new ArrayList<>();
cl.add("a");
cl.add("d");
cl.add("s");
cl.add("t");
cl.add("a");
cl.add("e");
System.out.priontln(cl);//[a, d, s, t, a, e]
Collections.sort(cl);
System.out.println(cl);//[a, a, d, e, s, t]
Collections.swap(cl,1,2);
System.out.println(cl);//[a, d, a, e, s, t]
Collections.reverse(cl);//英 /rɪˈvɜːs/颠倒
System.out.println(cl);//[t, s, e, a, d, a]
Collections.replaceAll(cl,"a","f");//英 /rɪˈpleɪs/替换
System.out.println(cl);//[t, s, e, f, d, f]
}
