1.Map集合:存储的是key=value键值对,key不能重复,value可以重复
  a.方法:
    put(key,value)//把键值对添加到HashMap集合
                 //如果添加重复的key,会把当前key对应的value覆盖掉              
                 //例如:第一次put("张三",80),第二次put("张三",50)
                //结果:map中的key=value变成 张三=50
         
    V get(key)//根据key返回对应的value

    V remove(key)//根据key删除对应的value,返回value值
2.Map集合遍历:将双列集合转换成单列,为了使用单列集合的迭代器
  a.利用keySet()方法
    1.调用keySet()方法将Map中的key封装一个Set集合中
    2.再利用迭代器(增强for)遍历Set集合取出一个个key
    3.根据取出的key再去Map利用get(key)方法取出对应value
  b.利用entrySet()方法
    内部接口:
    interface Map<K,V>{
      interface Entry<K,V>{//如果像使用Entry接口需要使用外部接口.内部接口Map.Entry<K,V>
      }
    }
    1.调用entrySet()方法将Map中的所有key=value封装成一个个Entry对象,把一个个Entry对象放到set
      集合中
    2.再利用迭代器(增强for)遍历Set集合取出一个个Entry对象
    3.再利用Entry对象中的方法getKey(),getValue取出键和值


3.JDK1.5新特性
  a.可变参数
    int[] arr={1,2,34}
    method(1,2,3,4);
    method(arr);

    public void method(int...arr){//底层会自动创建一个数组对象
                                     //把1,2,3,4存到数组里面
                                 //既可以接收数组对象,也可以接收任意多个参数
    }
    // public void method(int[]arr){ //数组的引用类型和可变参数不够成重载关系

    // }

    method(1.3,2.3.3.3)
    // public void method(double...arr,double d){//第一个可变参数把所有的实参都接收了,结果导致第二个参数接收任何实参

    // }

      public void method(double d , double...arr){//1.3赋值给了d,2.3,3.3封装到arr数组中
                                                  //可变参数定义在形参列表末尾
      }


4.数据结构之栈和队列,数组,链表
数组:用连续的内存单元存储
链表:用不连续的内存单元存储
栈:先进后出/后进先出(FILO) First In Last Out (手枪弹夹)
队列:先进先出/后进后出(FIFO) First In First Out(银行排队)

5.异常体系
  a.概述:
    Java 运用面向对象的思想将程序可能出现的 错误 封装成对应的类
  b.体系:
    Throwable
      Error:严重错误,无法处理 服务器宕机 数据库崩溃 内存溢出
      Exception:
        RuntimeException及其子类:在运行时抛出异常 运行时异常
        非RuntimeException及其子类:编译是抛出的异常 编译时异常
  c.异常处理
    1.单一异常的处理
       try{
           //可能出现错误的代码放在try中//如果没有出错直接走①处的代码
                                      //如果try中的代码出现了异常,找catch,执行catch中的代码
       }catch(异常类型 异常变量){
          // 处理异常的代码
       }
       //代码①
     2.多异常处理:(重点执行第一种)
            try{
                //可能出现错误的代码放在try中
            }catch(异常类型1 异常变量){//接收try中出现异常类型1的异常对象,然后执行处理代码
               // 处理异常的代码
            }catch(异常类型2 异常变量){//接收try中出现异常类型2的异常对象,然后执行处理代码
               // 处理异常的代码       //两者只会执行一个
                                           //当用catch处理后,代码①正常执行
            }
            //代码①

            try{
                //可能出现错误的代码放在try中
            }catch(异常类型1|异常类型2... 异常变量){//如果try中抛出异常类型1对象,就用异常类型1 来接收
                                                       //如果try中抛出异常类型2对象,就用异常类型2 来接收
               // 多个处理异常的代码都放在一起
            }
         3.throws:异常声明
           修饰符 返回值类型 方法名(形参列表) throws 异常类型1,异常类型2...{
                     可能抛出异常类型1
                     可能抛出异常类型2
          ...
           }
           public static void main(String[] args) /*throws ParseException*/ {
                          
                           try {
                                   //由于调用了抛出异常的方法,当产生异常时会将异常由method方法抛到main方法，由main方法处理异常。
                                   method();
                           } catch (ArithmeticException | ParseException e) {
                                   e.printStackTrace();
                                   System.err.println("我是异常处理代码，不要看错了，我不是报错！！↑");
                           }
                           System.out.println("异常处理后的代码");
                   }
                  
                   //定义声明抛出异常的方法
                   public static void method() throws ParseException{ //sf.parse(s)会抛出编译时异常ParseException,我们这里不处理,交给他人处理,
                                                                           //所以用throws声明,交给调用者处理
                           //产生异常的准备                              //运行时异常可以不用显式throws
                           String s = "1949-10-01";   
                           DateFormat sf = new SimpleDateFormat("yyyy-MM！dd");
                          
                           Date date = sf.parse(s);
                    
                           System.out.println(1/0);
                            
                   }
   d.自定义异常类:目的为了见名知义
      class 异常类名 extends Exception/RuntimeException{//继承Exception为编译时异常,继承RuntimeException为运行时异常
         public 异常类名 (){

         }
         public 异常类名(String message){//当外部创建该自定义异常类的对象时候,可以传递一些对该异常的描述信息

         }
      }

      class Demo{
        public static void main(String[] args) {
                 //throw new 异常类名(对异常信息描述的字符串);//该异常对象由于在main方法中,被JVM调用,JVM会采用默认的处理机制
                                                           //直接打印到控制台上
        

              try{
                 throw new 异常类名(对异常信息描述的字符串);
              }catch(异常类名 e){
                //处理代码
              }
            
        }


      }
   
    e.异常在继承中的注意事项:
      class Father{
               void method1()throws RuntimeException,NullPointerException{

               }
               void method2(){

               }
      }
      class Son extends Father{
               void method1()throws RuntimeException/NullPointerException/RuntimeException,NullPointerException{//只能throws父类异常子集,
                                                                                                                   //也可以不做任何声明


               }
               void method2(){
                 try{//只能做try..catch处理因为父类的method2没有throws任何异常
             throw new ParseException();
           }catch(Exception e){

           }
               }
      }
    f.finally:放在finally的语句一定被执行,要和try..catch结合使用
     1. try{
          //无论try中的代码是否抛出异常,finally中的语句一定会被执行
       }finally{
         //放在finally中的代码一般是释放资源的代码
               //在IO操作中需要释放占用的系统底层的资源
               //无论是否操作成功,我都要释放系统资源
        //与数据连接也会占用服务器的资源,无论用户是否建立连接成功,我都要释放资源
       }
     2.try{
        //无论try中的代码是否抛出异常,finally中的语句一定会被执行
      }catch(异常类型 e){

      }finally{

      }
     3.finally与return语句:
       public int method2() {
                     //定义返回值
                     int i = 100;
                     //产生异常的准备
                     String s = "1949-10-01";
                     DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

                     try {
                             Date date = sf.parse(s);
                             //返回路径：每次碰到return就会在返回路径中临时存储这个被返回的值，无论方法内有任何的改变，返回路径中的这个值一致不变。
                              return i;
                              /*
                               //相当于以下三行代码
                               int temp=i;//temp=100;
                               i=200;
                               return temp;//100
                               */
                              
                     } catch (ParseException e) {
                             e.printStackTrace();
                     } finally {
                             i = 200;
                             System.out.println("我一定会被执行~"+i);
                              
                     }
             System.out.println("异常过后执行其他代码");
             return i;
             }



               public int method2() {
                             //定义返回值
                             int i = 100;
                             //产生异常的准备
                             String s = "1949-10-01";
                             DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

                             try {
                                     Date date = sf.parse(s);
                                     //返回路径：每次碰到return就会在返回路径中临时存储这个被返回的值，无论方法内有任何的改变，返回路径中的这个值一致不变。
                                      return i;
                                      /*
                                       //相当于以下三行代码
                                       int temp=i;//temp=100;
                                       i=200;
                                       temp=i;//temp=200
                                       return temp;//200
                    
                                       */
                                      
                             } catch (ParseException e) {
                                     e.printStackTrace();
                             } finally {
                                     i = 200;
                                     System.out.println("我一定会被执行~"+i);
                                      
                             }
            
                     }

1.Map集合:存储的是key=value键值对,key不能重复,value可以重复
  a.方法:
    put(key,value)//把键值对添加到HashMap集合
                 //如果添加重复的key,会把当前key对应的value覆盖掉              
                 //例如:第一次put("张三",80),第二次put("张三",50)
                //结果:map中的key=value变成 张三=50
         
    V get(key)//根据key返回对应的value

    V remove(key)//根据key删除对应的value,返回value值
2.Map集合遍历:将双列集合转换成单列,为了使用单列集合的迭代器
  a.利用keySet()方法
    1.调用keySet()方法将Map中的key封装一个Set集合中
    2.再利用迭代器(增强for)遍历Set集合取出一个个key
    3.根据取出的key再去Map利用get(key)方法取出对应value
  b.利用entrySet()方法
    内部接口:
    interface Map<K,V>{
      interface Entry<K,V>{//如果像使用Entry接口需要使用外部接口.内部接口Map.Entry<K,V>
      }
    }
    1.调用entrySet()方法将Map中的所有key=value封装成一个个Entry对象,把一个个Entry对象放到set
      集合中
    2.再利用迭代器(增强for)遍历Set集合取出一个个Entry对象
    3.再利用Entry对象中的方法getKey(),getValue取出键和值


3.JDK1.5新特性
  a.可变参数
    int[] arr={1,2,34}
    method(1,2,3,4);
    method(arr);

    public void method(int...arr){//底层会自动创建一个数组对象
                                     //把1,2,3,4存到数组里面
                                 //既可以接收数组对象,也可以接收任意多个参数
    }
    // public void method(int[]arr){ //数组的引用类型和可变参数不够成重载关系

    // }

    method(1.3,2.3.3.3)
    // public void method(double...arr,double d){//第一个可变参数把所有的实参都接收了,结果导致第二个参数接收任何实参

    // }

      public void method(double d , double...arr){//1.3赋值给了d,2.3,3.3封装到arr数组中
                                                  //可变参数定义在形参列表末尾
      }


4.数据结构之栈和队列,数组,链表
数组:用连续的内存单元存储
链表:用不连续的内存单元存储
栈:先进后出/后进先出(FILO) First In Last Out (手枪弹夹)
队列:先进先出/后进后出(FIFO) First In First Out(银行排队)

5.异常体系
  a.概述:
    Java 运用面向对象的思想将程序可能出现的 错误 封装成对应的类
  b.体系:
    Throwable
      Error:严重错误,无法处理 服务器宕机 数据库崩溃 内存溢出
      Exception:
        RuntimeException及其子类:在运行时抛出异常 运行时异常
        非RuntimeException及其子类:编译是抛出的异常 编译时异常
  c.异常处理
    1.单一异常的处理
       try{
           //可能出现错误的代码放在try中//如果没有出错直接走①处的代码
                                      //如果try中的代码出现了异常,找catch,执行catch中的代码
       }catch(异常类型 异常变量){
          // 处理异常的代码
       }
       //代码①
     2.多异常处理:(重点执行第一种)
            try{
                //可能出现错误的代码放在try中
            }catch(异常类型1 异常变量){//接收try中出现异常类型1的异常对象,然后执行处理代码
               // 处理异常的代码
            }catch(异常类型2 异常变量){//接收try中出现异常类型2的异常对象,然后执行处理代码
               // 处理异常的代码       //两者只会执行一个
                                           //当用catch处理后,代码①正常执行
            }
            //代码①

            try{
                //可能出现错误的代码放在try中
            }catch(异常类型1|异常类型2... 异常变量){//如果try中抛出异常类型1对象,就用异常类型1 来接收
                                                       //如果try中抛出异常类型2对象,就用异常类型2 来接收
               // 多个处理异常的代码都放在一起
            }
         3.throws:异常声明
           修饰符 返回值类型 方法名(形参列表) throws 异常类型1,异常类型2...{
                     可能抛出异常类型1
                     可能抛出异常类型2
          ...
           }
           public static void main(String[] args) /*throws ParseException*/ {
                          
                           try {
                                   //由于调用了抛出异常的方法,当产生异常时会将异常由method方法抛到main方法，由main方法处理异常。
                                   method();
                           } catch (ArithmeticException | ParseException e) {
                                   e.printStackTrace();
                                   System.err.println("我是异常处理代码，不要看错了，我不是报错！！↑");
                           }
                           System.out.println("异常处理后的代码");
                   }
                  
                   //定义声明抛出异常的方法
                   public static void method() throws ParseException{ //sf.parse(s)会抛出编译时异常ParseException,我们这里不处理,交给他人处理,
                                                                           //所以用throws声明,交给调用者处理
                           //产生异常的准备                              //运行时异常可以不用显式throws
                           String s = "1949-10-01";   
                           DateFormat sf = new SimpleDateFormat("yyyy-MM！dd");
                          
                           Date date = sf.parse(s);
                    
                           System.out.println(1/0);
                            
                   }
   d.自定义异常类:目的为了见名知义
      class 异常类名 extends Exception/RuntimeException{//继承Exception为编译时异常,继承RuntimeException为运行时异常
         public 异常类名 (){

         }
         public 异常类名(String message){//当外部创建该自定义异常类的对象时候,可以传递一些对该异常的描述信息

         }
      }

      class Demo{
        public static void main(String[] args) {
                 //throw new 异常类名(对异常信息描述的字符串);//该异常对象由于在main方法中,被JVM调用,JVM会采用默认的处理机制
                                                           //直接打印到控制台上
        

              try{
                 throw new 异常类名(对异常信息描述的字符串);
              }catch(异常类名 e){
                //处理代码
              }
            
        }


      }
   
    e.异常在继承中的注意事项:
      class Father{
               void method1()throws RuntimeException,NullPointerException{

               }
               void method2(){

               }
      }
      class Son extends Father{
               void method1()throws RuntimeException/NullPointerException/RuntimeException,NullPointerException{//只能throws父类异常子集,
                                                                                                                   //也可以不做任何声明


               }
               void method2(){
                 try{//只能做try..catch处理因为父类的method2没有throws任何异常
             throw new ParseException();
           }catch(Exception e){

           }
               }
      }
    f.finally:放在finally的语句一定被执行,要和try..catch结合使用
     1. try{
          //无论try中的代码是否抛出异常,finally中的语句一定会被执行
       }finally{
         //放在finally中的代码一般是释放资源的代码
               //在IO操作中需要释放占用的系统底层的资源
               //无论是否操作成功,我都要释放系统资源
        //与数据连接也会占用服务器的资源,无论用户是否建立连接成功,我都要释放资源
       }
     2.try{
        //无论try中的代码是否抛出异常,finally中的语句一定会被执行
      }catch(异常类型 e){

      }finally{

      }
     3.finally与return语句:
       public int method2() {
                     //定义返回值
                     int i = 100;
                     //产生异常的准备
                     String s = "1949-10-01";
                     DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

                     try {
                             Date date = sf.parse(s);
                             //返回路径：每次碰到return就会在返回路径中临时存储这个被返回的值，无论方法内有任何的改变，返回路径中的这个值一致不变。
                              return i;
                              /*
                               //相当于以下三行代码
                               int temp=i;//temp=100;
                               i=200;
                               return temp;//100
                               */
                              
                     } catch (ParseException e) {
                             e.printStackTrace();
                     } finally {
                             i = 200;
                             System.out.println("我一定会被执行~"+i);
                              
                     }
             System.out.println("异常过后执行其他代码");
             return i;
             }



               public int method2() {
                             //定义返回值
                             int i = 100;
                             //产生异常的准备
                             String s = "1949-10-01";
                             DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

                             try {
                                     Date date = sf.parse(s);
                                     //返回路径：每次碰到return就会在返回路径中临时存储这个被返回的值，无论方法内有任何的改变，返回路径中的这个值一致不变。
                                      return i;
                                      /*
                                       //相当于以下三行代码
                                       int temp=i;//temp=100;
                                       i=200;
                                       temp=i;//temp=200
                                       return temp;//200
                    
                                       */
                                      
                             } catch (ParseException e) {
                                     e.printStackTrace();
                             } finally {
                                     i = 200;
                                     System.out.println("我一定会被执行~"+i);
                                      
                             }
            
                     }