2017

1 集合的特点
集合
  Collection(单列集合)
     (1)List(有序，可重复)
         A: ArrayList 
               底层数据结构是数组，查询快，增删慢
               线程不安全，效率高
         B: Vector
               底层数据结构是数组，查询快，增删慢
               线程安全，效率低
         C: LinkedList
               底层数据结构是链表，查询慢，增删快
               线程不安全，效率高
     (2)Set(无序，唯一)
         A: HashSet
               底层数据结构是哈希表
               哈希表依赖两个方法：hashCode()和equals()
               执行顺序：
          首先判断hashCode()值是否相同
        相同：继续执行equals()方法
       返回true：元素重复了，不添加
       返回false：直接把元素添加到集合
        不同：就直接把元素添加到集合
               最终：
                    自动生成hashCode()和equals()即可
               
              a: LinkedHashSet
                   底层数据结构由链表和哈希表组成。
                   由链表保证元素有序。
                   由哈希表保证元素唯一。
          B: TreeSet
                 底层数据结构是红黑树(是一种自平衡的二叉树)
                 如何保证元素唯一性呢？
                        根据比较的返回值是否是0来决定
                 如何保证元素的排序呢？
                        两种方式       
                           自然排序(元素具备比较性)
                                让元素所属的类实现Comparable接口
                           比较器排序(集合具备比较性)
                                让集合接收一个Comparator的实现类对象
  Map(双列集合)
       A:Map集合的数据结构仅仅针对键有效，与值无关。
       B:存储的是键值对形式的元素，键唯一，值可重复
      (1)HashMap
           底层数据结构是哈希表。线程不安全，效率高。
               哈希表依赖两个方法：hashCode()和equals()
               执行顺序：
          首先判断hashCode()值是否相同
        相同：继续执行equals()方法
       返回true：元素重复了，不添加
       返回false：直接把元素添加到集合
        不同：就直接把元素添加到集合
               最终：
                    自动生成hashCode()和equals()即可     
            A: LinkedHashMap
                 底层数据结构由链表和哈希表组成。
                        由链表保证元素有序。
                        由哈希表保证元素唯一。
       (2)Hashtable
          底层数据结构是哈希表。线程安全，效率低。
               哈希表依赖两个方法：hashCode()和equals()
               执行顺序：
          首先判断hashCode()值是否相同
        相同：继续执行equals()方法
       返回true：元素重复了，不添加
       返回false：直接把元素添加到集合
        不同：就直接把元素添加到集合
               最终：
                    自动生成hashCode()和equals()即可     
            A: LinkedHashMap
                 底层数据结构由链表和哈希表组成。
                        由链表保证元素有序。
                        由哈希表保证元素唯一。
       (3)TreeMap
             底层数据结构是红黑树(是一种自平衡的二叉树)
                 如何保证元素唯一性呢？
                        根据比较的返回值是否是0来决定
                 如何保证元素的排序呢？
                        两种方式       
                           自然排序(元素具备比较性)
                                让元素所属的类实现Comparable接口
                           比较器排序(集合具备比较性)
                                让集合接收一个Comparator的实现类对象
        
2  异常
(1)程序出现了不正常的情况
举例：今天天气很好，班长出去旅行，骑着自行车，去山里面呼吸新鲜空气
       问题1：山路坍塌了，班长及时停住了，但是过不去了。严重的问题。
       问题2：班长出门推自行车，发现气没了，把气吹起来。出发前就应该检查的问题。
       问题3：班长骑着车在山路上惬意的行驶着，山路两边是有小石子的，中间是光滑的水泥路。
             一直在平坦的水泥路上行驶，是没有任何问题的，但是，他偏偏要骑到小石子上，结果爆胎了。旅道的过程中出现的问题、
(2)
  程序的异常：Throwable
      严重问题：Error  我们不处理，这种问题一般都是很严重的，比如说内存溢出。
      问题：Exception
          编译期问题：不是RuntimeException的异常   必须进行处理的，因为你不处理，编译就不能通过。
          运行期问题：RuntimeException   这种问题我们也不处理，因为是你的问题，而且这个问题出现肯定是我们的代码不够严谨，需要修改代码。
(3)JVM默认处理异常：
如果程序出现了问题，我们没有做任何处理，最终jvm会做出默认的处理。
把异常的名称，原因以及出现的问题等信息输出在控制台。
同时会结束程序。
(4)我们自己如何进行处理异常呢？
A:try...catch...finally
B:throws 抛出

try...catch...finally的处理格式：  
      try{
           可能出现问题的代码：
       }catch(异常名 变量){
           针对问题的处理：
       }finally {
           释放资源;
       }
变形格式：
       try{
            可能出现问题的代码;
        }catch(异常名 变量){
             针对问题的处理;
        }
***注意事项：
       1：能明确的尽量明确，不要用大的来处理。
       2：平级关系的异常谁前谁后无关系，如果出现了子父关系，父必须在后面
***注意：
      A：try里面的代码越少越好。
      B：catch里面必须有内容，哪怕是给出一个简单的提示
      C：一旦try里面出了问题，就会在这里把问题给抛出去，然后和catch里面的问题进行匹配。一旦有匹配的，就执行了catch里面的处理，然后结束了try...catch。继续执行后面的语句。
------------------------------------------------
A:一个异常
B:二个异常
    a:每一个写一个try...catch
    b:写一个try，多个catch
------------------------------------------------
//一个异常的处理
    int a = 10;
    //int b =2;
    int b =0;
    
    try{
       System.out.println(a/b);
     }catch(ArithmeticException ae){
       System.out.println("除数不能为0");
     }
     
     System.out.println("over");
     
     //输出：  除数不能为0
               over
------------------------------------------------  
//两个异常的处理
  int a = 10;
  int b = 0;
  int[] arr = {1,2,3};
  try{
       System.out.println(arr[3]);
       System.out.println(a/b);
     }catch(ArithmeticException e){
       System.out.println("除数不能为0");
     }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("你访问了不该访问的索引");
     }
     System.out.println("over");
     //输出： 你访问了不该访问的索引
              over
-------------------------------------------------
//如果无法明确异常
  int a = 10;
  int b = 0;
  int[] arr = {1,2,3};
  try{
       System.out.println(arr[3]);
       System.out.println(a/b);
       System.out.println("这里出现了一个异常，你不太清楚是谁，该怎么办呢？");
     }catch(Exception e){
       System.out.println("出问题了");
     }
     System.out.println("over");
     //输出： 出问题了
              over
---------------------------------------------------
//正常情况
  try{
       System.out.println(arr[3]);
       System.out.println(a/b);
       System.out.println("这里出现了一个异常，你不太清楚是谁，该怎么办呢？");
     }catch(ArithmeticException e){
       System.out.println("除数不能为0");
     }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("你访问了不该访问的索引");
     }catch(Exception e){
       System.out.println("出问题了");
     }
---------------------------------------------------
(5) JDK7针对多个异常的处理方案
    try{
     }catch(异常名1 | 异常名2 | ... 变量) {
   }
   注意：这个方法虽然简洁，但是也不够好。
      A:处理方式是一致的(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)
      B:多个异常间必须是平级关系。(Exception会出错)
 
   //jdk7的处理方案  
    try{
       System.out.println(arr[3]);
       System.out.println(a/b);
     }catch(ArithmeticException | ArrayIndexOutOfBoundsException e){
       System.out.println("出问题了");
     }

3 编译期异常和运行期异常
区别
编译期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
运行期异常：无需显示处理，也可以和编译时异常一样处理

在try里面发现问题后，jvm会帮我们生成一个异常对象，然后把这个对象抛出，和catch里面的类进行匹配。
如果该对象是某个类型的，就会执行该catch里面的处理信息。

4 Throwable的几个常见方法
异常中要了解的几个方法：
  public String getMessage():异常的消息字符串
  public String toString():返回异常的简单信息描述
      此对象的类name(全路径名)
      ":"(冒号和一个空格)
      调用此对象getLocalizedMessage()方法的结果(默认返回的是getMessage()内容)
  printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void，把信息输出在控制台。

  String s = "2014-11-20";
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  try{
       Date d = sdf.parse(s);
       System.out.println(d);
   }catch(ParseException e){  //ParseException e = new ParseException();
     //getMessage()
     //System.out.println(e.getMessage());
     //Unparseable date:"2014-11-20"
  
     //toString()
     //System.out.println(e.toString());
     //java.text.parseException:Unparseable date:"2014-11-20"

      e.printStackTrace();
     //跳转到某个指定的页面(index.html)
  }
   System.out.println("over");
       
5 throws的方式处理异常
有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。
或者说，我处理不了，就不处理了。
为了结局出错问题，java针对这种情况，就提供了另一种处理方案：抛出。

格式：
       throws 异常类名
       注意：这个格式必须跟在方法的括号后面

注意：尽量不要在main方法上抛出异常
      但是讲课为了方便就这样做了。。。

小结：
      编译期异常抛出，将来调用者必须处理。
      运行期异常抛出，将来调用可以不用处理。
-------------------------------------------------------------
    System.out.println("今天天气真好！");
  //编译时异常处理
   try{
        method();
    }catch(ParseException e){
        e.printStackTrace();
  }
    System.out.println("但是就是不该有雾霾");   
     method2();

   //运行期异常的抛出  不需要异常处理
   public static void method2() throws ParseException(){
          int a = 10;
          int b =0;
          System.out.println(a/b);
 }
    //编译时异常的抛出
    public static void method() throws ParseException(){
           String s = "2014-11-20";
           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           Date d = sdf.parse(s);
           System.out.println(d);
  }

   //输出：       今天天气真好！
                  一段java错误提示...
                 但是就是不该有雾霾
                  一段java错误提示...
---------------------------------------------------------------
6 throw的概述以及和throws的区别
throw：如果出现了异常情况，我们可以把异常抛出，这个时候抛出的应该是异常的对象
(在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出)

***
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常
   public static void method(){
       int a = 10;
       int b = 0;
       if(b ==0){
          throw new ArithmeticException();
        }else{
             System.out.println(a/b);
       }
    }

7 异常处理使用情况
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws。
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws

***8 finally
(1)finally：异常处理，一般都会执行
格式
     try...catch...finally
----------------------------
(2)面试题 final finally finalize 三者的区别
final:最终的意思，可以修饰类，成员变量，成员方法
      修饰类，类不能被继承
      修饰变量，变量是常量
      修饰方法，方法不能被重写
finally:是异常处理的一部分，用于释放资源
        一般来说，代码肯定会执行。特殊情况：在执行到finally之前，jvm退出，例如System.exit();
finalize:是Object类的一个方法，用于垃圾回收。

(3)面试题 如果catch里面有return语句，请问finally里面的代码还有执行吗
          如果会，请问在return前，还是return后。
   会，因为除非jvm退出，否则finally能执行。
   前。
 更准确的说，是在return 的中间。

   int a = 10;
   try{
       System.out.println(a/0);
       a = 20;
     }catch (ArithmeticException e){
           a = 30;
           return a;
            // return a 在程序执行到这一步的首，这里不是return a，而是return 30 ，这个返回路径就完成了。
            // 但是，它发现后面还有finally ，所以继续执行finally的内容， a =40
            //再次回到以前的返回路径，继续走return 30
      }finally{
        a = 40;
        //return a; 如果这里有return a 则返回的是 40
      }
     return a;
   }   

9 异常注意事项
A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

10 File类的概述和构造方法
我们要想实现IO的操作，就必须知道硬盘上文件的表现形式
而java提供了一个类File供我们使用

File：文件和目录(文件夹)路径名的抽象表示形式

(1)构造方法：
     File(String pathname):根据一个路径得到File对象
     File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
     File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
----------------------------------
    //File(String pathname):根据一个路径得到File对象
    //把e:\\demo\\a.txt封装成一个File对象
    File file = new File("E:\\demo\\a.txt");
    
    //File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
    File file2 = new File("E:\\demo","a.txt");
  
    //File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
    File file3 = new File("e:\\demo");
    File file4 = new File(file3,"a.txt");
    //以上三种方式其实一样

(2)创建功能
public boolean createNewFile():创建文件
public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了
public Boolean mkdirs():创建文件夹，如果目录不存在，则创建该目录
   //需求，在e盘目录下创建一个文件夹demo
   File file = new File("e:\\demo");
   System.out.println("mkdir:"+file.mkdir());
   
   //需求：在e盘目录demo下创建一个文件a.txt
   File file2 = new File("e:\\demo\\a.txt");
   System.out.println("createNewFile:"+file2.createNewFile());
   
   //需求：在e盘目录test下创建一个文件b.txt
   File file3 = new File("e:\\test\\a.txt");
   System.out.println("createNewFile:"+file3.createNewFile());
   //会报错！ 注意：想要在某个目录下创建内容，该目录必须存在

   //需求，在e盘目录test下创建目录aaa
   File file4 = new File("e:\\test\\aaa");
   System.out.println("mkdir:"+file4.mkdir());
   //会报错，需要一步一步来

   File file5 = new File("e:\\test");
   System.out.println("mkdir:"+file5.mkdir());  
   File file6 = new File("e:\\test\\aaa");
   System.out.println("mkdir:"+file6.mkdir());

   //其实还有更简单的方法
   File file7 = new File("e:\\aaa\\bbb\\ccc\ddd");
   System.out.println("mkdirs:"+file7.mkdirs());  

(3)删除功能
public boolean delete():
A:如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下
B:Java中的删除不走回收站
C:要删除一个文件夹，请注意该文件夹不能包含文件或文件夹

    File file = new File("e:\\aaa\\bbb");
    System.out.println("mkdirs:"+file.mkdirs());  

    File file2 = new File("e:\\aaa");
    System.out.println("delete:"+file2.delete());
    //删除失败 因为 aaa文件夹中有东西，必须全部删除后，才能删除aaa
   
    File file3 = new File("e:\\aaa\\bbb");
    System.out.println("delete:"+file3.delete());
    File file4 = new File("e:\\aaa");
    System.out.println("delete:"+file4.delete());

(4)重命名功能
路径以盘符开始：绝对路径 c:\\a.txt
路径不以盘符开始：相对路径 a.txt

public boolean renameTo(File dest)
//创建一个文件对象
File file = new File("林青霞.jpg");
//改名
File newFile = new File（"东方不败.jpg"）;
file.renameTo(newFile);

(5)判断功能
public boolean isDirectory() :判断是否是目录
public boolean isFile() :判断是否是文件
public boolean exists() :判断是否存在
public boolean canRead() :判断是否可读
public boolean canWrite() :判断是否可写
public boolean isHidden() :判断是否隐藏

(6)获取功能
public String getAbsolutePath() :获取绝对路径
public String getPath() :获取相对路径
public String getName() :获取名称
public long length() : 获取长度，字节数
public long lastModified() :获取最后一次的修改时间，毫秒值

(7)高级获取功能
public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles() :获取指定目录下的所有文件或者文件夹的File数组
//指定一个目录
File file = new File("e:\\");
//public String[] list()
String strArray = file.list();
for(String s : strArray){
    Sytstem.out.println(s);
 }

//public File[] listFiles()
File[] fileArray = file.listFiles();
for(File f : fileArray){
       Sytem.out.println(f.getName());
 }

(8)输出指定目录下指定后缀名的文件名
//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的file数组
File[] fileArray = file.listFiles();
//遍历该File数组，得到每一个File对象，然后判断
for(File f : fileArray){
    //是否是文件
   if(f.isFile()){
       //继续判断是否以.jpg结尾
      if(f.getName().endsWith(".jpg"))
          //输出该文件名称
         System.out.println(f.getName());
    }
}

(9) 改进输出指定目录下的指定后缀名的文件名
A:先获取所有的，然后遍历的时候，一次判断，如果满足条件就输出
B:获取的时候就已经是满足条件了的，然后输出即可

想要实现这个效果，就必须学习一个接口:文件名称过滤器
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)

//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的String数组
//public String[] list(FilenameFilter filter)
String[] strArray = file.list(new FilenameFilter(){
   @Override
  public boolean accpet(File dir,String name){
            //return false
            //return true
            //通过这个测试，我们知道了，到底把这个文件或者文件夹的名称加不加到数组中，取决于这里的返回值是true还是false
            //所以，这个的true或者false应该是通过某种判断得到的
            File file = new File(dir,name);
            //System.out.println(file)
            boolean flag = file.isFile();
            boolean flag2 = name.endsWith(".jpg");
            return flag && flag2;
            for(String s : strArray){
                  System.out.println(s);
          }

        //return new File(dir,name).isFile() &&name.endsWith(".jpg");

}