黑马Java——集合进阶（List、Set、泛型、树）

一、集合的体系结构

1、单列集合（Collection）

 二、Collection集合

1、Collection常见方法

1.1代码实现：

import java.util.ArrayList;
import java.util.Collection;public class A01_CollectionDemo1 {public static void main(String[] args) {
/*public boolean add(E e)             添加public void clear()                 清空public boolean remove(E e)          删除public boolean contains(Object obj) 判断是否包含public boolean isEmpty()            判断是否为空public int size()                   集合长度注意点：Collection是一个接口,我们不能直接创建他的对象。所以，现在我们学习他的方法时，只能创建他实现类的对象。实现类：ArrayList
*///目的：为了学习Collection接口里面的方法//自己在做一些练习的时候，还是按照之前的方式去创建对象。Collection<String> coll = new ArrayList<>();//1.添加元素//细节1：如果我们要往List系列集合中添加数据，那么方法永远返回true，因为List系列的是允许元素重复的。//细节2：如果我们要往Set系列集合中添加数据，如果当前要添加元素不存在，方法返回true，表示添加成功。//                                       如果当前要添加的元素已经存在，方法返回false，表示添加失败。//                                       因为Set系列的集合不允许重复。coll.add("aaa");coll.add("bbb");coll.add("ccc");System.out.println(coll);//2.清空//coll.clear();//3.删除//细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。//细节2：方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false//如果要删除的元素不存在，就会删除失败。System.out.println(coll.remove("aaa"));System.out.println(coll);//4.判断元素是否包含//细节：底层是依赖equals方法进行判断是否存在的。//所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。boolean result1 = coll.contains("bbb");System.out.println(result1);//5.判断集合是否为空boolean result2 = coll.isEmpty();System.out.println(result2);//false//6.获取集合的长度coll.add("ddd");int size = coll.size();System.out.println(size);//3}
}

1.2 contains方法重写equals方法示例：（idea可自动重写）

import java.util.ArrayList;
import java.util.Collection;public class A02_CollectionDemo2 {public static void main(String[] args) {//1.创建集合的对象Collection<Student> coll = new ArrayList<>();//2.创建三个学生对象Student s1 = new Student("zhangsan",23);Student s2 = new Student("lisi",24);Student s3 = new Student("wangwu",25);//3.把学生对象添加到集合当中coll.add(s1);coll.add(s2);coll.add(s3);//4.判断集合中某一个学生对象是否包含Student s4 = new Student("zhangsan",23);//因为contains方法在底层依赖equals方法判断对象是否一致的。//如果存的是自定义对象，没有重写equals方法，那么默认使用Object类中的equals方法进行判断，而Object类中equals方法，依赖地址值进行判断。//需求：如果同姓名和同年龄，就认为是同一个学生。//所以，需要在自定义的Javabean类中，重写equals方法就可以了。System.out.println(coll.contains(s4));}
}

重写

 @Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && Objects.equals(name, student.name);}

2、Collection的遍历方式（3种）

Collection的遍历的三种方式：

• 迭代器遍历
• 增强for循环
• Lambda表达式

2.1迭代器遍历

迭代器不依赖索引

 

循环遍历： 

 //2.获取迭代器对象//迭代器就好比是一个箭头，默认指向集合的0索引处Iterator<String> it = coll.iterator();//3.利用循环不断的去获取集合中的每一个元素while(it.hasNext()){//4.next方法的两件事情：获取元素并移动指针String str = it.next();System.out.println(str);}

示例代码：（不依赖索引，而是通过指针移动的方式）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class A03_CollectionDemo3 {public static void main(String[] args) {/*Collection系列集合三种通用的遍历方式：1.迭代器遍历2.增强for遍历3.lambda表达式遍历迭代器遍历相关的三个方法：Iterator<E> iterator()  ：获取一个迭代器对象boolean hasNext()       ：判断当前指向的位置是否有元素E next()                ：获取当前指向的元素并移动指针*///1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("aaa");coll.add("bbb");coll.add("ccc");coll.add("ddd");//2.获取迭代器对象//迭代器就好比是一个箭头，默认指向集合的0索引处Iterator<String> it = coll.iterator();//3.利用循环不断的去获取集合中的每一个元素while(it.hasNext()){//4.next方法的两件事情：获取元素并移动指针String str = it.next();System.out.println(str);}}
}

迭代器书写的小细节：

迭代器细节注意点：

 迭代器的细节注意点：1.报错NoSuchElementException2.迭代器遍历完毕，指针不会复位3.循环中只能用一次next方法4.迭代器遍历时，不能用集合的方法进行增加或者删除暂时当做一个结论先行记忆，在今天我们会讲解源码详细的再来分析。如果我实在要删除：那么可以用迭代器提供的remove方法进行删除。如果我要添加，暂时没有办法。

//当上面循环结束之后，迭代器的指针已经指向了最后没有元素的位置//System.out.println(it.next());//NoSuchElementException//迭代器遍历完毕，指针不会复位System.out.println(it.hasNext());//如果我们要继续第二次遍历集合，只能再次获取一个新的迭代器对象Iterator<String> it2 = coll.iterator();while(it2.hasNext()){String str = it2.next();System.out.println(str);}

 

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class A05_CollectionDemo5 {public static void main(String[] args) {//1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("aaa");coll.add("bbb");coll.add("ccc");coll.add("ddd");coll.add("eee");//2.获取迭代器对象//迭代器就好比是一个箭头，默认指向集合的0索引处Iterator<String> it = coll.iterator();//3.利用循环不断的去获取集合中的每一个元素while(it.hasNext()){//4.next方法的两件事情：获取元素,并移动指针String str = it.next();if("bbb".equals(str)){//coll.remove("bbb");it.remove();}}System.out.println(coll);}
}

小结：

Interator方法：

2.2增强for循环

示例代码：

import java.util.ArrayList;
import java.util.Collection;public class A06_CollectionDemo6 {public static void main(String[] args) {/* Collection系列集合三种通用的遍历方式：1.迭代器遍历2.增强for遍历3.lambda表达式遍历增强for格式：for(数据类型 变量名: 集合/数组){}快速生成方式：集合的名字 + for 回车*///1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("zhangsan");coll.add("lisi");coll.add("wangwu");//2.利用增强for进行遍历//注意点：//s其实就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据for(String s : coll){s = "qqq";}System.out.println(coll);//zhangsan lisi wangwu}
}

 2.3Lambda表达式遍历

示例代码：

//1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("zhangsan");coll.add("lisi");coll.add("wangwu");//2.利用匿名内部类的形式//底层原理：//其实也会自己遍历集合，依次得到每一个元素//把得到的每一个元素，传递给下面的accept方法//s依次表示集合中的每一个数据/* coll.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*///lambda表达式coll.forEach(s -> System.out.println(s));

 3、小结

 

 

三、List集合

1、List集合特有的方法（操作索引的4个方法）

示例代码：

import java.util.ArrayList;
import java.util.List;public class A01_ListDemo1 {public static void main(String[] args) {/*List系列集合独有的方法：void add(int index,E element)       在此集合中的指定位置插入指定的元素E remove(int index)                 删除指定索引处的元素，返回被删除的元素E set(int index,E element)          修改指定索引处的元素，返回被修改的元素E get(int index)                    返回指定索引处的元素*///1.创建一个集合List<String> list = new ArrayList<>();//2.添加元素list.add("aaa");list.add("bbb");//1list.add("ccc");//void add(int index,E element)       在此集合中的指定位置插入指定的元素//细节：原来索引上的元素会依次往后移//list.add(1,"QQQ");//E remove(int index)                 删除指定索引处的元素，返回被删除的元素//String remove = list.remove(0);//System.out.println(remove);//aaa//E set(int index,E element)          修改指定索引处的元素，返回被修改的元素//String result = list.set(0, "QQQ");//System.out.println(result);// E get(int index)                    返回指定索引处的元素//String s = list.get(0);//System.out.println(s);//3.打印集合System.out.println(list);}
}

add方法：

//1.创建一个集合List<String> list = new ArrayList<>();//2.添加元素list.add("aaa");list.add("bbb");//1list.add("ccc");//void add(int index,E element)       在此集合中的指定位置插入指定的元素//细节：原来索引上的元素会依次往后移list.add(1,"QQQ");

remove方法：

E remove(int index)                 //删除指定索引处的元素，返回被删除的元素String remove = list.remove(0);System.out.println(remove);//aaa

List删除的小细节：

//List系列集合中的两个删除的方法//1.直接删除元素//2.通过索引进行删除//1.创建集合并添加元素List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);//2.删除元素//请问：此时删除的是1这个元素，还是1索引上的元素？//为什么？//因为在调用方法的时候，如果方法出现了重载现象//优先调用，实参跟形参类型一致的那个方法。//list.remove(1);//手动装箱，手动把基本数据类型的1，变成Integer类型Integer i = Integer.valueOf(1);list.remove(i);System.out.println(list);

set & get方法：

//E set(int index,E element)          修改指定索引处的元素，返回被修改的元素//String result = list.set(0, "QQQ");//System.out.println(result);// E get(int index)                    返回指定索引处的元素//String s = list.get(0);//System.out.println(s);

2、List集合的遍历方式（5种）

• 迭代器遍历
• 列表迭代器遍历
• 增强for遍历
• Lambda表达式遍历
• 普通for循环（因为List集合存在索引）

2.1迭代器遍历：

/*List系列集合的五种遍历方式：1.迭代器2.列表迭代器3.增强for4.Lambda表达式5.普通for循环*///创建集合并添加元素List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");//1.迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}

2.2增强for：

//2.增强for//下面的变量s，其实就是一个第三方的变量而已。//在循环的过程中，依次表示集合中的每一个元素for (String s : list) {System.out.println(s);}

2.3Lambda表达式

//3.Lambda表达式//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素//并把每一个元素传递给下面的accept方法//accept方法的形参s，依次表示集合中的每一个元素list.forEach(s->System.out.println(s) );

2.4普通for循环

//4.普通for循环//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素for (int i = 0; i < list.size(); i++) {//i:依次表示集合中的每一个索引String s = list.get(i);System.out.println(s);}

2.5列表迭代器（ListIterator，继承于Iterator）

// 5.列表迭代器//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的//额外添加了一个方法：在遍历的过程中，可以添加元素ListIterator<String> it = list.listIterator();while(it.hasNext()){String str = it.next();if("bbb".equals(str)){//qqqit.add("qqq");}}

但迭代器默认指向0索引，想要使用previous方法需要先移动到后面

小结

四、数据结构（常见有8种）

1、什么是数据结构呢？

数据结构就是计算机存储、组织数据的方式

不同的业务场景要选择不同的数据结构

2、数据结构概述

常见的数据结构：

栈、队列、数组、链表、二叉树、二叉树查找

3、栈（后进先出，先进后出）

 

4、队列（先进先出，后进后出）

• 数据从后端进入队列模型的过程称为：入队列
• 数据从前端离开队列模型的过程称为：出队列

5、栈与队列小结

6、数组

7、链表（与数组相对）

双向链表可以提高查询效率：

小结

五、ArrayList原码分析

 1、ArrayList集合底层原理

2、ArrayList源码分析

idea快捷键：Alt + 7：列出方法大纲

添加的数据长度不超过10：

 一次添加多个，超过10，但不超过15：

六、LinkedList集合

1、LinkedList特有方法

2、LinkedList源码分析

3、迭代器源码分析

 

modCount：集合变化的次数

expectedModCount：创建对象时，传递过来的次数

结论:
在以后如何避免并发修改异常
在使用迭代器或者是增强for遍历集合的过程中，不要使用集合的方法去添加
或者删除元素即可