8.7笔记

复习{
 try...catch...finally块儿:
      try{
      
      }catch(){
           捕获异常
      }     
           
      try{
         有异常 并且 需要关闭资源的时候
      }catch(){
      
      }finally{
      
      }
      
      try{
         专门用来关闭资源的
      }finally{
      
      }     
           
      finally特点:  正常情况下 finally块儿都会执行
                       但是特殊情况下 ，不会执行 1.在try块儿之前就出现了异常
                                                     2.在try块儿中执行了System.exit(0); 方法     

    try...catch(){}...finally块儿中 添加return 关键字   
    
    finally如果添加了return 关键字 那么会出现什么情况?
         1.覆盖方法的返回值
         2.异常丢失
    
    return关键字可以有两种用法?
        1.用于方法的返回值
        2.结束方法的执行                                                        
            
 自定义异常:
      目的: 在java提供的异常体系中，不能满足我们的需求了,我们就继承Exception， RuntimeException
              拓展自己的异常类型
     
      public class MyException extends Exception{
             可选 重写  getMessage方法  和 printStackTrace() 方法，可以补充些，使用父类的;
      }
     
     new Exception("自己的异常信息");
          
 集合框架:   
   介绍了集合框架出现的原因: 因为java中提供的容器啊，有局限性
    比如数组，数组的特点有些限定， 例如数组长度确定不能改变，数组只能存储相同数据类型
              数组必须通过下标来获取元素,所以拓展了另一个容器就是 集合框架
   
    我们学的第一个集合框架就是 对数组进行了封装; Object[]  
    
  java中的循环一共有几种?  
       1.do...while();   2.while(){}  , 3.for 
       4.迭代器               5. foreach 增强for循环
                
 集合框架的体系: 
     Iterable: 接口 , 作用是 用于 迭代器        
           方法: iterator();   
                  
        Collection:是所有单值存储集合的 顶级接口
             add(); 向集合中添加元素
             clear();  清除集合
             contains(); 判断是否包含指定对象
             equals();  比较两个对象是否相等
             size(); 返回当前集合中的元素个数
             isEmpty(); 判断集合是否为 空
             remove(Object obj);根据对象删除
             toArray(); 将一个集合 变成对象数组
             
             |-- List:
                      add(int index,Object obj);
                      indexOf(); 
                     lastIndexOf();
                     get(int index); 根据指定下标 获取元素
                     remove(int i); 根据下标删除元素
                     remove(Object obj); 根据对象删除元素
                     set(int index,Object value); 将指定位置的元素 ，替换
                     subList(int fromIndex,int endIndex); 截取集合中的元素
                     toArray(); 将集合框架变成数组

             |-- Set:
             |-- Queue: 
                      |-- Deque: 
    
        Map: 双值   key-value
------------------------------------------------------------------------------------------        L
List接口的第一个实现类: 
     ArrayList: 实现方式  是 底层封装了一个 Object[] 数组    
                 适合查询操作， 不太适合 删除 ，添加操作
                 
         学会使用ArrayList添加 String.....  添加自定义对象
     
    源码分析: 
         private static final int DEFAULT_CAPACITY = 10; 默认的对象数组大小为10
    
        Object[] obj = new Object[0]; 动态初始化
              obj[0] = 4;
              
              System.out.println(obj[0]);
              
        Object[] obj = {}; 静态初始化
            
             private int size; 有效的元素个数
                  
                 
                 new ArrayList(); 无参默认 10 
                 new ArrayList(int capacity); 默认初始化大小的
                             
     
     LinkedList: ，不是用 数组实现的 ,是用双向链表实现的;
               每次我们向LinkedList添加元素的时候，都会将元素包装成 Node节点

          void linkLast(E e) { 
            final Node<E> l = last; //假设 这个容器中没有元素 ，你告诉我 last 是谁?
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;     //我们把 新的数字 7 当成  整个链表的 最后一个节点
            if (l == null)
                first = newNode; //如果最后一个节点 是null ，那么新节点 就是第一个节点
                                      也是最后一个节点     
            else
                l.next = newNode; //如果 之前链表中有元素，那么新建的 节点就是 之前节点的
                                         下一个节点
            size++;     //有效个数 + 1
            modCount++; //操作 次数 + 1
        }
          
    方法: 
         add(E e);
         add(int index, E element);
         addFirst(E e);
         addLast(E e); 
         clear();
         contains(Object o);
         get(int index);
         getFirst();
         getLast();
         indexOf(Object o);
         lastIndexOf(Object o);     
         remove(Object o);
         remove(int index);
          size();
          toArray();
       
     讲解 get方法:         位运算 
         public Node<E> node(int index) {     7
                   7      <  3
            if (index < (size >> 1)) {size 是 10   向右移动一位 是 /2的意思  5
                Node<E> x = first;
                for (int i = 0; i < index; i++)
                    x = x.next;
                return x;
            } else {
                Node<E> x = last; //last代表链表的最后一个元素
                for (int i = 10 - 1; i > index; i--)
                    x = x.prev;
                return x;
            }
        }
                                       1 2 3 4 5 6 7 8 9 10
     
    LinkedList在查询数据时， 没有下标，只能 将 总长度 /2 ，判断
    一下 你要找的整个下标 在 前半段， 还实在 后半段，如果在前半段
    那就从头找， 如果在后半段，那就从后找
     
     ArrayList 和 LinkedList的区别: 
              ArrayList有下标，能快速锁定值的所在位置，但是 LinkedList
              没下标，所以查询速度慢， 以后查询操作频繁 要使用ArrayList，不要使用LinkedList
              
              如果插入，和 删除频繁 使用LinkedList 性能快，它不用移动；
              修改指针 指向就可以了，ArrayList有下标，删除，插入，就会移动很多数 
                   就耗时
                   
     插入，删除多，那就用LinkedList
     查询多 ， ArrayList
     
     
     Vector: 
        |-- Stack:  
          
 1.学会如何使用ArrayList
 2.将一个List集合 ，倒叙 输出
 3.了解ArrayList 底层代码原理， 尽量写出动态数组的工具
 
 
 
 
 
 
 两个层次: ArrayList ---> 单链表， ----> 双向链表
  1.会用
  2.会用 ，懂源码
  3.会用，懂源码， 自己能写源码
  
 
 
 
 
 
 
 
 
 
 
 

}