增强day06-异常、集合进阶（Collection、List集合）

1. List集合特点
   1. 添加的元素是有序、可重复、有索引
   2. ArrayLsit、LinkedList
2. Set集合特点
   1. 添加的元素是无序、不重复、无索引
      1. HashSet：无序、不重复、无索引
      2. LinkedHashSet：有序、不重复、无索引
      3. TreeSet：按照大小默认升序排序、不重复、无索引
3. Collection集合常用方法
   1. ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet集合都可以调用下面的方法
   2. 
4. Collection集合遍历方式
   1. 迭代器
      1. 
   2. 增强For
   3. forEach

Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");

//调用forEach方法
//由于参数是一个Consumer接口，所以可以传递匿名内部类
c.forEach(new Consumer<String>{
    @Override
    public void accept(String s){
        System.out.println(s);
    }
});


//也可以使用lambda表达式对匿名内部类进行简化
c.forEach(s->System.out.println(s)); //[赵敏, 小昭, 素素, 灭绝]

5. List集合常用方法
   1. List集合是有索引的，所以有针对索引的方法
   2. 
6. List集合遍历方法
   1. 普通for循环(因为有索引)
   2. 迭代器
   3. 增强for
   4. Lambda表达式

List<String> list = new ArrayList<>();
list.add("蜘蛛精");
list.add("至尊宝");
list.add("糖宝宝");

//1.普通for循环
for(int i = 0; i< list.size(); i++){
    //i = 0, 1, 2
    String e = list.get(i);
    System.out.println(e);
}

//2.增强for遍历
for(String s : list){
    System.out.println(s);
}

//3.迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()){
    String s = it.next();
    System.out.println(s);
}

//4.lambda表达式遍历
list.forEach(s->System.out.println(s));

7. 重点：ArrayList底层的原理
   1. ArrayList集合底层是基于数组结构实现的，也就是说当你往集合容器中存储元素时，底层本质上是往数组中存储元素。
   2. 数组的特点：查询快，增删慢
      1. 查询快：根据索引查询快
      2. 删除效率低：后面的数据要前移
      3. 添加效率低：后面的数据要后移，可能要进行数组扩容
   3. ArrayList底层扩容原理
      1. 
      2. 数组扩容，并不是在原数组上扩容（原数组是不可以扩容的），底层是创建一个新数组，然后把原数组中的元素全部复制到新数组中去。
8. 重点：LinkedList底层原理
   1. LinkedList底层是基于双向链表实现的
   2. 链表的特点：查询慢，增删快
      1. 查询慢：无论从哪个数据都要从头开始找
      2. 增删快：链表增删相对块，只需要重新指向新的节点地址就行了
   3. 双向链表特点：针对头尾增删特别快
   4. 新增了一些针对头尾进行操作的方法
      1. 
9. ArrayList 和 LinkedList 查询 增删 底层剖析
   1. ArrayList查询：头 中 尾 都很快，按值查找–时间复杂度O(n)
   2. ArrayList插入：尾部非常快，头部，中间很慢
      1. 尾部很快是因为直接插入数组[length++]
      2. 头部中间慢是因为要进行数组移动
   3. LinkedList查询：头尾快，中间慢
      1. 底层调用node()方法，把index和mid会进行一次判断，是从头遍历还是尾遍历，所以越靠近中间越慢
   4. LinkedList插入
      1. 头部插入调用add方法，add方法里面判断是linklast还是linkBefore，这个根据node()来判断
      2. 尾部linkLast(E e)方法，可以看出，在尾部插入的时候，并不需要从头开始遍历整个链表，因为已经事先保存了尾结点，所以可以直接在尾结点后面插入元素。
10. LinkedList的应用场景
11. LinkedList实现队列

//1.创建一个队列：先进先出、后进后出
LinkedList<String> queue = new LinkedList<>();
//入对列
queue.addLast("第1号人");
queue.addLast("第2号人");
queue.addLast("第3号人");
queue.addLast("第4号人");
System.out.println(queue);

//出队列
System.out.println(queue.removeFirst());	//1
System.out.println(queue.removeFirst());	//2
System.out.println(queue.removeFirst());	//3
System.out.println(queue.removeFirst());	//4

1 2 3 4
<------

2. LinkedList实现栈

//1.创建一个栈对象
LinkedList<String> stack = new ArrayList<>();
//压栈(push) 等价于 addFirst()
stack.push("第1颗子弹");
stack.push("第2颗子弹");
stack.push("第3颗子弹");
stack.push("第4颗子弹");
System.out.println(stack); //[第4颗子弹, 第3颗子弹, 第2颗子弹,第1颗子弹]

//弹栈(pop) 等价于 removeFirst()
System.out.println(statck.pop()); //第4颗子弹
System.out.println(statck.pop()); //第3颗子弹
System.out.println(statck.pop()); //第2颗子弹
System.out.println(statck.pop()); //第1颗子弹

//弹栈完了，集合中就没有元素了
System.out.println(list); //[]


4   3  2  1
------》
3 2 1
2 1
1

11. 关于Java异常
12. 分类：编译异常和运行异常
13. NumberFormatException 是 RuntimeException 的子类
14. catch顺序是顺序执行
15. 异常的体系
16. 
17. 关于try–catch–finally
18. 要么try catch 要么 try finally
19. 可以有多个catch
20. 关于遍历删除list元素的问题
21. 遍历删除list元素时候，应该从后往前遍历

for (int i = list.size()-1; i >= 0; i--) {
			if("java".equals(list.get(i))){
				list.remove(i);
			}
	}  

如果我们从前往后遍历
for (int i =0; i < list.size(); i++) {
			if("java".equals(list.get(i))){
				list.remove(i);
			}
	}

这就会导致索引改变了，我们刚删除一个，list的数组就改变了，整体前移

14. 关于ConcurrentModificationException异常
15. 如果我们在用迭代器遍历一个list时候，去修改它，会破坏迭代器的一致性，就会抛出这个异常