Java第四周学习

常用类
Object类:
String类:
StringBuffer类:
StringBuilder类:
包装类: Integer类:
日期类: Date类：java.util.Date  代表系统时间
                |--java.sql.Date  代表数据库时间
              SimpleDateFormate: 用来辅助java.util.Date的
Time类:
Math类:数学类
Random类:随机类
Scanner类:控制台输入
String的常量池:
 jvm内存模型中有两个内存地址: 
  1.栈(Stack)
  2.堆(heap) 
  
  String str = new String("abc"); 在堆中开辟空间

  String str = "abc"; String类的常量池中
  
  字符串在java中使用频繁，消耗时间，空间比较多，
  所以在java中 优化了,String 类存存储,目的是为了
  提高性能，减少内存开销
  
 优化String类在jvm虚拟机内存中的存储 
 
 常量池 可以理解成  String类型数据的缓冲区，
 在创建String str = "abc"; 它先去常量池中
 找 有没有这个abc字符串，如果常量池中没有
 他就创建，如果有了 就不创建了
 
 常量池中存储字符串原理: 
  1.String str = "abc"; 首先 去常量池中 
       找 有没有这个字符串啊，如果么有直接创建新的,
  2.如果有 就直接将当前变量 指向常量池中同一个内存地址
    在两个字符串变量的拼接时， 它会在堆中 开辟空间 存储
  3.如果两个原生字符串 + 拼接时，拼接后它是会去常量池中匹配的
       如果有就直接指向，如果没有就开辟新的空间存储
   
 String类的intern()方法: 
   intern方法  是将 new 在堆中的字符串，放到常量池中
   如果常量池中没有就会创建新的，如果常量池中有 ，就不创建了
   返回一个变量指向 常量池中的内容}
==========================================================================
  异常Exception：
      为什么要有异常机制？
         在程序运行过程中，与可能会出现一些未预期到的问题，我们就可以通过Java中提供的处理异常的方式来捕获
         或者抛出异常。   异常本质上是不能解决问题的，只能给我们提供解决问题的信息，根据提供的信息，能快速锁定
         找到问题并解决问题。
  Java异常体系Throwable类：所有错误，异常的基类，根类
        |--错误Error：程序崩溃，程序员不能解决的问题
           |--VirtualMachineError:java虚拟机异常
              |-- StackOverflowError:栈溢出错误，  一般方法同时循环调用的时候会出现。
              |-- OutOfMemoryError:内存泄漏错误，  执行的代码没有可用的资源的时候会出现。
        |--异常Exception：程序员可以解决的问题
           |--IOException:I/O流异常
           |--RuntimeEXception:运行时异常
              |--ArithmeticException:数学异常
              |--NullPointerException:空指针异常
              |--IndexOutofBoundsException:下标越界异常
                 |--ArrayOutofBoundsException:数组下标越界异常
                 |--StringOutofBoundsException:字符串下标越界异常
              |--NumberFormateException:数字初始化异常
              |--IlleagleArgumentException:非法参数异常
              |--ClassCastException:字符转换异常
        CheckedException:受检查异常    在Java API中没有这个类
  Java中处理异常的方式：
       1：捕获异常： 
            （1）try{
                有可能出现异常的代码
            }catch(异常类型 e){
                打印输出信息
            }
            （2）try{
                   可能出现异常的代码
                }catch(异常类型 |异常类型|异常类型|异常类型 e){
                    打印输出信息
                } 
            （3）try{
                   可能出现异常的代码
                }catch(异常类型 e){   异常类型必须是从小到大的
                                       
                }catch(异常类型 e){
                
                }
            （4）try{
                
                }catch(){
                
                }finally{
                   最终的，finally块儿里面的代码一般情况下一定会执行
                }                
                特殊情况：1.在进入到 try...catch 块儿 之前 就出现异常了 ， 那么finally 块儿 就不会执行
                        2.在try块儿中 ，执行System.exit(0); 强制推出 ， 这样你的finally块儿也不会执行
            （5） try{
                    就是用来关闭资源的 ,没有任何处理异常的能力, 可以写普通代码
                  }finally{    
                   一般用于关闭资源 , 连接数据库后， 或使用 IO流 读取 文件后
                   ips.close();
                  }
                 注意事项: 
                 finally 块儿中 不要加 return 关键字，加了返回值会出现什么情况? 
                   1. 会覆盖返回值
                2. 会出现异常丢失问题
===============================================================================================
return关键字有两个功能: 
  1.代表方法的返回值
           public int a(){
               return 10;
           }
           
  2.终止程序     
        if(true){
            return;
        }
=================================================================================================
自定义异常: 
    什么情况下 会有自定义 异常?
      java本身的 异常体系 不能满足我们的 需求的时候 ，需要我们拓展自己的异常
      
   如何做的自定义异常? 
     掌握Exception, 这个类 没有final修饰 ，所以我们可以定义一个类 继承Exception这个类
================================================================================================
集合框架：
       1：变量：用来存储单个元素的
       2：数字：用来存储多个元素的
              特点：1：长度一旦确定无法改变
                   2：必须存储相同的数据类型
                   3：必须通过下标获取元素
                   4：数组可以存储重复元素
       3：集合框架：相当于动态的容器
                优点: 自动扩容
                     可以存出任何数据类型
                   有的容器是通过下标来获取， 有的不是通过下标来获取元素
                   有的容器可以存储重复元素， 有的不可以存储重复元素  
            是Java给我们提供的一套框架体系，包括接口，类；接口的作用就是用来设计程序的
            Iterrable:接口    意思：可迭代的
                     方法：Iterater()迭代
                |--Collection:接口   集合框架的顶级接口  特点：单值存储
                    方法：    1.add();  向集合中添加一个元素
                               2.clear(); 删除所有元素
                             3.contains(Object o); 判断次容器中 是否包含指定元素， 如果包含返回true ，否则 返回false
                            4.equals(Object o);
                            5.isEmpty(); 判断当前容器 是否是空的
                            6.iterator();
                            7.remove(Object o); 删除指定 对象
                            8.size() 返回当前容器中的大小
                            9.Object[]  toArray(); 将一个集合变成 对象数组
                Collection 下的子接口 ，有的可以存储重复数据，有的不可以存储重复数据
                                    有的是 有序的， 有的是 无序的， 顺序只的是 输入顺序 和输出顺序 不一致
                    |--List:接口  有序的， 可以重复的 ， 允许存储为null  ， 多个
                           方法：
                              add(int index, E element); 在指定 位置上 添加元素
                                get(int index); 获取指定下标位置上的元素
                                indexOf(Object o); 返回此对象在容器中的位置
                                lastIndexOf(Object o); 返回此对象在容器中最后出现的位置
                                remove(int index); 根据索引删除元素
                                remove(Object obj);  根据对象删除
                                set(int index, E element); 替换，将指定位置上的元素，替换为新的
                                size(); 返回集合中有效的元素个数
                                subList(int fromIndex, int toIndex); 截取集合中的元素
        List接口的实现类
                (1)new ArrayList();实现方式  是 底层封装了一个 Object[] 数组    
                                    适合查询操作， 不太适合 删除 ，添加操作
                (2)new LinkedList();是用 数组实现的 ,是用双向链表实现的;
                                    每次我们向LinkedList添加元素的时候，都会将元素包装成 Node节点        
                    方法：    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();        
ArrayList 和 LinkedList的区别: 
              ArrayList有下标，能快速锁定值的所在位置，但是 LinkedList
              没下标，所以查询速度慢， 以后查询操作频繁 要使用ArrayList，不要使用LinkedList
              
              如果插入，和 删除频繁 使用LinkedList 性能快，它不用移动；
              修改指针 指向就可以了，ArrayList有下标，删除，插入，就会移动很多数 
                   就耗时
                   
     插入，删除多，那就用LinkedList
     查询多 ， ArrayList                             
============================================================================================
                    |--Set:接口    无序的 ， 不可重复的 ， 允许存储为null ，只能 是一个
                    |--Queue:接口
                       |--Deque:接口
                独立接口：map:接口     双值存储