java基础学习04

日期类
    Date类概述和构造方法
    多个包下可能有相同的类，要注意区分。
    import java.util.Date;
    构造方法
        public Date() 分配一个Date对象，以当前时间初始化对象，精确到毫秒
        public Date(long date) 分配一个Date对象，并用参数将其初始化为从标准基准时间起指定的毫秒数
    常用方法
        public long getTime() 获取的是日期对象从1970年1月1日00:00：00到现在的毫秒值
        public void setTime() 设置时间，给的是毫秒值
    System.currentTimeMillis() 返回自标准基准时间的毫秒值

SimpleDateFormat类概述
    是一个具体的类，用于格式化和解析日期，重点学习日期格式化和解析
    日期和时间格式由日期和实践模式字符串指定。
    常用的模式字母及对应关系如下：
    y  年
    M  月
    d  日
    H  时
    m  分
    s  秒
    -------
    SimpleDateFormat 构造方法
        public SimpleDateFormat()  构造一个SimpleDateFormat，使用默认模式和日期格式
        public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat，使用给定的模式和日期格式
    --------
    SimpleDateFormat 格式化和解析日期
        1.格式化成字符串(从Date到String)
            public final String format(Date date):将日期格式化成日期/时间字符串
            SimpleDateFormat std = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")

        2.解析成日期Date(从String到Date)
            public Date parse(String source):从给定字符串解析文本生成日期
    编写日期工具类

Calendar 类概述
    Calendar为某一时刻和一组日历字段之间的转换提供了一段方法，并为操作日历字段提供了一些方法
    Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段使用当前日期和实践初始化
    Calendar c=Calendar.getInstrance();
    --------
    Calendar的常用方法
        public int get(int filed)  返回给日历字段的值
        public abstract void add(int filed,int amount)  根据日历的规则，将指定的时间量添加到给定的日历字段
        public final void set(int year,int month,int date)  设置当前日历对象的年月日
        int year =c.get(Calendar.YEAR);
    --------
    获取任意一年的二月有多少天？
        四年一闰，百年不闰，四百年再闰
        设置日历对象为3月1日，往前推一天，就是2月的最后一天，输出这一天就好

异常
    异常：程序出现了不正常的情况
    --------
    异常体系
        Throwable
            Error 严重问题，不需要处理
            Exception  称为异常类，它表示程序本身可以处理的问题
                RuntimeException  在编译期不检查，出现问题后，需要我们回来修改代码
                非RuntimeException 编译期就必须处理，否则程序不能通过编译，就更不能正常运行了
    --------
    throwable的两个子类 Error和Exception
    Error 表示严重的问题，合理的应用程序不应该试图捕获，大多数这样的错误是异常情况
    Exception及其子类 表示合理的应用程序可能想要捕获的条件
    --------
    RuntimeException是java虚拟机在正常操作期间可以抛出的异常的超类
    RuntimeException及其子类是非受检异常
    --------
    jvm的默认处理方案
        如果程序出现问题，我们没有做任何处理，最终jvm会做默认的处理
            输出异常的类型与出现的位置，同时程序停止运行
    --------
    异常处理
       程序员异常处理的两种方案，
           * try...catch...
           * throws
       --------
       异常处理之 try...catch...
            try{
                可能出现异常的代码
            }catch(异常类名 变量名){
                异常的处理代码
            }
       执行流程：
              程序从try里面的代码开始执行，出现异常后，会自动生成一个异常类对象，
          该异常类对象会被提交给java运行时系统，当java运行时系统接收到异常对象时，
          会到catch中找匹配的异常类，找到后进行对应异常的处理，执行完毕后，程序还
          可以继续往下执行。

       运行时异常：
          数组访问越界 ArrayIndexOutOfBoundsException e; e.printStackTrace()
       --------
    Throwable的成员方法
        public String getMessage()    返回此throwable的详细消息字符串
        public String toString()      返回此可抛出的简短描述
        public String printStacktrace()  把异常的错误信息输出在控制台
    Throwable是所有错误和异常的祖宗类，其成员方法各个子类都可以使用
    --------
    编译时异常和运行时异常的区别
        java中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常
        所有的RuntimeException类及其子类被称为运行时异常，其它的异常都是编译时异常
        * 编译时异常：必须显示处理，否则程序就会发生错误，无法编译
        * 运行时异常：无需显示处理，也可以和编译时异常一样处理
    --------
    异常处理之throws
        处理try...catch...处理不了的异常情况，java提供了throws的方案。
        格式：
            throws 异常类名；
        注意：这个格式是跟在方法的扩后后面
        --------
        throws仅仅抛出异常，异常的处理还是需要调用者使用try...catch...处理
    --------
    自定义异常
        如：学生分数0-100，系统无法知道这个异常。
        格式：
            public class 异常类名 extends Exception{
                无参构造
                带参构造
            }
        --------
        范例：
            public class ScoreException extends Exception{

                public ScoreException() {}

                public ScoreException(String message){
                    //message最终传递给了throwable的detailMessage变量
                    super(message);
                }
            }

            public class Teacher{

                public void checkScore(int score) throws ScoreException{
                    if(score<0 || score>100){
                        throw new ScoreException("你给的分数有误，分数应该在0-100之间");
                    }else{
                        System.out.println("分数正常");
                    }
                }
            }
        --------
        throws和throw的区别
            throws                                      throw
          * 用在方法声明后面，跟的是异常类名                 用在方法体内，跟的是异常对象名
          * 表示抛出异常，由该方法的调用者来处理              表示抛出异常，由方法体内的语句处理
          * 表示出现异常的一种可能性，并不一定会发生这些异常    执行throw一定抛出了某种异常

Collection
    集合知识回顾
        集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。
    集合类体系结构
        集合
            单列 Collection(接口)
                元素可重复 list(接口)
                    具体的实现类：Arraylist、LinkedList...
                元素不可重复 Set(接口)
                    具体的实现类：HashSet、TreeSet...
            双列 Map(接口)
                具体的实现类：HashMap...
    --------
    Collection集合概述和使用
        Collection集合概述
            * 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
            * JDK不提供此接口的任何实现，它提供更具体的子接口(如Set和List)实现
        创建Collection集合的对象
            * 多态的实现方式
            * 具体的实现类Arraylist
            Collection<String> c= new ArrayList<String>();
        Collection集合的常用方法
            * boolean add(E e)          添加元素
            * boolean remove(Object o)  从集合中移除指定的元素
            * void clear()              清空集合中的元素
            * boolean contains(Object o)判断集合中是否存在指定的元素
            * boolean isEmpty()         判断集合是否为空
            * int size()                集合的长度，也就是集合中元素的个数
        Collection集合的遍历
            iterator 迭代器，集合的专用遍历方式
            iterator<E> iterator() 返回此集合中元素的迭代器，通过集合的iterator()方法得到
            迭代器是通过集合的iterator()方法得到的，所以说它是依赖于集合而存在的

            iterator中的常用方法
                E next() 返回迭代中的下一个元素
                Boolean hasNext() 如果迭代具有更多元素，则返回true
        Collection的使用步骤
            ...
    --------
    List集合概述和特点
        List集合特有方法
            void add(int index,E element)          在集合中的指定位置插入元素
            E remove(int index)                    删除指定索引处的元素，返回被删元素
            E set(int index,E element)             修改指定索引处的元素，返回被修改的元素
            E get(int index)                       返回指定索引处的元素
        除iterator外的遍历方法：
            通过E get(int index)获取指定索引处的元素。

并发修改异常
      Iterator<String> it =list.iterator();
        while(it.hasNext()){
            String s=it.next();
            if(s.equals("world")){
                // 添加元素后，迭代器失效？
                list.add("javaee");
            }
        }
      并发修改异常的源码分析:
          迭代器时集合的内部类，可以随时访问集合的内部属性。
            list类包含modCount成员变量，初始化迭代器时会将modCount赋值给得带器中的变量expectedModCount，
         迭代器在迭代过程中会判断modCount与expectedModCount是否相等。

      ArrayList Fail Fast机制，多线程，不能一边修改一边遍历

      修改方式：
          for(int i=0;i<list.size();i++){
            String s=list.get(i);
            if(s.equals("world")){
                list.add("javaee");
            }
          }

ListIterator列表迭代器
    通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
    listIterator接口继承自iterator类，允许程序员沿任一方向遍历列表，在迭代期间修改列表，并获取列表中迭代器的当前位置。
    ListIterator中常用方法：
        E next()             返回迭代器的下一个元素
        boolean hasNext()    如果迭代器有更多的元素，返回true
        E previous()         返回列表中的上一个元素
        boolean hasPrevious()如果迭代器在反方向有更多的元素，返回true
        void add(E e)        将指定的元素插入列表

    重点：ListIterator.add()方法，不会出现并发修改异常，原因是 方法中将modCount赋值给变量expectedModCount
          ListIterator<String> it = list.ListIterator();
            while(it.hasNext()){
                String s=it.next();
                if(s.equals("world")){
                    // 此处添加元素后不会失效
                    it.add("javaee");
                }
            }

增强for循环
    简化数组和Collection集合的遍历
        * 实现iterable接口的类允许其对象成为增强型for语句的目标
        * 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
    增强for的格式
        for(元素数据类型 变量名：数组或者Collection集合){
            //此处使用变量即可
        }

数据结构
    是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
    通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率
    栈：  先进后出
    队列：先进先出
    数组：查询数据通过索引定位，查询任意数据耗时相同，查询速度快；
         删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低。
         添加数据时，添加位置及其后的每个数据后移，再添加元素，添加效率低。
    链表：查询慢，添加删除元素快