1. package cn.Exception;
    2. /**
    3.  * 异常：程序出了不正常的情况
    4.  *      程序出现的问题：
    5.  *          1、严重问题：（Error）（不处理，这种问题一般解决不了，比如内存溢出）
    6.  *          2、一般问题：（Exception）
    7.  *                  a、编译期问题:不是RuntimeException的异常（必须处理，如果不处理，编译不能通过）
    8.  *                  b、运行期问题：RuntimeException（不处理，因为代码不够严谨，需要修正代码）
    9.  *
    10.  *      如果程序出现了问题，我们没有做处理，最终JVM会做出默认的处理
    11.  *      把异常的名称，原因及出现的问题等在控制台输出
    12.  *      同时会结束程序，但是后面的程序无法执行
    13.  *
    14.  * */
    15. public class ExceptionDemo {
    16.     public static void main(String[] args) {
    17.         int a = 10;
    18.         //int b = 2;
    19.         //System.out.println(a/b);
    20.         int c = 0;
    21.         System.out.println(a/c);
    22.         System.out.println("over");
    25.     }
    26. }
    1. package cn.Exception;
    2. /**
    3.  * 如何处理异常
    4.  *      1、try……catch……finally
    5.  *      2、throws（抛出）
    6.  *
    7.  *      try …… catch ……finally 格式
    8.  *          try{
    9.  *              可能出现问题的代码
    10.  *          }catch(异常变量名){
    11.  *              针对问题的处理
    12.  *          }finally{
    13.  *              释放资源
    14.  *          }
    15.  *
    16.  *          变形格式
    17.  *          try{
    18.  *              可能出现的问题
    19.  *          }catch（异常变量名）{
    20.  *              针对问题的处理
    21.  *          }
    22.  *
    23.  *          注意：
    24.  *              1、try 里面的问题越少越好
    25.  *              2、catch里面必须有内容
    26.  *
    27.  * */
    28. public class ExceptionDemo_02 {
    29.     public static void main(String[] args) {
    30.         //第一阶段
    31.         int a = 10;
    32.         //int b = 2;
    33.         int b = 0;
    35.         try {
    36.             System.out.println(a / b);
    37.         }catch(ArithmeticException ae){
    38.             System.out.println("除数不能为0");
    39.         }
    41.         //第二阶段
    42.         System.out.println("over");
    44.     }
    45. }
    1. package cn.Exception;
    2. /**
    3.  * 1、一个异常
    4.  * 2、写一个try多个catch
    5.  *      try{
    6.  *          ……
    7.  *      }catch(){
    8.  *          ……
    9.  *      }catch(){
    10.  *          ……
    11.  *      }
    12.  *
    13.  *
    14.  *
    15.  *      能明确的问题，就尽量明确，实在找不出就使用Exception
    16.  *      Exception 是可以匹配所有的问题，只能放在最后
    17.  *
    18.  *
    19.  * */
    20. public class ExceptionDemo_03 {
    21.     public static void main(String[] args) {
    23.     //method1();
    24.     //method2();
    25.         method3();
    27.     }
    29.     private static void method3() {
    30.         int a = 10;
    31.         int b = 0;
    32.         int[] arr = {1, 2, 3};
    33.         try {
    34.             System.out.println(a / b);
    35.             System.out.println(arr[3]);
    36.         }
    37. //        catch (ArithmeticException ae) {
    38. //            System.out.println("除数不能为0");
    39. //        } catch (ArrayIndexOutOfBoundsException ae) {
    40. //            System.out.println("索引越界");
    41. //        }
    42.         catch(Exception e){
    43.             System.out.println("出问题了");         //这个只能放在最后，否则后面的catch会保错
    44.         }
    45.         System.out.println("over");
    46.     }
    48.     private static void method2() {
    49.         int a = 10;
    50.          int b = 0;
    51.          try {
    52.              System.out.println(a / b);
    53.          }catch(ArithmeticException ae){
    54.              System.out.println("除数不能为0");
    55.          }
    56.          int []arr= {1,2,3};
    57.         try{
    58.             System.out.println(arr[3]);
    59.         }catch(ArrayIndexOutOfBoundsException ae){
    60.             System.out.println("索引越界");
    61.         }
    63.         System.out.println("over");
    65.     }
    68.     public  static void method1() {
    69.         //第一阶段
    70.         int a = 10;
    71.         //int b = 2;
    72.         int b = 0;
    74.         try {
    75.             System.out.println(a / b);
    76.         }catch(ArithmeticException ae){
    77.             System.out.println("除数不能为0");
    78.         }
    80.         //第二阶段
    81.         System.out.println("over");
    82.     }
    85. }
    1. package cn.Exception;
    2. /**
    3.  * JDK7出现了一个新特性
    4.  *      try{
    5.  *          ……
    6.  *      }catch(异常名1|异常名2|……变量名){
    7.  *          ……
    8.  *      }
    9.  *      
    10.  *      注意：
    11.  *          1、这种方式是一致的（开发中可能就会针对同一类型的问题，给出同一个处理）
    12.  *          2、多个异常间必须是平级关系（不能使用Exception）
    13.  *
    14.  *
    15.  * */
    16. public class ExceptionDemo_04 {
    17.     public static void main(String[] args) {
    18.         int a  = 10;
    19.         int b = 0;
    20.         int [] arr  = {1,2,3};
    22. //        try{
    23. //            System.out.println(a/b);
    24. //            System.out.println(arr[3]);
    25. //            System.out.println("这里出现了问题，怎么办");
    26. //        }catch(ArithmeticException ae){
    27. //            System.out.println("除数不能为0");
    28. //        }catch(ArrayIndexOutOfBoundsException ae){
    29. //            System.out.println("索引越界");
    30. //        }catch(Exception e){
    31. //            System.out.println("出问题了");
    32. //        }
    33. //        System.out.println("over");
    35.         //JDK7的处理方案
    36.         try{
    37.             System.out.println(a/b);
    38.             System.out.println(arr[3]);
    39.             System.out.println("这里出现了问题，怎么办");
    40.         }catch(ArithmeticException |ArrayIndexOutOfBoundsException ae){
    41.             System.out.println("出问题了");
    42.         }
    43.         System.out.println("over");
    46.     }
    47. }

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

    1. package cn.Exception;
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    7. /**
    8.  * 编译时异常和运行时异常的区别
    9.  *      编译时异常：java程序必须显示处理，否则就会发生错误，无法通过编译
    10.  *      运行时异常：无需显示处理，也可以和编译时异常一样处理
    11.  *
    12.  *      在try里面发现问题，JVM会帮我们生成一个异常对象，然后把这个对象抛出，，和catch 里面的类进行匹配
    13.  *      如果该对象是某个类型，就会执行catch里面的处理信息
    14.  *
    15.  *      异常中要了解几个方法：
    16.  *          public String getMessage()  异常消息的字符串
    17.  *
    18.  *          public String toString()    返回异常的简单信息描述
    19.  *              此对象的类的 name
    20.  *              ": "（冒号和一个空格）
    21.  *              调用此对象 getLocalizedMessage() 方法的结果（默认返回的是getMessage()的内容）
    22.  *
    23.  *          printStackTrace()       获取异常类名和异常信息，一讲话异常出现在程序的位置，返回值void,把信息输出在控制台（相当于toString）
    24.  * */
    25. public class Exception_05 {
    26.     public static void main(String[] args)  {
    27. //        int a = 10;
    28. //        int b = 0;
    29. //        if(b!=0){
    30. //            System.out.println(a/b);
    31. //        }
    32.         String s = "2014-11-20";
    33.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    34.         try {
    35.             Date d = sdf.parse(s);          //创建一个ParseException 对象，然后抛出，和catch里面的进行匹配
    36.             System.out.println(d);
    37.         } catch (ParseException e) {        //ParseException e = new ParseException();
    38.             //e.printStackTrace();
    40.             //getMessage()
    41.             System.out.println(e.getMessage());     //Unparseable date: "2014-11-20"
    43.             //toString
    44.             System.out.println(e.toString());       //java.text.ParseException: Unparseable date: "2014-11-20"
    46.             e.printStackTrace();
    50.         }
    51.         System.out.println("over");
    54.     }
    55. }
    1. package cn.Exception;
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    6. /**
    7.  *  有的时候，我们是可以对异常进行处理的，但有的时候没有权限去处理某个异常
    8.  *  为了解决这个问题，java针对这种情况提供了一种处理方案：抛出（throws）
    9.  *      格式：
    10.  *          throws 异常类名
    11.  *      注意：
    12.  *          1、这个格式必须是跟在方法的括号后面的
    13.  *          2、尽量不要在main方法上面抛出异常
    14.  *
    15.  *          ArithmeticException        算数异常
    16.  *           parseException             解析异常
    17.  *           
    18.  *           小结：
    19.  *              编译期异常抛出，奖励啊调用必须处理，
    20.  *              运行期异常抛出，将来调用可以不用处理
    21.  *
    22.  * */
    24. public class ExceptionDemo_06 {
    25.     public static void main(String[] args) {
    26.         System.out.println("今天天气很好");
    27.         try {
    28.             method();
    29.         } catch (ParseException e) {
    30.             e.printStackTrace();
    31.         }
    32.         System.out.println("但是就不该有雾霾");
    34.         method2();
    35.     }
    37.     private static void method2() throws ArithmeticException{
    38.         int a = 10;
    39.         int b = 0;
    40.         System.out.println(a/b);
    41.     }
    43.     public static void method()  throws ParseException {
    44.         String s  = "2014-11-20";
    45.         SimpleDateFormat sdf = new SimpleDateFormat();
    46.         Date d  = sdf.parse(s);
    47.         System.out.println(d);
    48.     }
    49. }
    1.  * throw:如果出现了异常情况我们可以把异常抛出，这个时候抛出的是异常的对象
    2.  * throws:在方法上面声明异常（表示的是一种异常的可能性）
    3.  * throw用在方法内部抛出异常对象（表示的是真的异常）
    4.  *      throws：
    5.  *          1、用在方法声明后面跟的是异常类名
    6.  *          2、可以跟多个异常类型，用逗号隔开
    7.  *          3、表示抛出异常，由该方法的调用者处理
    8.  *          4、throws表示出现异常的可能性，并不一定会发生这些异常
    9.  *
    10.  *     throw：
    11.  *          1、用在方法体没，跟的是异常对象名
    12.  *          2、一次只能抛出一个异常对象名
    13.  *          3、表示抛出异常，有方法体内的语句处理
    14.  *          4、throw则是抛出了异常，指定throw则是一定抛出了某种异常
    15.  *

    处理原则：
    如果该功能颞骨可以将问题处理，同try，如果处理不了。交由调用者处理使用throws
    区别：
    后续程序还需要执行就是用try
    后续程序不需要执行就使用throws

    举例：
    感冒吃点药就好：try
    感冒吃药不见好：throws
    如果医院解决不了：Error（严重问题）

    异常的注意事项：
    1、子类重写父类方法时，子类方法必须抛出相同的异常或者父类异常的子类
    2、如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是它的子集，子类不能抛出父类没有的异常
    3、如果被重写的方法没有抛出异常，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能使用try ，不能使用throws

    1. package cn.Exception.Finally;
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    7. /**
    8.  *  finally（异常处理的异常格式）
    9.  *      格式try……catch……finally
    10.  *
    11.  *      特点：被finally控制的语句一定会执行
    12.  *
    13.  *      注意：如果 执行到finally之前jvm退出了，就不能在执行了
    14.  *
    15.  *      作用：用于释放资源，
    16.  *
    17.  *          面试题：
    18.  *              1、final、finally、finalize
    19.  *                  1、final:最终的意思，可以修饰类，成员变量，成员方法
    20.  *                      修饰类：类不能被继承
    21.  *                      修饰变量：变量是常量
    22.  *                      修饰方法：方法不能别重写
    23.  *
    24.  *                  2、finally:异常处理，用于释放资源
    25.  *                      一般来说，代码肯定会执行，特殊情况下：在执行finally之前jvm就退出了，就不在实行了
    26.  *
    27.  *                  3、finalize：是Object类的一个方法，垃圾回收器
    28.  *
    29.  *
    30.  *                  2、如果catch里面有return，那么finally里面的代码还会执行吗
    31.  *                      如果会，是在return前执行还是return后执行
    32.  *                          会，return前执行
    33.  *
    34.  *            try ……catch ……finally的格式变形
    35.  *                  1、try……catch……finally
    36.  *                  2、try……catch
    37.  *                  3、try……catch……catch
    38.  *                  4、try……catch……catch ……finally
    39.  *                  5、try……finally这种做法是为了释放资源
    40.  *
    41.  *
    42.  *
    43.  * */
    44. public class ExceptionFinallyDemo {
    45.     public static void main(String[] args) {
    47. //        String s = "2014-11-10";
    48. //        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    49. //
    50. //        Date d = null;
    51. //        try {
    52. //            d = sdf.parse(s);
    53. //        } catch (ParseException e) {
    54. //            e.printStackTrace();
    55. //        }finally{
    56. //            System.out.println("这里的代码是可以执行的");
    57. //        }
    58. //        System.out.println(d);
    61.         System.out.println(getInt());
    65.     }
    67.     public static int getInt(){
    68.         int a  = 10;
    69.         try{
    70.             System.out.println(a/0);
    71.             a=20;
    72.         }catch(ArithmeticException e){
    73.             a = 30;
    74.             return a;       //返回路径
    75.           /**
    76.            * return a 在执行到这一步的时候，这里不是return a ，二是return 30；这个返回路径就形成了
    77.            * 但是在后面有finally，所以就继执行finally的内容，a=40
    78.            * 再次回到以前的返回路径，此时继续走return 30
    79.            * */
    81.         }finally{
    82.             a = 40;
    83.             return a;       //  此时，a = 40；
    84.         }
    85.         //return a;  //面试是在这里return
    86.     }
    87. }

    File：

    1. package cn.File;
    3. import java.io.File;
    5. /**
    6.  * 我们要想实现IO的操作，就必须知道硬盘上文件的表现形式
    7.  * 而java就提供了一个类File供我们使用
    8.  *
    9.  * File：文件和目录（文件夹）路径名的抽象表现形式
    10.  *
    11.  *      构造方法：
    12.  *          1、File(String pathname) : 根据一个路径得到一个File对象
    13.  *          2、File(String parent ,String child) :根据一个目录和一个子文件/目录得到一个File对象
    14.  *          
    15.  *
    16.  * */
    17. public class FileDemo {
    18.     public static void main(String[] args) {
    19.         //1、File(String pathname) : 根据一个路径得到一个File对象
    20.             //把e:\\demo\\a.tex封装成一个File对象
    21.         File file = new File("e:\\demo\\a.txt");
    23.         //2、File(String parent ,String child) :根据一个目录和一个子文件/目录得到一个File对象
    24.         File file2 = new File("E:\\demo\\a.txt");
    26.         //3、File(File parent ,String child) : 根据一个父File对象和一个子文件/目录得到一个File对象
    27. //        File file3 = new File("e:\\demo);
    28. //                File file4 = new File(file3,"a.txt");
    30.         //以上三种表现形式效果都是一样的
    32.     }
    33. }
    1. package cn.File;
    3. import java.io.File;
    4. import java.io.IOException;
    6. /**
    7.  * File 的创建功能
    8.  *      1、public boolean createNewFile()    //创建文件
    9.  *      2、public boolean mkdir()    //创建文件夹  如果存在就会返回false ，不创建
    10.  *      3、public boolean mkdirs()   //创建多级文件夹如果父类文件夹不存在，会自动创建
    11.  *
    12.  *      a.txt 不一定是文本文件，可以是文件名，所以需要判断一下是文件，还是文件夹
    13.  *
    14.  * File 的删除功能：
    15.  *      1、public boolean delete()
    16.  *      注意：
    17.  *          1、在删除之前必须要有文件夹
    18.  *          2、java删除不走回收站
    19.  *
    20.  * */
    21. public class FileDemo_02 {
    22.     public static void main(String[] args) throws IOException {
    23.         //需求： 在E盘创建一个文件夹demo
    24.         File file1 = new File("e:\\demo");
    25.         System.out.println("mkdir : " + file1.mkdir());
    27.         //需求：在e盘demo文件下创建一个a.txt
    28.         File file2 = new File("e:\\demo\\a.txt");
    29.         System.out.println("creatNewFile : " +file2.createNewFile());
    31.         //需求：在e盘目demo1录创建一个文件b.txt
    32. //        File file3 = new File("e:\\demo1\\a.txt");
    33. //        System.out.println("creatNewFile : "+ file3.createNewFile());
    34.         //这样做会报错，因为在当前路径下，demo1文件夹还不存在，所以，需要先创建文件夹在穿件文件
    36.         //需求：在e盘目录test下创建目录aaa（创建文件夹，在到文件夹里面创建文件夹）
    37.         File file4 = new File("e:\\test\\aaa");
    38.         System.out.println("mkdir : " + file4.mkdir());     //false,因为test文件夹还没有创建，所以创建不了aaa，但是没有报错
    39.         File file5 = new File("e:\\test");
    40.         File file6 = new File("e:\\test\\aaa");
    41.         System.out.println("mkdir :" +file5.mkdir());
    42.         System.out.println("mkdir :" + file6.mkdir());        //不适合多目录使用
    44.         //3、public boolean mkdirs()   //创建多级文件夹如果父类文件夹不存在，会自动创建
    45.         File file7  =new File("e:\\aaa\\bbb\\ccc\\ddd\\eee\\fff\\zzz\\ddd\\eee\\ggg\\jjj");
    46.         System.out.println("mkdir : " + file7.mkdirs());
    48.         System.out.println("------");
    49.         //创建目录dd并创建目录a.txt
    50.         File file8 = new File("e:\\dd\\a.txt");
    51.         System.out.println("mkdir : " + file8.mkdirs());        //a.txt 不一定是文本文件，还可以是文件名
    55.         //删除功能：
    57.         //创建文件：
    58. //        File file  =  new File("a.txt"); //这里没有写盘符，但是可以创建成功，目录位置在当前项目路径
    59. //        System.out.println("createNewFile :" + file.createNewFile());       //创建文件
    61.         File file  =  new File("e:\\a.txt");
    62.         System.out.println("createNewFile :" + file.createNewFile());       //创建文件
    64.         //1、public boolean delete()
    65. //        File file11 = new File("e:\\test\\aaa");
    66. //        System.out.println("delete : " + file.delete());
    69.         System.out.println("delete : " + file7.delete());
    72.     }
    73. }
    1. package cn.File;
    3. import java.io.File;
    5. /**
    6.  *
    7.  *  File 的创建功能
    8.  *  *      1、public boolean createNewFile()    //创建文件
    9.  *  *      2、public boolean mkdir()    //创建文件夹  如果存在就会返回false ，不创建
    10.  *  *      3、public boolean mkdirs()   //创建多级文件夹如果父类文件夹不存在，会自动创建
    11.  *  *
    12.  *  *      a.txt 不一定是文本文件，可以是文件名，所以需要判断一下是文件，还是文件夹
    13.  *  *
    14.  *  * File 的删除功能：
    15.  *  *      1、public boolean delete()
    16.  *  *      注意：
    17.  *  *          1、在删除之前必须要有文件夹
    18.  *  *          2、java删除不走回收站
    19.  *  * File 的重命名
    20.  *      public boolean renameTo(file dest)      //重命名
    21.  *          注意：
    22.  *              1、如果路径名相同，就是改名
    23.  *              2、如果路径名不同，就是改名并剪切
    24.  *
    25.  *      路径以盘符开始：绝对路径：   c:\\a\txt
    26.  *      路径不以盘符开始：相对路径：  a.txt
    27.  *
    28.  * */
    29. public class FileDemo_03 {
    30.     public static void main(String[] args) {
    31.         //创建文件：
    32.         File file = new File("证件照.jpg");
    34.         //需求：改成邓同湖证件照.jpg
    35. //        File newFile = new File("邓同湖证件照.jpg");
    36. //        System.out.println("renameTo : " + file.renameTo(newFile));
    38.         File file2 = new File("邓同湖证件照.jpg");
    39.         File  newFile2 = new File("e:\\dengtonghu");
    40.         System.out.println("rename : " + file2.renameTo(newFile2));         //这一步相当于改名和剪切
    42.     }
    43. }

    file的判断功能

    1. package cn.File;
    3. import java.io.File;
    4. import java.io.IOException;
    6. /**
    7.  * File的判断功能：
    8.  *      1、public boolean idDirectory()  判断是否是目录
    9.  *      2、public boolean isFile();      判断是否是文件
    10.  *      3、public boolean exists();      判断文件是否存在
    11.  *      4、public boolean canRead()      判断是否可读
    12.  *      5、public boolean canWrite();    判断是否可写
    13.  *      6、public boolean isHidden();    判断是否隐藏
    14.  *
    15.  *
    16.  * */
    17. public class FileDemo_04 {
    18.     public static void main(String[] args) throws IOException {
    19.         //创建文件
    20.         File file = new File("a.txt");
    21.         System.out.println("createNewFile : " +file.createNewFile());
    23.         System.out.println("idDirectory : " +file.isDirectory());
    24.         System.out.println("isFile : " +file.isFile());
    25.         System.out.println("exists : " +file.exists());
    26.         System.out.println("canRead : " +file.canRead());
    27.         System.out.println("canWrite : " +file.canWrite());
    28.         System.out.println("isHidden : " +file.isHidden());
    32.     }
    33. }

    获取毫秒值转为格式化时间

    1.         Date d = new Date(1595841521032l);
    2.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd : HH:mm:ss");
    3.         String s=  sdf.format(d);
    4.         System.out.println(s);
    1. package cn.File;
    3. import java.io.File;
    4. import java.text.SimpleDateFormat;
    5. import java.util.Date;
    7. /**
    8.  * File 的获取功能：
    9.  *      public String getAbsolutePath()    获取绝对路径
    10.  *      public String getPath()             获取相对路径
    11.  *      public String getName()                获取名字
    12.  *      public long length();                获取长度，字节数
    13.  *      public long lastModified()          获取最后一次修改时间，返回毫秒值
    14.  *
    15.  *
    16.  * */
    17. public class FileDemo_05 {
    18.     public static void main(String[] args) {
    19.         //创建文件方法：
    20.         File file = new File("test.txt");
    21.         System.out.println("getAbsolutePath : " + file.getAbsolutePath());
    22.         System.out.println("getPath: " + file.getPath());
    23.         System.out.println("getName : " + file.getName());
    24.         System.out.println("length : " + file.length());
    25.         System.out.println("lastModified : " + file.lastModified());
    27.         //1595840481722毫秒值
    28.         Date d = new Date(1595841521032l);
    29.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd : HH:mm:ss");
    30.         String s=  sdf.format(d);
    31.         System.out.println(s);
    33.     }
    34. }

    File的高级获取：（获取所有的文件夹）

    1. package cn.File_01;
    3. import java.io.File;
    5. /**
    6.  * File的高级获取
    7.  *  public String [] list()     获取指定目录下的所有文件或者文件夹的名称数组
    8.  *  public File[] listFiles()     获取指定目录下的所有文件或者文件下的file数组
    9.  *
    10.  *
    11.  * */
    12. public class FileDemo_06 {
    13.     public static void main(String[] args) {
    14.         //定义一个路径
    15.         File file = new File("e:\\");
    17.         //public String [] list()  获取制定目录下的所有文件或者文件夹名称的数组
    18.         String[] strArray = file.list();
    19.         for (String s : strArray) {
    20.             System.out.println(s);
    21.         }
    22.         System.out.println("--------------");
    25.         //public File[] listFiles()     获取指定目录下的所有文件或者文件下的file数组
    26.         File[] fileArray = file.listFiles();        
    27.         for (File f : fileArray) {
    28.             System.out.println(f);
    29.         }
    31.     }
    34. }
    1. package cn.FileTest;
    3. import java.io.File;
    5. /**
    6.  * 判断e盘目录下是否有后缀名为.jpg 的文件，如果有，就输出文件的名称
    7.  *      分析：
    8.  *          1、封装e判断目录
    9.  *          2、获取该目录下面所有文件或者文件夹的File数组
    10.  *          3、遍历该file数组，单后判断
    11.  *          4、是否是文件
    12.  *                  是：继续判断是否以.jpg结尾
    13.  *                          是：输出文件名称
    14.  *                          否：不搭理
    15.  *                  否：不搭理
    17.  * */
    18. public class FileDemo {
    19.     public static void main(String[] args) {
    20.         //封装e盘目录
    21.         File file= new File("e:\\");
    23.         //获取该目录下面所有的文件或者文件夹数组//public File[] listFiles()     获取指定目录下的所有文件或者文件下的file数组
    24.         File [] fileArray = file.listFiles();
    26.         //遍历file数组，得到每一个File对象，然后判断
    27.         for (File f : fileArray){
    28.             //判断是否是文件
    29.             if(f.isFile()){
    30.                 //判断是不是以.jpg结尾
    31.                 if(f.getName().endsWith(".jpg")){
    32.                     //输出给文件的名称
    33.                     System.out.println(f.getName());
    34.                 }
    35.             }
    36.         }
    37.     }
    38. }

    Screenshot_2020-07-27-22-47-51.pngScreenshot_2020-07-27-22-53-50.pngScreenshot_2020-07-27-23-00-18.png
    递归：

    1. package cn.DiGui;
    3. import java.util.Scanner;
    5. /**
    6.  * 递归：方法定义中调用方法本身的现象
    7.  *  public void show(int n){
    8.  *      System.out.println(n)
    9.  *      show()
    10.  *  }
    11.  *
    12.  *  注意事项：
    13.  *      1、递归一定要有出口，否则就是死递归
    14.  *      2、递归的次数不能太多，否则会造成内存溢出
    15.  *      3、构造方法不能递归使用
    16.  *
    17.  *
    18.  * 需求：
    19.  *      计算5的阶乘
    20.  *          n！表示阶乘
    21.  *              5！= 1*2*3*4*5
    22.  *          循环实现
    23.  *          递归实现
    24.  *
    25.  *     递归解决问题的思想
    26.  *          1、分解法：
    27.  *          2、合并法：
    28.  *          先把大问题分解小问题解决，到后面返回形成一个大问题
    29.  *
    30.  *          递归：方法定义中，调用本身的现象
    31.  *          实现：
    32.  *              1、做递归要写一个方法
    33.  *                  写方法：
    34.  *                      1、返回值类型
    35.  *                      2、参数列表
    36.  *              2、出口条件
    37.  *              3、规律
    38.  *
    39.  * */
    40. public class DiGuiDemo {
    41.     public static void main(String[] args) {
    42. //        int jc = 1;
    43. //        for(int x = 2;x<=5;x++){
    44. //            jc*= x;     //等价于jc = jc*x;
    45. //
    46. //        }
    47. //        System.out.println("5的阶乘是：" + jc);
    50. //        Scanner sc =new Scanner(System.in);
    51. //        System.out.println("请输入 ： ");
    52. //        int num = sc.nextInt();
    53. //        int jc = 1;
    54. //        for(int x = 2;x<=num;x++){
    55. //            jc*= x;     //等价于jc = jc*x;
    56. //
    57. //        }
    58. //        System.out.println("你输入:"+num+"的阶乘是：" + jc);
    59. //        System.out.println("------------");
    61.         System.out.println("5的阶乘是： "+jiecheng(5));
    63.     }
    64.     /**
    65.      * 做递归要写一个方法
    66.      *      返回值类型：int 或者long
    67.      *      参数列表：int n
    68.      *
    69.      *  出口条件：
    70.      *      if(n==1 ) {return 1;}
    71.      *
    72.      *  规律：if(n!= 1) {return n*方法名（n-1）}
    73.      *
    74.      *
    75.      * */
    77.     public static int jiecheng(int n){
    78.         if(n==1){
    79.             return 1;
    80.         }else {
    81.           return n*jiecheng(n-1);
    82.         }
    83.     }
    87. }
    1. package cn.DiGui;
    2. /**
    3.  *  有一对兔子，从出生后第三个月起，每个月生一对小兔子，小兔子长到第三个月的时候，每个月又生一对兔子，加入兔子不死，请问第20个月后有多少对兔子
    4.  *      分析：
    5.  *                      兔子对数
    6.  *      第一个月：           1
    7.  *      第二个月：           1
    8.  *      第三个月：           2   第一个月生的兔子生了一对小兔子
    9.  *      第四个月：           3   第一个月生的兔子生一对，第二个月的兔子生一对，老兔子生一对
    10.  *      第五个月：           5   第一个月的生一对，第二个月的生一对，第三个的生一对，第一个月生的小兔子兔子再生一对，第二个月生的小兔子再生一对
    11.  *      第六个月：           8
    12.  *          ……
    13.  *
    14.  *      兔子的对数是：1、1、2、3、5、8
    15.  *                  1+1=2
    16.  *                  2+3=5
    17.  *                  3+5=8
    18.  *                  ……
    19.  *                  1、从第三项开始，每一项是前两项之和
    20.  *                  2、前两项是已知的
    21.  *
    22.  *         实现：
    23.  *              1、数组实现
    24.  *              2、变量的变化实现
    25.  *
    26.  *       假如相邻的两个月的兔子变量是a,b
    27.  *    第一个相邻的数据：a = 1,b = 1;
    28.  *    第二个相邻的数据：a = 1,b = 2
    29.  *    第三个相邻的数据：a = 2,b = 3
    30.  *    第四个相邻的数据：a = 3,b = 5
    31.  *    下一次的a是上一次的b， b是上一次的a+b
    32.  *
    33.  * */
    34. public class DiGuiDemo_02 {
    35.     public static void main(String[] args) {
    36.         //定义一个数组
    37.         int [] arr = new int[20];
    38.         arr[0] = 1;
    39.         arr[1] = 1;
    40. //        arr[2] = arr[0]+arr[1];
    41. //        arr[3] = arr[1]+ arr[2];
    42. //        ……
    43.         for(int x = 2; x<arr.length;x++){
    44.             arr[x] = arr[x-2] + arr[x-1];
    45.         }
    46.         System.out.println(arr[19]);        //6765
    47.         System.out.println("--------------------");
    49.         int a = 1;
    50.         int b = 1;
    51.         for(int x = 0 ;x<18;x++){       //第一个月和第二个月已经拿出，所以是18
    52.             //临时变量存储a的值
    53.             int temp = a;
    54.             a= b;
    55.             b = temp+b;
    56.         }
    57.         System.out.println(b);
    59.         //递归实现
    60.         /*
    61.         * 方法：
    62.         *   1、返回值类型：int
    63.         *   2、参数列表：int n
    64.         *
    65.         *   出口条件：
    66.         *       第一个月是1，第二个月是1
    67.         *   规律：
    68.         *       从第三个月开始，每个月是前两个月之和
    69.         *
    70.         *
    71.         *
    72.         * */
    74.         System.out.println(fib(20));
    77.     }
    78.     public static int fib(int n){
    79.         if(n==1|| n==2){
    80.             return 1;
    81.         }else{
    82.              return fib(n-1)+fib(n-2);       //前一个月是n-1,前两个月是n-2
    83.         }
    84.     }
    85. }
    1. package cn.DiGui;
    3. import java.io.File;
    5. /**
    6.  * 需求：  把D:\javaProject中目录下所有的以.java结尾的文件的绝对路径输出在控制台
    7.  *      分析：
    8.  *          1、封装对象
    9.  *          2、获取该目录下所有的文件或者文件夹的File[]
    10.  *          3、遍历File数组，得到每一个File对象
    11.  *          4、判断该File对象是否是文件夹
    12.  *              是：回到2               //因为要回到2，所以使用递归方法
    13.  *              否：判断是否以.java结尾
    14.  *                  是：数据该文件的绝对路径
    15.  *                  否：不搭理
    16.  *
    17.  *
    18.  * */
    19. public class FilePathDemo {
    20.     public static void main(String[] args) {
    21.         //封装对象
    22.         File srcFolder = new File("d:\\javaProject");
    24.         //递归功能实现
    25.         getAllJavaFilePaths(srcFolder);
    26.     }
    28.     private static void getAllJavaFilePaths(File srcFolder) {
    29.         //2、获取该目录下所有的文件或者文件夹的File[]
    30.         File[] fileArray = srcFolder.listFiles();
    32.         //3、遍历File数组，得到每一个File对象
    33.         for(File file:fileArray){
    34.             //4、判断该File对象是否是文件夹
    35.             if(file.isDirectory()){         //判断是否是文件
    36.                 getAllJavaFilePaths(file);
    38.             }else{
    39.                 if(file.getName().endsWith(".java")){   //判断是否以.java结尾
    40.                     System.out.println(file.getAbsoluteFile());       //是，则输出绝对路径
    41.                 }
    42.             }
    43.         }
    45.     }
    46. }

    Screenshot_2020-07-28-16-33-16.png

    1. package cn.IO.cn;
    3. import java.io.File;
    4. import java.io.FileNotFoundException;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    8. /**
    9.  * IO:
    10.  *      概述：IO流用来处理设备之前的数据传输
    11.  *              上传文件和下载文件
    12.  *     java对数据的操作都是通过流的方式
    13.  *     java用于操作流的对象都在IO包下
    14.  *
    15.  *      按照数据流向分：
    16.  *          输入流 读数据
    17.  *          输出流 写数据
    18.  *
    19.  *      按照数据类型分：
    20.  *          字节流         不能读懂
    21.  *
    22.  *                   字节输入流：读取数据     InputStream
    23.  *                   字节输出流：写出数据     OutputStream
    24.  *
    25.  *          字符流         可以读懂
    26.  *
    27.  *                  字符输入流：读取数据      Reader
    28.  *                  字符输出流：写出数据      Writer
    29.  *
    30.  *              注意：如果没有明确说明按哪种分分类，是按照数据类型分类的
    31.  *
    32.  *          使用场景：
    33.  *              如果数据所在的文件通过windows自带的记事本打开并且能够读懂里面的内容就是用字符流，其他使用字节流
    34.  *              如果不清楚，就使用字符流
    35.  *
    36.  *              查看FileOutputStream 的构造方法：
    37.  *                  FileOutputStream(File file)
    38.  *                  FileOutputStream(String name)
    39.  *
    40.  *                  字节输出流操作步骤：
    41.  *                      1.创建字节输出流对象
    42.  *                      2、写数据
    43.  *                      3、释放资源
    44.  *
    45.  *
    46.  *
    47.  * */
    48. public class IODemo {
    49.     public static void main(String[] args) throws IOException {
    50.         //创建字节输出流对象
    51. //        //FileOutputStream(File file)
    52. //        File file = new File("fos.txt");
    53. //        FileOutputStream fos = new FileOutputStream(file);
    55.         //FileOutputStream(String name)
    56.         FileOutputStream fos  = new FileOutputStream("fos.txt");
    57.         /**
    58.          * 创建字节流输出对象做了三件事情
    59.          *      1、调用系统功能区创建文件
    60.          *      2、创建fos对象
    61.          *      3、把fos对象指向这个文件
    62.          *
    63.          * */
    65.         //写数据“hello,io”
    66.         fos.write("hello,io".getBytes());
    68.         //释放资源
    69.         fos.close();
    70.         /**
    71.          * 为什么要close
    72.          *      1、让流对象变成垃圾，这样就可以被垃圾回收器回收
    73.          *      2、通知体统去释放跟该文件相关的资源，如果不释放，那么该文件就一直无法关闭，占用系统资源
    74.          * */
    75.     }
    76. }
    1. package cn.IO.cn;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    7. /**
    8.  * 字节流输出得操作步骤
    9.  *      1、创建字节输出流对象
    10.  *      2、调用writer() 方法
    11.  *      3、释放资源
    12.  *
    13.  *      public void write (int b)       写一个字节
    14.  *      public void write(byte[] b)      写一个字节数组
    15.  *      public void write(byte [] b, int off ,int len)      写一个字节数组的一部分
    16.  *
    17.  *
    18.  * */
    19. public class IODemo_02 {
    20.     public static void main(String[] args) throws IOException {
    21.         //创建字节输出流对象
    22.         FileOutputStream fos = new FileOutputStream("fos2.txt");
    24.         //调用writer（）方法：
    25. //        fos.write(97);      //输出：a: 因为底层是二进制数据结构，通过对应的记事本打开，找97对应的字符值a
    26. //        fos.write(57);      //9
    27. //        fos.write(55);      //7
    29.         //public void write(byte[] b)      写一个字节数组
    30.         byte[] bytes  = {97,98,99,100,101};
    31.         fos.write(bytes);
    34.         // public void write(byte [] b, int off ,int len)      写一个字节数组的一部分
    35.         fos.write(bytes,1,3);       //bcd
    37.         fos.close();
    38.     }
    39. }

    标准的异常处理代码

    1. package cn.IO_01;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    7. /**
    8.  * 加入异常处理的字节流输出操作
    9.  *
    10.  * */
    11. public class FileOutputStream_02 {
    12.     public static void main(String[] args) {
    13.         //创建字节输出流
    14. //        FileOutputStream fos = null;
    15. //        try {
    16. //            fos = new FileOutputStream("fos4.txt");
    17. //        } catch (FileNotFoundException e) {
    18. //            e.printStackTrace();
    19. //        }
    20. //        //写数据
    21. //        try {
    22. //            fos.write("java".getBytes());
    23. //        } catch (IOException e) {
    24. //            e.printStackTrace();
    25. //        }
    26. //        //释放资源
    27. //        try {
    28. //            fos.close();
    29. //        } catch (IOException e) {
    30. //            e.printStackTrace();
    31. //        }
    34.         //一起处理异常
    35. //        try{
    36. //            FileOutputStream fos = new FileOutputStream("fos.txt");
    37. //            fos.write("java".getBytes());
    38. //            fos.close();
    39. //
    40. //        }catch(FileNotFoundException e){
    41. //            e.printStackTrace();
    42. //        }catch(IOException e){
    43. //            e.printStackTrace();
    44. //        }
    46.         //改进版：
    47.         FileOutputStream fos = null;
    48.         try {
    49.             //fos = new FileOutputStream("z:\\fos4.txt");     //不存在盘符
    50.             fos = new FileOutputStream("fos4.txt");
    51.             fos.write("java".getBytes());
    54.         } catch (FileNotFoundException e) {
    55.             e.printStackTrace();
    56.         } catch (IOException e) {
    57.             e.printStackTrace();
    58.         } finally {
    59.             //为了保证close()一定会被执行，就放在这里
    60.             //如果fos不是null，才需要close
    61.             if (fos != null) {      //如果对象没有造成功，就不会close从而触发空指针异常
    62.                 try {
    63.                     fos.close();        //close本身就有异常，所以要抛出
    64.                 } catch (IOException e) {
    65.                     e.printStackTrace();
    66.                 }
    68.             }
    69.         }
    72.     }
    73. }
    1. package cn.IO_InputStream;
    3. import java.io.FileInputStream;
    4. import java.io.FileNotFoundException;
    5. import java.io.IOException;
    7. /**
    8.  * 字节输入流的操作步骤（读）
    9.  *  1、创建字节输入流对象
    10.  *  2、调用read()方法读取数据，并把数据显示在控制台
    11.  *  3、释放资源
    12.  *
    13.  *        读取数据的方式：
    14.  *          1、int read()  一次读取一个字节数数组
    15.  *          2、int read(byte [] b) 一次读取一个字节数组
    16.  *
    17.  * */
    18. public class FileInputStreamDemo_01 {
    19.     public static void main(String[] args) throws IOException {
    20.         //创建字节流输入流对象
    21.         //FileInputStream fis = new FileInputStream("fis.txt");
    22.         FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
    23.         //这里读取的是代码，但是注释会乱码，因为当前是char类型
    26.         //2、调用read()方法读取数据，并把数据显示在控制台
    27. //        int by = fis.read();
    28. //        System.out.println("by = " + by);
    29. //        System.out.println("(char)by = " + (char)by);
    30. //
    31. //        by = fis.read();
    32. //        System.out.println("by = " + by);
    33. //        System.out.println("(char)by = " + (char)by);
    34. //
    35. //        by= fis.read();
    36. //        System.out.println("by = " + by);
    37. //        System.out.println("(char)by = " + (char)by);
    38. //
    39. //        by = fis.read();
    40. //        System.out.println("by = " + by);  //-1说明文件已经到达末尾了
    42.         //用循环改进
    43. //        int by = fis.read();        //  先读取一次
    44. //        while(by!= -1){
    45. //            System.out.print((char)by);
    46. //            by = fis.read();
    47. //        }
    49.         //最终版：
    50.         int by = 0;
    51.         while((by = fis.read())!=-1){       //读取、赋值、判断
    52.             System.out.print((char) by);
    54.         }
    56.         //3、释放资源
    57.         fis.close();
    58.     }
    59. }
    1. package cn.IO_InputStream;
    3. import java.io.FileInputStream;
    4. import java.io.FileNotFoundException;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    8. /**
    9.  * 复制文本文件
    10.  *      数据源：从哪里来
    11.  *          a.txt       --- 读数据 --- FileInputStream
    12.  *      目的地：到哪里去
    13.  *          b.txt       --- 写数据 --- FileOutputStream
    14.  *
    15.  *
    16.  *          java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)说明数据源不存在
    17.  *          
    18.  *       上一次我们出现问题的原因是每次获取到一个字节是数据，就把该字节数据转换为了字符数据，然后输出在控制台   
    19.  *      这里复制中文没有出现问题而这一次是通过IO流读取数据，写到文本文件，读一个字节，就写入一个字节，‘没有做任何的转换，会自己做转换
    20.  *      
    21.  *
    22.  *
    23.  * */
    24. public class CopyFileDemo {
    25.     public static void main(String[] args) throws IOException {
    26.         //封装数据源(读)
    27.         FileInputStream fis = new FileInputStream("a.txt");
    28.         //封住目的地(写)
    29.         FileOutputStream fos = new FileOutputStream("b.txt");
    31.         int by = 0;
    32.         while((by=fis.read())!=-1){
    33.             fos.write(by);
    34.         }
    35.         //释放资源
    36.         fos.close();
    37.         fis.close();
    39.     }
    40. }

    计算机是如何识别什么时候该把两个字节转换为一个中文呢
    在计算机中，中文的存储分为两个字节，：
    第一个字节肯定是负数
    第二个字节是负数，也可能是正数，但是没有印象
    如：我—— -50
    爱—— -46

    复制数据：
    int by= 0;
    while(by = fis.read() != -1){
    fos.write(by);
    }

    1. package cn.IO_InputStream;
    3. import java.io.FileInputStream;
    4. import java.io.FileNotFoundException;
    5. import java.io.IOException;
    7. /**
    8.  * 字节输入流的操作步骤（读）
    9.  *  1、创建字节输入流对象
    10.  *  2、调用read()方法读取数据，并把数据显示在控制台
    11.  *  3、释放资源
    12.  *
    13.  *        读取数据的方式：
    14.  *          1、int read()  一次读取一个字节数数组
    15.  *          2、int read(byte [] b) 一次读取一个字节数组
    16.  *
    17.  * */
    18. public class FileInputStreamDemo_01 {
    19.     public static void main(String[] args) throws IOException {
    20.         //创建字节流输入流对象
    21.         //FileInputStream fis = new FileInputStream("fis.txt");
    22.         FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
    23.         //这里读取的是代码，但是注释会乱码，因为当前是char类型
    26.         //2、调用read()方法读取数据，并把数据显示在控制台
    27. //        int by = fis.read();
    28. //        System.out.println("by = " + by);
    29. //        System.out.println("(char)by = " + (char)by);
    30. //
    31. //        by = fis.read();
    32. //        System.out.println("by = " + by);
    33. //        System.out.println("(char)by = " + (char)by);
    34. //
    35. //        by= fis.read();
    36. //        System.out.println("by = " + by);
    37. //        System.out.println("(char)by = " + (char)by);
    38. //
    39. //        by = fis.read();
    40. //        System.out.println("by = " + by);  //-1说明文件已经到达末尾了
    42.         //用循环改进
    43. //        int by = fis.read();        //  先读取一次
    44. //        while(by!= -1){
    45. //            System.out.print((char)by);
    46. //            by = fis.read();
    47. //        }
    49.         //最终版：
    50.         int by = 0;
    51.         while((by = fis.read())!=-1){       //读取、赋值、判断
    52.             System.out.print((char) by);
    54.         }
    56.         //3、释放资源
    57.         fis.close();
    58.     }
    59. }
    1. package cn.IO_InputStream;
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    7. /**
    8.  * 需求需求：把e:\\010_注释.mp4复制到当前目录下
    9.  *        数据源
    10.  *            e:\\010_z注释.mp4   --- 读数据 ---FileInputStream
    11.  *        目的地：
    12.  *            copy.mp4    ---写数据--- FileOutputStream
    13.  *
    14.  *
    15.  * */
    16. public class CopyMp4Demo_02 {
    17.     public static void main(String[] args) throws IOException {
    18.         //封装数据源
    19.         FileInputStream fis = new FileInputStream("e:\\010_注释.mp4");
    21.         //封装目的地
    22.         FileOutputStream fos = new FileOutputStream("010_注释.mp4");
    24.         //复制数据
    25.         int by = 0;
    26.         while((by = fis.read())!=-1){
    27.             fos.write(by);
    28.         }
    30.         byte[] bys = new byte[1024];        // java缓冲区效果
    31.         int len = 0;
    32.         while((len = fis.read(bys))!=-1){
    33.             fos.write(bys,0,len);
    34.         }
    37.         //释放资源
    38.         fos.close();
    39.         fis.close();
    41.     }
    42. }

    IO流的分类：

    1. /**
    2.  * IO流分类：
    3.  *      字节流：
    4.  *          InputStream:（输入流（读））
    5.  *              FileInputStream     
    6.  *              BufferedInputStream
    7.  *          OutputStream（输出流（写））
    8.  *              FileOutputStream
    9.  *              BufferedOutputStream
    10.  *       
    11.  *       字符流：
    12.  *          reader:（字符输入流（读））
    13.  *              FileReader
    14.  *              BufferedReader
    15.  *          writer:（字符输出流（写））
    16.  *              FileWriter
    17.  *              BufferedWrite
    19.  * 
    20.  * */
    • 为什么要close
      * 1、让流对象变成垃圾，这样就可以被垃圾回收器回收
    • 2、通知系统去释放跟该文件相关的资源，如果不释放，那么该文件就一直无法关闭，占用系统资源

    编码表：由现实世界的字符和对应的数值组成的一张表
    ASCII码表：最高位位符号位，其余为数值位
    ‘a’ 97
    ‘A’ 65
    ‘0’ 48

    ISO-8859-1: 拉码表 8位表示一个数据

    GB2312: 中国的中文编码表
    GBK： 中国的中文编码表升级，融合了更多的中文文字符号
    GB19030 :GBK的取代版本
    BIG-5码： 通用于台湾、香港地区的一个繁体字编码方案，俗称“大五码”
    Unicode 国际编码表，融合了各种文字；
    所有文字都是用两个字节表示，java语言使用的就是Unicode

    UTF-8 最多三个字节表示一个字符
    能用一个字符用一个字符表示，（ASCII兼容）
    一个表示不了就使用两个，实在不行就使用三个

    1. package cn.IO;
    3. import java.io.UnsupportedEncodingException;
    4. import java.util.Arrays;
    6. /**
    7.  * String(byte[] bytes, String charsetName) 通过指定的字符集解码字节数组
    8.  * byte [] getBytes(String charsetName)     使用指定的字符集和把字符串编码为字节数组
    9.  *
    10.  * 编码：String --- byte[]
    11.  *      把看的懂得变成看不懂的
    12.  * 解码：byte[] --- String
    13.  *      把看不懂的变成看得懂的
    14.  *
    15.  * */
    16. public class StringDemo {
    17.     public static void main(String[] args) throws UnsupportedEncodingException {
    18.         String s = "你好";
    20.         //String --- byte[]
    21.         byte[] bys = s.getBytes();
    22.         System.out.println(Arrays.toString(bys));       //[-28, -67, -96, -27, -91, -67]
    24.         byte[] bys2 = s.getBytes("GBK ");
    25.         System.out.println(Arrays.toString(bys2));      //[-60, -29, -70, -61]
    27.         //byte[] --- String
    28.         String ss = new String(bys);
    29.         System.out.println(ss);
    31.         String sss  = new String(bys2);
    32.         System.out.println("sss = " + sss);
    35.     }
    36. }
    1. package cn.IO;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.OutputStreamWriter;
    8. /**
    9.  * OutputStreamWriter(OutputStream out) 根据默认编码把字节流数据转换为字符流
    10.  * OutputStreamWriter(OutputStream out ,String charsetName) 根据指定编码转把字节流数据转换为字符流
    11.  * 把字节流转换为字符流
    12.  * 字符流= 字节流+编码表
    13.  *
    14.  * */
    15. public class OutputStreamWriterDemo {
    16.     public static void main(String[] args) throws IOException {
    17.         //创建对象
    18.         //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));         //默认编码
    19.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"Unicode");    //制定编码
    22.         //写数据
    23.         osw.write("中国");
    24.         //释放资源
    25.         osw.close();
    26.     }
    27. }
    1. package cn.IO;
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStreamWriter;
    7. /**
    8.  * OutputStreamWriter的方法：
    9.  *  public void write(int c)     写一个字符
    10.  *  public void write(char[] cbuf)      写一个字符数组
    11.  *  public void write(char[] cbuf , int off ,int len)   写一个字符数组的一部分
    12.  *  public void write(String str)       写一个字符串
    13.  *  public void write(String str ,int off ,int len )        写一个字符串的一部分
    14.  *
    15.  * 面试题： close() 和flush()的区别：
    16.  *      1、close() 关闭流对象，但是先刷新一次缓冲区，关闭之后，流对象就不能再使用了
    17.  *      2、flush（）仅仅刷新缓冲区，刷新之后，流对象还可以使用
    18.  *
    19.  *
    20.  * */
    21. public class OutputStreamWriterDemo_02 {
    22.     public static void main(String[] args) throws IOException {
    23.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw2"));
    24.         //写数据
    25.         //public void write(int c)     写一个字符
    26. //        osw.write('a');
    27. //        osw.write(97);
    29.         //public void write(char[] cbuf)      写一个字符数组
    30.        // char[] chs = {'a','b','c','d','e'};
    31. //        osw.write(chs);
    33.         //public void write(char[] cbuf , int off ,int len)   写一个字符数组的一部分
    34.         //osw.write(chs,1,4);     //获取两个会报错
    37.         //public void write(String str)       写一个字符串
    38.         //osw.write("我爱林青霞");
    40.         //public void write(String str ,int off ,int len )        写一个字符串的一部分
    41.         osw.write("我爱林青霞",2,3);
    43.         osw.flush();    //刷新缓冲区,因为字符流数据没有直接进文件，而在缓冲区，所有刷新
    44.         osw.write("我爱林青霞",2,3);
    46.         osw.close();
    47.        // osw.write("我爱林青霞",2,3);       //写这里会报错
    49.     }
    50. }
    1. package cn.test;
    3. import java.io.FileReader;
    4. import java.io.FileWriter;
    5. import java.io.IOException;
    7. /**
    8.  * 由于常见的操作都是使用本地默认编码，所以不用指定编码
    9.  * 而转换流的长度有点长，java就提供了其子类使用
    10.  * OutputStreamWriter  = FileOutputStream+ 编码表（GBK）
    11.  * FileWriter = FilOutputStream+编码表（GBK）
    12.  *
    13.  * InputStreamReader = FileInputStream + 编码表（GBK）
    14.  * FileReader = FileInputStream + 编码表（GBK）
    15.  *
    16.  *
    17.  * 需求；把当前项目目录下的a.txt文件内容复制到当前项目目录下的b.txt
    18.  * 数据源：
    19.  *      a.txt       ---读取数据---字节转换流---InputStreamReader   --- FileReader
    20.  * 目的地：
    21.  *      b.txt       ---写入数据---字节转换流---OutputStreamWriter  ---FileWriter
    22.  *
    23.  * */
    24. public class CopyFileDemo_02 {
    25.     public static void main(String[] args) throws IOException {
    26.         //数据源
    27.         FileReader  fr = new FileReader("a.txt");
    28.         //目的地
    29.         FileWriter fw = new FileWriter("b.txt");
    31.         //读数据
    32. //        int ch = 0;
    33. //        while((ch = fr.read())!=-1){
    34. //            fw.write((char) ch);
    35. //        }
    37.         char[] chars = new char[1024];
    38.         int len  = 0;
    39.         while((len = fr.read(chars))!=-1){
    40.             fw.write(chars,0,len);
    41.         }
    44.         //释放资源
    45.         fr.close();
    46.         fw.close();
    47.     }
    48. }
    1. package cn.Bufered;
    3. import java.io.*;
    5. /**
    6.  *  * 需求；把当前项目目录下的a.txt文件内容复制到当前项目目录下的b.txt
    7.  *  * 数据源：
    8.  *  *      a.txt       ---读取数据---字节转换流---InputStreamReader   --- FileReader
    9.  *  * 目的地：
    10.  *  *      b.txt       ---写入数据---字节转换流---OutputStreamWriter  ---FileWriter
    11.  *
    12.  * */
    13. public class CopyDemo_01 {
    14.     public static void main(String[] args) throws IOException {
    15.         //封装数据源
    16.         BufferedReader  br = new BufferedReader(new FileReader("a.txt"));
    17.         //封装目的地
    18.         BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    20.         //读数据
    21. //        int ch = 0;
    22. //        while((ch = br.read())!=-1){
    23. //            bw.write(ch);
    24. //        }
    25.         char[] chars = new char[1024];
    26.         int len = 0;
    27.         while((len = br.read(chars))!= -1){
    28.             bw.write(chars,0,len);
    29.             bw.flush();
    30.         }
    32.         //释放资源
    33.         br.close();
    34.         bw.close();
    36.     }
    37. }
    1. package cn.Bufered;
    3. import java.io.*;
    5. /**
    6.  * 字符流为了搞笑读写，也提供了字符缓冲流
    7.  * BufferedWriter:字符输出流（写）
    8.  *      将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
    9.  *      可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
    10.  *
    11.  * BufferedReader:字符输入流（读）
    12.  *
    13.  *
    14.  * */
    15. public class BufferedWriterDemo_01 {
    16.     public static void main(String[] args) throws IOException {
    17.         //BufferedWriter(Writer out)
    18.         //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt")));
    19.         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
    21.         //写数据
    22. //        bw.write("hello"+"\n");
    23. //        bw.write("java"+"\n");
    24. //        bw.write("world"+"\n");
    27.         bw.close();
    28.     }
    29. }
    1. package cn.Bufered;
    3. import java.io.BufferedReader;
    4. import java.io.FileReader;
    5. import java.io.IOException;
    7. /**
    8.  * BufferedReader：
    9.  *       从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
    10.  *       可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
    11.  * BufferedReader(Reader in)
    12.  *
    13.  * */
    14. public class BufferedReaderDemo_01 {
    15.     public static void main(String[] args) throws IOException {
    16.         //创建字符缓冲输入流对象
    17.         BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
    19.         //
    20. //        int ch = 0;
    21. //        while ((ch = br.read())!=-1){
    22. //            System.out.print((char)ch);
    23. //        }
    25.         char [] chars = new char[1024];
    26.         int len = 0;
    27.          while((len = br.read(chars))!=-1){
    28.              System.out.println(new String(chars,0,len));
    29.          }
    30.         br.close();
    31.     }
    32. }
    1. package cn.Bufered;
    3. import java.io.*;
    5. /**
    6.  * 字符 缓冲流的特殊方法：
    7.  *    BufferedWriter:
    8.  *      public void newLine()   根据 系统来决定换行符
    9.  *    BufferedReader:
    10.  *      public String readLine()    一次读取一行数据
    11.  *      包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
    12.  *
    13.  *
    14.  * */
    15. public class BufferedDemo {
    16.     public static void main(String[] args) throws IOException {
    17.         //创建字符缓冲数据流对象
    18. //        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
    19. //
    20. //        for(int x = 0;x <10;x++){
    21. //            bw.write("hello"+x);
    22. //            //bw.write("\r\n");
    23. //            bw.newLine();
    24. //            bw.flush();
    25. //
    26. //
    27. //        }
    28. //
    29. //
    30. //        //释放资源
    31. //        bw.close();
    33.         //write();
    34.         read();
    36.     }
    38.     private static void read()  throws IOException{
    39.         //创建字符缓冲输入流
    40.         BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
    41. //        String line = br.readLine();
    42. //        System.out.println("line = " + line);       //hello0
    43. //        line = br.readLine();
    44. //        System.out.println("line = " + line);       //hello1
    46.         String line = null;
    47.         while((line = br.readLine())!=null){
    48.             System.out.println(line);
    49.         }
    51.         br.close();
    53.     }
    55.     private static void write() throws IOException {
    56.         BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
    58.         for(int x = 0;x <10;x++){
    59.             bw.write("hello"+x);
    60.             //bw.write("\r\n");
    61.             bw.newLine();
    62.             bw.flush();
    64.         }
    67.         //释放资源
    68.         bw.close();
    69.     }
    72. }
    1. package cn.Bufered;
    3. import java.io.*;
    5. /**
    6.  *  * 需求；把当前项目目录下的a.txt文件内容复制到当前项目目录下的b.txt
    7.  *  * 数据源：
    8.  *  *      a.txt       ---读取数据---字节转换流---InputStreamReader   --- FileReader
    9.  *  * 目的地：
    10.  *  *      b.txt       ---写入数据---字节转换流---OutputStreamWriter  ---FileWriter
    11.  *
    12.  * */
    13. public class CopyDemo_02 {
    14.     public static void main(String[] args) throws IOException {
    15.         //封装数据源
    16.         BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    17.         //封装目的地
    18.         BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    20.         //读写数据
    21.         String line  = null;
    22.         while((line = br.readLine())!=null){
    23.             bw.write(line);
    24.             bw.newLine();            //写换行符
    25.             bw.flush();            
    26.         }
    28.         //释放资源
    29.         br.close();
    30.         bw.close();
    31.     }
    32. }

    Screenshot_2020-07-30-12-48-20.png
    IO(复制文件的5中方式)重点是：第五种

    1. package cn.test;
    3. import java.io.*;
    5. /**
    6.  * 复制文本文件
    7.  *  分析：
    8.  *      1、复制数据用记事本打开兵并且可以读懂，就用字符流，否则用字节流，通过分析，使用字符流更方便
    9.  *      而字符流有5种方式（掌握第5种）
    10.  *      数据源：        a.txt ---FileReader  ---BufferedReader
    11.  *      目的地：    e:\\b.txt---FileWriter ---BufferedWriter
    12.  *
    13.  * */
    14. public class CopyFileDemo_03 {
    15.     public static void main(String[] args) throws  IOException {
    16.         String srcString= "a.txt";
    17.         String destString = "e:''b.txt";
    19. //        method1(srcString,destString);
    20. //        method2(srcString,destString);
    21. //        method3(srcString,destString);
    22. //        method4(srcString,destString);
    23.         method5(srcString,destString);
    24.     }
    26.     //字符缓冲流一次读写一个字符串（掌握）
    27.     private static void method5(String srcString, String destString) throws IOException {
    28.         BufferedReader br = new BufferedReader(new FileReader(srcString));
    29.         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
    31.         String line = null;
    32.         while ((line = br.readLine()) != null) {
    33.             bw.write(line);
    34.             bw.newLine();       //换行
    35.             bw.flush();
    36.         }
    37.         bw.close();
    38.         br.close();
    39.     }
    41.     //高效字符缓冲流（一次一个数组）
    42.     private static void method4(String srcString, String destString) throws IOException {
    43.         BufferedReader br = new BufferedReader(new FileReader(srcString));
    44.         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
    46.         char[] chars = new char[1024];
    47.         int len = 0;
    48.         while ((len = br.read(chars)) != -1) {
    49.             bw.write(chars, 90, len);
    50.         }
    52.         bw.close();
    53.         br.close();
    54.     }
    56.     //高效字符缓冲流(一次一个字符)
    57.     private static void method3(String srcString, String destString) throws IOException {
    58.         BufferedReader br = new BufferedReader(new FileReader(srcString));
    59.         BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
    61.         int ch = 0;
    62.         while ((ch = br.read()) != -1) {
    63.             bw.write(ch);
    64.         }
    66.         br.close();
    67.         bw.close();
    69.     }
    71.     private static void method2(String srcString, String destString) throws IOException {
    72.         FileReader fr = new FileReader(srcString);
    73.         FileWriter fw = new FileWriter(destString);
    76.         //一次读写一个字符数组
    77.         char[] chars = new char[1024];
    78.         int len = 0;
    79.         while ((len = fr.read(chars)) != -1) {
    80.             fw.write(chars, 0, len);
    81.         }
    82.         fr.close();
    83.         fw.close();
    84.     }
    86.     //基本字符流，一次读写一个
    87.     private static void method1(String srcString, String destString) throws IOException {
    88.         FileReader fr = new FileReader(srcString);
    89.         FileWriter fw = new FileWriter(destString);
    91.         int ch = 0;
    92.         while ((ch = fr.read()) != -1) {
    93.             fw.write(ch);
    94.         }
    95.         fr.close();
    96.         fw.close();
    99.     }
    100. }

    掌握第四种

    1. package cn.test;
    3. import java.io.*;
    6. /**
    7.  * 复制图片：
    8.  *  分析：
    9.  *      复制数据用记事本打开可以读懂就是用字符流，而读不懂就使用字节流；
    10.  *      而字节流有四种方式，掌握第四种
    11.  *
    12.  *      数据源：e:\\证件照.jpg     ---FileInputStream---BufferedInputStream
    13.  *      目的地：证件照。jpg        ---FileOutputStream---BufferedOutputStrsam
    14.  *
    15.  * */
    16. public class CopyImageDemo {
    17.     public static void main(String[] args) throws IOException {
    18.         //使用字符串作为路径
    19. //        String srcString="e:\\证件照.jpg";
    20. //        String destString= "证件照.jpg";
    22. //        method1(srcString,destString);
    23. //        method2(srcString,destString);
    24. //        method3(srcString,destString);
    25. //        method4(srcString,destString);
    27.         //使用File对象作为参数
    28.         File srcfile = new File("e:\\证件照.jpg");
    29.         File destfile = new File("证件照.jpg");
    31.         //method1(srcfile,destfile);
    32.        // method2(srcfile,destfile);
    33. //        method3(srcfile,destfile);
    34.         method4(srcfile,destfile);
    39.     }
    41.     //字节缓冲区，一次字符数组
    42.     private static void method4(File srcfile, File destfile) throws IOException {
    43.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcfile));
    44.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
    46.         byte[] bytes = new byte[1024];
    47.         int len = 0;
    48.         while ((len = bis.read(bytes)) != -1) {
    49.             bos.write(bytes, 0, len);
    50.         }
    53.     }
    55.     //字节缓冲流，一次一个字节
    56.     private static void method3(File srcfile, File destfile) throws IOException {
    57.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcfile));
    58.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
    60.         int by = 0;
    61.         while ((by = bis.read()) != -1) {
    62.             bos.write(by);
    63.         }
    65.     }
    67.     //一次读写一个字符数组
    68.     private static void method2(File srcfile, File destfile) throws IOException {
    69.         FileInputStream fis = new FileInputStream(srcfile);
    70.         FileOutputStream fos = new FileOutputStream(destfile);
    72.         byte[] bytes = new byte[1024];
    73.         int len = 0;
    74.         while ((len = fis.read(bytes)) != -1) {
    75.             fos.write(bytes, 0, len);
    76.         }
    78.         fis.close();
    79.         fos.close();
    80.     }
    82.     //一次读写一个字节
    83.     private static void method1(File srcfile, File destfile) throws IOException {
    84.         FileInputStream fis = new FileInputStream(srcfile);
    85.         FileOutputStream fos = new FileOutputStream(destfile);
    87.         int by = 0;
    88.         while ((by = fis.read()) != -1) {
    89.             fos.write(by);
    90.         }
    92.         fis.close();
    93.         fos.close();
    96.     }
    99. }
    2. package cn.test;
    4. import java.io.BufferedWriter;
    5. import java.io.FileWriter;
    6. import java.io.IOException;
    7. import java.util.ArrayList;
    9. /**
    10.  * 需求:把ArrayList集合中的字符串数据存储到文本文件
    11.  *
    12.  *  分析：
    13.  *      ArrayList集合里面存储的是字符串
    14.  *      遍历ArrayList集合把数据获取到，然后存储到文本文件
    15.  *      文本文件使用字符流
    16.  *
    17.  *      数据源 ：   ArrayList<String>-- 遍历得到每一个字符串数据
    18.  *      目的地：    a.txt---FileWriter  ---BufferedWrite
    19.  *
    20.  * */
    21. public class ArrayListToFileDemo {
    22.     public static void main(String[] args)  throws IOException {
    23.         //创建集合对象
    24.         ArrayList<String> array = new ArrayList<>();
    25.         array.add("hello");
    26.         array.add("world");
    27.         array.add("java");
    29.         //封装数据源(目的地)
    30.         BufferedWriter  bw = new BufferedWriter(new FileWriter("a.txt"));
    32.         //遍历集合
    33.         for(String s  : array){
    34.             //写数据
    35.             bw.write(s);
    36.             bw.newLine();
    37.             bw.flush();
    39.         }
    40.         bw.close();
    41.     }
    42. }
    1. package cn.test;
    3. import java.io.BufferedReader;
    4. import java.io.FileReader;
    5. import java.io.IOException;
    6. import java.util.ArrayList;
    8. /**
    9.  *
    10.  * 需求：从文本文件读取数据（每一行为椅子字符串数据） 到集合总并遍历
    11.  * 分析：
    12.  *      数据源是一个文本文件
    13.  *      目的地是一个集合，元素是字符串
    14.  *
    15.  *      数据源 b2.txt      ---FileReader ---BufferedReader
    16.  *      目的地 ArrayList<String>
    17.  *
    18.  *
    19.  * */
    20. public class FileToAArrayListDemo {
    21.     public static void main(String[] args) throws IOException {
    22.         //封装数据源
    23.         BufferedReader br =new BufferedReader(new FileReader("b2.txt"));
    25.         //封装目的地（创建集合对象）
    26.         ArrayList<String> array = new ArrayList<>();
    28.         //读取数据，存到集合中
    29.         String line = null;
    30.         while((line = br.readLine())!=null){
    31.             array.add(line);
    32.         }
    34.         br.close();
    36.         //遍历集合
    37.         for(String s: array){
    38.             System.out.println("s = " + s);
    39.         }
    41.     }
    42. }
    1. package cn.test;
    3. import java.io.BufferedReader;
    4. import java.io.FileReader;
    5. import java.io.IOException;
    6. import java.util.ArrayList;
    7. import java.util.Random;
    9. /**
    10.  * 需求：b2.txt文件存储了几个名称，写一个程序 实现随机获取一个人的名字
    11.  *  分析：
    12.  *      1、把文本文件的数据存储到集合中
    13.  *      2、随机产生一个索引
    14.  *      3.根据该索引获取一个值
    15.  *
    16.  * */
    17. public class GetName {
    18.     public static void main(String[] args)  throws IOException {
    19.         //把文本文件的数据存到集合中(f封装数据源)
    20.         BufferedReader br =new BufferedReader(new FileReader("b2.txt"));
    22.         //创建集合对象（封装目的地）
    23.         ArrayList<String> array = new ArrayList<>();
    25.         //读取数据
    26.         String line = null;
    27.         while ((line = br.readLine())!=null){
    28.             array.add(line);
    29.         }
    30.         //释放资源
    31.         br.close();
    33.         //随机产生一个索引
    34.         Random r = new Random();
    35.         int index = r.nextInt(array.size());
    37.         //根据该索引获取一个值
    38.         String name = array.get(index);
    39.         System.out.println("幸运者是： " + name);
    41.     }
    42. }
    1. package cn.IO;
    3. import java.io.FileReader;
    4. import java.io.IOException;
    5. import java.io.LineNumberReader;
    7. /**
    8.  * BufferedReader
    9.  *      LineNumberReader
    10.  *              public int getLineNumber()获取当前行号
    11.  *              public void setLineNumber(int lineNumber)
    12.  *
    13.  * */
    14. public class LineNumberReaderDemo {
    15.     public static void main(String[] args) throws IOException {
    16.         LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
    18.         lnr.setLineNumber(10);//行号从10以后不包括10
    20.         String line = null;
    22.         while ((line = lnr.readLine()) != null) {
    23.             System.out.println(lnr.getLineNumber() + ":" + line);//1:hello2:world3:java
    26.         }
    27.         lnr.close();
    28.     }
    29. }