黑马程序员技术交流社区

标题: 集合下 ----->小尾巴梦工厂 [打印本页]

作者: 柒月份的尾巴丶 时间: 2016-7-27 22:06
标题: 集合下 ----->小尾巴梦工厂
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);

     }

     }

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2