(二十五)基础系列 io流
来源：互联网 发布：淘宝网打不开商品强细 编辑：程序博客网 时间：2024/06/08 05:57
一、异常
01异常的概述
* A: 异常的概述 * a:什么是异常 * Java代码在运行时期发生的问题就是异常。 * b:异常类 * 在Java中，把异常信息封装成了一个类。 * 当出现了问题时，就会创建异常类对象并抛出异常相关的信息（如异常出现的位置、原因等）。 * c：我们见过的异常：数组角标越界异常ArrayIndexOutOfBoundsException,空指针异常NullPointerException02异常的继续体系和错误的区别
* A: 异常的继承体系 Throwable: 它是所有错误与异常的超类（祖宗类） |- Error 错误 |- Exception 编译期异常,进行编译JAVA程序时出现的问题 |- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题* B：异常与错误的区别 * a：异常 * 指程序在编译、运行期间发生了某种异常(XxxException)，我们可以对异常进行具体的处理。 * 若不处理异常，程序将会结束运行。 * 案例演示： public static void main(String[] args) { int[] arr = new int[3]; System.out.println(arr[0]); System.out.println(arr[3]); // 该句运行时发生了数组索引越界异常ArrayIndexOutOfBoundsException， // 由于没有处理异常，导致程序无法继续执行，程序结束。 System.out.println("over"); // 由于上面代码发生了异常，此句代码不会执行 } * b：错误 * 指程序在运行期间发生了某种错误(XxxError)，Error错误通常没有具体的处理方式，程序将会结束运行。 * Error错误的发生往往都是系统级别的问题，都是jvm所在系统发生的，并反馈给jvm的。 * 我们无法针对处理，只能修正代码。 * 案例演示： public static void main(String[] args) { int[] arr = new int[1024*1024*100]; //该句运行时发生了内存溢出错误OutOfMemoryError，开辟了过大的数组空间， //导致JVM在分配数组空间时超出了JVM内存空间，直接发生错误。 }03异常对象的产生原因和处理方式
* A: 异常对象的产生原因 * 案例代码： * 工具类 class ArrayTools{ //对给定的数组通过给定的角标获取元素。 public static int getElement(int[] arr,int index) { int element = arr[index]; return element; } } * 测试类 class ExceptionDemo2 { public static void main(String[] args) { int[] arr = {34,12,67}; int num = ArrayTools.getElement(arr,4) System.out.println("num="+num); System.out.println("over"); } } * 原因分析： * a: 由于没找到4索引，导致运行时发生了异常。这个异常JVM认识：ArrayIndexOutOfBoundsException。 这个异常Java本身有描述：异常的名称、异常的内容、异常的产生位置。 java将这些信息直接封装到异常对象中。new ArrayIndexOutOfBoundsException(4); * b：throw new ArrayIndexOutOfBoundsException(4);产生异常对象。JVM将产生的异常抛给调用者main()方法。 * c：main()方法接收到了数组索引越界异常对象。 由于main()方法并没有进行处理异常，main()方法就会继续把异常抛给调用者JVM。 当JVM收到异常后，将异常对象中的名称、异常内容、位置都显示在就控制台上。同时让程序立刻终止。* B：异常的处理方式 * a：JVM的默认处理方式 * 把异常的名称,原因,位置等信息输出在控制台，同时会结束程序。 * 一旦有异常发生，其后来的代码不能继续执行。 * b：解决程序中异常的手动方式 * a)：编写处理代码 try...catch...finally * b)：抛出 throws04方法内部抛出对象throw关键字
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。* A: 什么时候使用throw关键字？ * 当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断， 数据若不合法，就应该告诉调用者，传递合法的数据进来。 这时需要使用抛出异常的方式来告诉调用者。* B: 使用throw关键字具体操作 * a: 创建一个异常对象。封装一些提示信息(信息可以自己编写)。 * b: 通过关键字throw将这个异常对象告知给调用者。throw 异常对象； throw 用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。* C: throw关键字使用格式 * throw new 异常类名(参数); * 例如： throw new NullPointerException("要访问的arr数组不存在"); throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");* D：案例演示 * throw的使用05方法声明异常关键字throws
* A: 声明 * 将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。* B: 声明异常格式 * 修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… { }* C：注意事项： * throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。* D：代码演示： * 多个异常的处理==============================第二节课开始====================================
06try...catch异常处理
* A: 捕获 * Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理* B: 捕获异常格式 try { //需要被检测的语句。 } catch(异常类 变量) { //参数。 //异常的处理语句。 } finally { //一定会被执行的语句。 }* C: 格式说明 * a: try * 该代码块中编写可能产生异常的代码。 * b: catch * 用来进行某种异常的捕获，实现对捕获到的异常进行处理。 * c: finally： * 有一些特定的代码无论异常是否发生，都需要执行。 * 另外，因为异常会引发程序跳转，导致有些语句执行不到。 * 而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。 * d：try...catch...处理掉异常后，程序可以继续执行* D：案例演示 * 捕获异常格式07多catch处理
* A：一个try 多个catch组合 * 对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。* B：多catch处理的格式 void show(){ //不用throws try{ throw new Exception();//产生异常，直接捕获处理 }catch(XxxException e){ //处理方式 }catch(YyyException e){ //处理方式 }catch(ZzzException e){ //处理方式 } } 注意事项：在捕获异常处理中，变量也是有作用域的，如可以定义多个catch中异常变量名为e。08多catch处理细节
* A：细节：多个catch小括号中，写的是异常类的类名，有没有顺序的概念？ * 有顺序关系。* B：平级异常： * 抛出的异常类之间,没有继承关系,没有顺序 NullPointerException extends RuntimeException NoSuchElementException extends RuntimeException ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException* C：上下级关系的异常 * 越高级的父类,越写在下面 NullPointerException extends RuntimeException extends Exception09finally代码块
* A: finally的特点 * 被finally控制的语句体一定会执行* B：finally的作用 * finally,无论程序是否有异常出现,程序必须执行释放资源在 如：IO流操作和数据库操作中会见到10调用抛出异常方法try和throws处理方式
* A: 在实际开发中使用哪种异常处理方式呢？ * 能自己处理的尽量自己处理。(建议用try...catch)==============================第三节课开始====================================
11运行时期异常的特点
* A: 运行时期异常的概述: * RuntimeException和他的所有子类异常,都属于运行时期异常。 NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.* B：运行时期异常的特点 * a：方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常。 * b：运行时期异常一旦发生,需要程序人员修改源代码。 设计原因: 运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码 运行异常: 一旦发生,不要处理,请你修改源代码,运行异常一旦发生,后面的代码没有执行的意义12运行异常的案例
* A: 计算圆的面积案例 定义方法,计算圆形的面积 传递参数0,或者负数,计算的时候没有问题 但是,违反了真实情况 参数小于=0, 停止程序,不要在计算了* B：数组索引越界案例 使用数组中不存在的索引 public class RuntimeExceptionDemo { public static void main(String[] args) { double d = getArea(1); System.out.println(d); } /* * 定义方法,计算圆形的面积 * 传递参数0,或者负数,计算的时候没有问题 * 但是,违反了真实情况 * 参数小于=0, 停止程序,不要在计算了 */ public static double getArea(double r){ if(r <= 0) throw new RuntimeException("圆形不存在"); return r*r*Math.PI; } public static void function(){ int[] arr = {1,2,3}; //对数组的5索引进行判断,如果5索引大于100,请将5索引上的数据/2,否则除以3 //索引根本就没有 if(arr[5] > 100){ arr[5] = arr[5]/2; }else{ arr[5] = arr[5]/3; } }13方法重写时候异常的处理
* A：方法重写时候异常的处理 * a：子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。 例如： class Fu { public void method () throws RuntimeException { } } class Zi extends Fu { public void method() throws RuntimeException { } //抛出父类一样的异常 //public void method() throws NullPointerException{ } //抛出父类子异常 } * b：当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集。 例如： class Fu { public void method () throws NullPointerException, ClassCastException{ } } class Zi extends Fu { public void method()throws NullPointerException, ClassCastException { } public void method() throws NullPointerException{ } //抛出父类异常中的一部分 public void method() throws ClassCastException { } //抛出父类异常中的一部分 } * c：当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常的。 例如： class Fu { public void method (){ } } class Zi extends Fu { public void method() throws Exception { }//错误的方式 }* B：问题：父类中会存在下列这种情况，接口也有这种情况。 接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？ 回答：无法进行throws声明，只能catch的捕获。 万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。14Throwable类方法
* A: 常见方法 * a：getMessage()方法 返回该异常的详细信息字符串，即异常提示信息 * b：toString()方法 返回该异常的名称与详细信息字符串 * c：printStackTrace()方法 在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置* B：案例演示 异常的常用方法代码演示 try { Person p= null; if (p==null) { throw new NullPointerException(“出现空指针异常了，请检查对象是否为null”); } } catch (NullPointerException e) { String message = e.getMesage(); System.out.println(message ); String result = e.toString(); System.out.println(result); e.printStackTrace(); } A: 自定义异常的定义 * a：通过阅读源码，发现规律： 每个异常中都调用了父类的构造方法，把异常描述信息传递给了父类，让父类帮我们进行异常信息的封装。 * b：格式： Class 异常名 extends Exception{ //或继承RuntimeException public 异常名(){ } public 异常名(String s){ super(s); } } * c：自定义异常继承Exception演示 * d：自定义异常继承RuntimeException演示* B：自定义异常的练习 在Person类的有参数构造方法中，进行年龄范围的判断， 若年龄为负数或大于200岁，则抛出NoAgeException异常，异常提示信息“年龄数值非法”。 要求：在测试类中，调用有参数构造方法，完成Person对象创建，并进行异常的处理。* C：关于构造方法抛出异常总结 构造函数到底抛出这个NoAgeException是继承Exception呢？还是继承RuntimeException呢？ * a：继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。 * b：继承RuntimeExcpetion,不需要throws声明的，这时调用是不需要编写捕获代码的，因为调用根本就不知道有问题。 一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。01IO技术概述.avi（02:49）
* A:IO技术概述 * a: Output * 把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作 * b: Input * 把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作 * c: IO操作 * 把上面的这种输入和输出动作称为IO操作02File类的概述和作用
* A:File类的概述和作用 * a: File的概念 * File类是文件和目录路径名的抽象表示形式 * Java中把文件或者目录（文件夹）都封装成File对象 * 我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可03File类静态的成员变量
* A:File类静态的成员变量 * a: pathSeparator * 与系统有关的路径分隔符，为了方便，它被表示为一个字符串 * b: separator * 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串 * c: 案例代码 /* * java.io.File * 将操作系统中的,文件,目录(文件夹),路径,封装成File对象 * 提供方法,操作系统中的内容 * File与系统无关的类 * 文件 file * 目录 directory * 路径 path */ public class FileDemo { public static void main(String[] args) { //File类静态成员变量 //与系统有关的路径分隔符 String separator = File.pathSeparator; System.out.println(separator);// 是一个分号,目录的分割(window中环境变量配置各个路径用分号分割，表示一个完整的路径结束) Linux中是冒号 : //与系统有关的默认名称分隔符 separator = File.separator; System.out.println(separator);// 向右 \ 目录名称分割 Linux / } }04File类构造方法_1
* A: File类构造方法_1 * a: File(String pathname) * 通过将给定路径名字符串转换为一个File对象,之后可以使用File中的方法 * windows中的路径或文件名不区分大小写 * d: 案例代码 public class FileDemo1 { public static void main(String[] args) { function(); } /* * File(String pathname) * 传递路径名: 可以写到文件夹,可以写到一个文件 * c:\\abc c:\\abc\\Demo.java * 将路径封装File类型对象 */ public static void function(){ File file = new File("d:\\eclipse"); System.out.println(file); } }05相对路径和绝对路径
* A: 相对路径和绝对路径 * a: 绝对路径 * 绝对路径是一个固定的路径,从盘符开始 * b: 相对路径 * 相对路径相对于某个位置,在eclipse下是指当前项目下 * c: 路径 绝对路径 在系统中具有唯一性 c:\\windows\\system32 相对路径 表示路径之间的关系 D:\\develop\\Java\\jdk1.7.0_72\\bin D:\\develop\\Java\\jre7 路径之间关系 Java 父目录是D:\\develop Java 子目录是：jdk1.7.0_72 父路径是 唯一性 子目录是可以多个06File类的构造方法_2
* A: File类的构造方法_2 * a:File(String parent, String child) * 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 对象 * b: File(File parent, String child) * c: 案例代码 public class FileDemo1 { public static void main(String[] args) { function_2(); } /* * File(File parent,String child) * 传递路径,传递File类型父路径,字符串子路径 * 好处: 父路径是File类型,父路径可以直接调用File类方法 */ public static void function_2(){ File parent = new File("d:"); File file = new File(parent,"eclipse"); System.out.println(file); } /* * File(String parent,String child) * 传递路径,传递字符串父路径,字符串子路径 * 好处: 单独操作父路径和子路径 */ public static void function_1(){ File file = new File("d:","eclipse"); System.out.println(file); } }07File类创建文件功能
* A: File类创建文件功能 * a: public boolean createNewFile() * 创建文件 如果存在这样的文件，就不创建了 * b: 案例代码 public class FileDemo2 { public static void main(String[] args)throws IOException { function(); } /* * File创建文件的功能 * boolean createNewFile() * 创建的文件路径和文件名,在File构造方法中给出 * 文件已经存在了,不在创建 */ public static void function()throws IOException{ File file = new File("c:\\a.txt"); boolean b = file.createNewFile(); System.out.println(b); } }08File类创建目录功能
* A: File类创建目录功能 * a: 创建目录 * public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了 * public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来 * b: 案例代码 public class FileDemo2 { public static void main(String[] args)throws IOException { function_1(); } /* * File创建文件夹功能 * boolean mkdirs() 创建多层文件夹 * 创建的路径也在File构造方法中给出 * 文件夹已经存在了,不在创建 */ public static void function_1(){ File file = new File("c:\\abc"); boolean b = file.mkdirs(); System.out.println(b); } }09File类删除功能
* A: File类删除功能 * a: 删除功能 * public boolean delete():删除文件或者文件夹* B: 案例代码 public class FileDemo2 { public static void main(String[] args)throws IOException { function_2(); } /* * File类的删除功能 * boolean delete() * 删除的文件或者是文件夹,在File构造方法中给出 * 删除成功返回true,删除失败返回false * 删除方法,不走回收站,直接从硬盘中删除 * 删除有风险,运行需谨慎 */ public static void function_2(){ File file = new File("c:\\a.txt"); boolean b = file.delete(); System.out.println(b); } }10File类获取功能
* A：File类获取功能 * a: 方法介绍 * String getName(): 返回路径中表示的文件或者文件夹名 * 获取路径中的最后部分的名字 * long length(): 返回路径中表示的文件的字节数 * String getAbsolutePath(): 获取绝对路径,返回String对象 * File getAbsoluteFile() : 获取绝对路径,返回File对象 * eclipse环境中,写一个相对路径,绝对位置工程根目录 * String getParent(): 获取父路径,返回String对象 * File getParentFile(): 获取父路径,返回File对象 * b: 案例代码 public class FileDemo3 { public static void main(String[] args) { function_3(); } /* * File类的获取功能 * String getParent() 返回String对象 * File getParentFile()返回File对象 * 获取父路径 */ public static void function_3(){ File file = new File("d:\\eclipse\\eclipse.exe"); File parent = file.getParentFile(); System.out.println(parent); } /* * File类获取功能 * String getAbsolutePath() 返回String对象 * File getAbsoluteFile() 返回File对象 * 获取绝对路径 * eclipse环境中,写的是一个相对路径,绝对位置工程根目录 */ public static void function_2(){ File file = new File("src"); File absolute = file.getAbsoluteFile(); System.out.println(absolute); } /* * File类获取功能 * long length() * 返回路径中表示的文件的字节数 */ public static void function_1(){ File file = new File("d:\\eclipse\\eclipse.exe"); long length = file.length(); System.out.println(length); } /* * File类的获取功能 * String getName() * 返回路径中表示的文件或者文件夹名 * 获取路径中的最后部分的名字 */ public static void function(){ File file = new File("d:\\eclipse\\eclipse.exe"); String name = file.getName(); System.out.println(name); /*String path = file.getPath(); System.out.println(path);*/ // System.out.println(file); } }11File类判断功能
* A: File类判断功能 * a: 方法介绍 * boolean exists(): 判断File构造方法中封装路径是否存在 * 存在返回true,不存在返回false * boolean isDirectory(): 判断File构造方法中封装的路径是不是文件夹 * 如果是文件夹,返回true,不是文件返回false * boolean isFile(): 判断File构造方法中封装的路径是不是文件 * 如果是文件,返回true,不是文件返回false * b: 案例代码 public class FileDemo4 { public static void main(String[] args) { function_1(); } /* * File判断功能 * boolean isDirectory() * 判断File构造方法中封装的路径是不是文件夹 * 如果是文件夹,返回true,不是文件返回false * * boolean isFile() * 判断File构造方法中封装的路径是不是文件 */ public static void function_1(){ File file = new File("d:\\eclipse\\eclipse.exe"); if(file.exists()){ boolean b = file.isDirectory(); System.out.println(b); } } /* * File判断功能 * boolean exists() * 判断File构造方法中封装路径是否存在 * 存在返回true,不存在返回false */ public static void function(){ File file = new File("src"); boolean b = file.exists(); System.out.println(b); } }12File类list获取功能
* A: File类list获取功能 * a: 方法介绍 * String[] list()：获取到File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录) * 返回只有名字 * File[] listFiles()：获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录) * 返回的是目录或者文件的全路径 * static File[] listRoots(): 列出可用的文件系统根 * b: 案例代码 public class FileDemo { public static void main(String[] args) { function_2(); } public static void function_2(){ //获取系统中的所有根目录 File[] fileArr = File.listRoots(); for(File f : fileArr){ System.out.println(f); } } /* * File类的获取功能 * File[] listFiles() * 获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录) * 返回的是目录或者文件的全路径 */ public static void function_1(){ File file = new File("d:\\eclipse"); File[] fileArr = file.listFiles(); for(File f : fileArr){ System.out.println(f); } } /* * File类的获取功能 * String[] list() * 获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录) * 返回只有名字 */ public static void function(){ File file = new File("c:"); String[] strArr = file.list(); System.out.println(strArr.length); for(String str : strArr){ System.out.println(str); } } }13文件过滤器
* A: 文件过滤器 * a: 作用 * 过滤一个目录下的指定扩展名的文件，或者包含某些关键字的文件夹 * b: 方法介绍 * public String[] list(FilenameFilter filter) * public File[] listFiles(FileFilter filter) * C: 案例代码 /* * 自定义过滤器 * 实现FileFilter接口,重写抽象方法 */ public class MyFilter implements FileFilter{ public boolean accept(File pathname) { /* * pathname 接受到的也是文件的全路径 * c:\\demo\\1.txt * 对路径进行判断,如果是java文件,返回true,不是java文件,返回false * 文件的后缀结尾是.java */ //String name = pathname.getName(); return pathname.getName().endsWith(".java"); } } /* * File类的获取,文件获取过滤器 * 遍历目录的时候,可以根据需要,只获取满足条件的文件 * 遍历目录方法 listFiles()重载形式 * listFiles(FileFilter filter)接口类型 * 传递FileFilter接口的实现类 * 自定义FileFilter接口实现类,重写抽象方法, * 接口实现类对象传递到遍历方法listFiles */ public class FileDemo1 { public static void main(String[] args) { File file = new File("c:\\demo"); File[] fileArr = file.listFiles(new MyFilter()); for(File f : fileArr){ System.out.println(f); } } }14文件过滤器_原理分析
* A:文件过滤器_原理分析 * listFiles()遍历目录的同时，获取到了文件名全路径，调用过滤器的方法accept，将获取到的路径传递给accept方法的参数pathname * accept方法接收了参数pathname，参数是listFiles传递来的 * 在accept方法中，进行判断，如果这个路径是Java文件，返回true，走着返回false * 一旦方法返回了true * listFiles将路径保存到File数组中15递归遍历全目录
* A: 递归遍历全目录 * a: 案例代码 /* * 对一个目录的下的所有内容,进行完全的遍历 * 编程技巧,方法的递归调用,自己调用自己 */ public class FileDemo { public static void main(String[] args) { File dir = new File("d:\\eclipse"); getAllDir(dir); } /* * 定义方法,实现目录的全遍历 */ public static void getAllDir(File dir){ System.out.println(dir); //调用方法listFiles()对目录,dir进行遍历 File[] fileArr = dir.listFiles(); for(File f : fileArr){ //判断变量f表示的路径是不是文件夹 if(f.isDirectory()){ //是一个目录,就要去遍历这个目录 //本方法,getAllDir,就是给个目录去遍历 //继续调用getAllDir,传递他目录 getAllDir(f); }else{ System.out.println(f); } } } }16递归概念和注意事项
* A:递归概念和注意事项 * a: 递归概念 * 递归，指在当前方法内调用自己的这种现象 * 递归分为两种，直接递归和间接递归 * 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法 * b: 注意事项 * 递归一定要有出口, 必须可以让程序停下 * 递归次数不能过多 * 构造方法,禁止递归17递归求和计算
* A: 递归求和计算 * a: 题目分析 * 1+2+3+...+(n-1)+n:求1到n的和 * 总结规律：1到n的和等于1到(n-1)的和再加n * getSum(n-1)+ n * 递归出口：getSum(1) return 1; * b: 案例代码 /* * 方法的递归调用 * 方法自己调用自己 * 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化 * 注意: * 递归一定要有出口, 必须可以让程序停下 * 递归次数不能过多 * 构造方法,禁止递归 */ public class DiGuiDemo { public static void main(String[] args) { int sum = getSum(3); System.out.println(sum); } /* * 计算 1+2+3+100和 = 5050 * 计算规律: * n+(n-1)+(n-2) * 100+(100-1)+(99-1)+...1 */ public static int getSum(int n){ if( n == 1) return 1; return n + getSum(n-1); } }18递归求阶乘
* A: 递归求和计算 * a: 题目分析 * 5!=5*4*3*2*1 * =5*4! * 4!=4*3! * 3!=3*2! * 2!=2*1! * 1!=1 * n!=n*(n-1)! * 递归出口：n*getJieCheng(n-1): getJieCheng(1) return 1; * b: 案例代码 /* * 方法的递归调用 * 方法自己调用自己 * 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化 * 注意: * 递归一定要有出口, 必须可以让程序停下 * 递归次数不能过多 * 构造方法,禁止递归 */ public class DiGuiDemo { public static void main(String[] args) { System.out.println(getJieCheng(5)); } /* * 计算阶乘 5! * 5*4*3*2*1 */ public static int getJieCheng(int n){ if ( n == 1) return 1; return n * getJieCheng(n-1); } }19递归计算斐波那契数列
* A: 递归计算斐波那契数列 * a：题目分析 * 1 1 2 3 5 8 13 21 * 从第三项开始，后面的每一项都等于前面两项的和，第一项和第二项的值为1，作为程序的出口 * b: 案例代码 /* * 方法的递归调用 * 方法自己调用自己 * 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化 * 注意: * 递归一定要有出口, 必须可以让程序停下 * 递归次数不能过多 * 构造方法,禁止递归 */ public class DiGuiDemo { public static void main(String[] args) { System.out.println(getFBNQ(12)); } /* * 方法递归,计算斐波那契数列 * */ public static int getFBNQ(int month){ if( month == 1) return 1; if( month == 2) return 1; return getFBNQ(month-1)+getFBNQ(month-2); } }20遍历目录下的所有java文件
* A: 遍历目录下的所有java文件 * a: 案例代码 public class MyJavaFilter implements FileFilter { public boolean accept(File pathname) { //判断获取的是目录,直接返回true if(pathname.isDirectory()) return true; return pathname.getName().toLowerCase().endsWith(".java"); } } /* * 遍历目录,获取目录下的所有.java文件 * 遍历多级目录,方法递归实现 * 遍历的过程中,使用过滤器 */ public class FileDemo1 { public static void main(String[] args) { getAllJava(new File("c:\\demo")); // new File("c:\\demo").delete(); } /* * 定义方法,实现遍历指定目录 * 获取目录中所有的.java文件 */ public static void getAllJava(File dir){ //调用File对象方法listFiles()获取,加入过滤器 File[] fileArr = dir.listFiles(new MyJavaFilter()); for(File f : fileArr){ //对f路径,判断是不是文件夹 if(f.isDirectory()){ //递归进入文件夹遍历 getAllJava(f); }else{ System.out.println(f); } } } }01输入和输出
* A:输入和输出 * a: 参照物 * 到底是输入还是输出，都是以Java程序为参照 * b: Output * 把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作 * 程序到文件称为输出 * c: Input * 把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作 * 文件到程序称为输入 * d: IO操作 * 把上面的这种输入和输出动作称为IO操作02字节输出流OutputStream
* A: 字节输出流OutputStream * a.概念 * IO流用来处理设备之间的数据传输 * Java对数据的操作是通过流的方式 * Java用于操作流的类都在IO包中 * 流按流向分为两种：输入流，输出流。 * 流按操作类型分为两种： * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 * 字符流 : 字符流只能操作纯字符数据，比较方便。 * b.IO流常用父类 * 字节流的抽象父类： * InputStream * OutputStream * 字符流的抽象父类： * Reader * Writer * c.IO程序书写 * 使用前，导入IO包中的类 * 使用时，进行IO异常处理 * 使用后，释放资源 * d: 方法介绍 * void close(): 关闭此输出流并释放与此流有关的所有系统资源。 * void write(byte[] b)： 将 b.length 个字节从指定的 byte 数组写入此输出流 * void write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 * abstract void write(int b) ： 将指定的字节写入此输出流。03字节输出流FileOutputStream写字节
* A: 字节输出流FileOutputStream写字节 * a: FileOutputStream * 写入数据文件,学习父类方法,使用子类对象 * b: FileOutputStream构造方法 * 作用：绑定输出的输出目的 * FileOutputStream(File file) * 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 * FileOutputStream(File file, boolean append) * 创建一个向指定 File 对象表示的文件中写入数据的文件输出流，以追加的方式写入。 * FileOutputStream(String name) * 创建一个向具有指定名称的文件中写入数据的输出文件流。 * FileOutputStream(String name, boolean append) * 创建一个向具有指定 name 的文件中写入数据的输出文件流，以追加的方式写入。 * c: 流对象使用步骤 * 1. 创建流子类的对象,绑定数据目的 * 2. 调用流对象的方法write写 * 3. close释放资源 * d: 注意事项 * 流对象的构造方法,可以创建文件,如果文件存在,直接覆盖 * e: 案例代码 /* * FileOutputStream * 写入数据文件,学习父类方法,使用子类对象 * * 子类中的构造方法: 作用:绑定输出的输出目的 * 参数: * File 封装文件 * String 字符串的文件名 * * 流对象使用步骤 * 1. 创建流子类的对象,绑定数据目的 * 2. 调用流对象的方法write写 * 3. close释放资源 * * 流对象的构造方法,可以创建文件,如果文件存在,直接覆盖 */ public class FileOutputStreamDemo { public static void main(String[] args)throws IOException { FileOutputStream fos = new FileOutputStream("c:\\a.txt"); //流对象的方法write写数据 //写1个字节 fos.write(97); //关闭资源 fos.close(); } }04字节输出流FileOutputStream写字节数组
* A: 字节输出流FileOutputStream写字节数组 * a: 方法介绍 * void write(byte[] b)： 将 b.length 个字节从指定的 byte 数组写入此输出流 * void write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 * b: 案例代码 /* * FileOutputStream * 写入数据文件,学习父类方法,使用子类对象 * * 子类中的构造方法: 作用:绑定输出的输出目的 * 参数: * File 封装文件 * String 字符串的文件名 * * 流对象使用步骤 * 1. 创建流子类的对象,绑定数据目的 * 2. 调用流对象的方法write写 * 3. close释放资源 * * 流对象的构造方法,可以创建文件,如果文件存在,直接覆盖 */ public class FileOutputStreamDemo { public static void main(String[] args)throws IOException { FileOutputStream fos = new FileOutputStream("c:\\a.txt"); //流对象的方法write写数据 //写字节数组 byte[] bytes = {65,66,67,68}; fos.write(bytes); //写字节数组的一部分,开始索引,写几个 fos.write(bytes, 1, 2); //写入字节数组的简便方式 //写字符串 fos.write("hello".getBytes()); //关闭资源 fos.close(); } }05文件的续写和换行符号
* A: 文件的续写和换行符号 * a: 文件的续写 * FileOutputStream构造方法, 的第二个参数中,加入true * b: 换行符号 * 在文件中,写入换行,符号换行 \r\n * \r\n 可以写在上一行的末尾, 也可以写在下一行的开头 * c: 案例代码 /* * FileOutputStream 文件的续写和换行问题 * 续写: FileOutputStream构造方法, 的第二个参数中,加入true * 在文件中,写入换行,符号换行 \r\n * \r\n 可以写在上一行的末尾, 也可以写在下一行的开头 */ public class FileOutputStreamDemo1 { public static void main(String[] args)throws IOException { File file = new File("c:\\b.txt"); FileOutputStream fos = new FileOutputStream(file,true); fos.write("hello\r\n".getBytes()); fos.write("world".getBytes()); fos.close(); } }06IO中的异常处理
* A: IO中的异常处理 * a:IO流的异常处理 * try catch finally * b: 细节 * 1. 保证流对象变量,作用域足够 * 2. catch里面,怎么处理异常 * 输出异常的信息,目的看到哪里出现了问题 * 停下程序,从新尝试 * 3. 如果流对象建立失败了,需要关闭资源吗 * new 对象的时候,失败了,没有占用系统资源 * 释放资源的时候,对流对象判断null * 变量不是null,对象建立成功,需要关闭资源 * c: 案例代码 public class FileOutputStreamDemo3 { public static void main(String[] args) { //try 外面声明变量,try 里面建立对象 FileOutputStream fos = null; try{ fos = new FileOutputStream("s:\\a.txt"); fos.write(100); }catch(IOException ex){ System.out.println(ex); throw new RuntimeException("文件写入失败,重试"); }finally{ try{ if(fos!=null) fos.close(); }catch(IOException ex){ throw new RuntimeException("关闭资源失败"); } } } }07字节输入流InputStream
* A: 字节输入流InputStream * a: 方法介绍 * abstract int read() ： * 从输入流中读取数据的下一个字节。 * int read(byte[] b) * 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 * int read(byte[] b, int off, int len) * 将输入流中最多 len 个数据字节读入 byte 数组。 * void close() * 关闭此输入流并释放与该流关联的所有系统资源。 * b: 案例代码 /* * 字节输入流 * java.io.InputStream 所有字节输入流的超类 * 作用: 读取任意文件,每次只读取1个字节 * 读取的方法 read * int read() 读取1个字节 * int read(byte[] b) 读取一定量的字节,存储到数组中 */ public class InputStreamDemo { }08字节输入流FileInputStream读取字节
* A: 字节输入流FileInputStream读取字节 * a: 方法介绍 * abstract int read() ： * 从输入流中读取数据的下一个字节，返回-1表示文件结束 * int read(byte[] b) * 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 * 读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。 * int read(byte[] b, int off, int len) * 将输入流中最多 len 个数据字节读入 byte 数组。 * void close() * 关闭此输入流并释放与该流关联的所有系统资源。 * b: 案例代码 /* * FileInputStream读取文件 * * 构造方法: 为这个流对象绑定数据源 * * 参数: * File 类型对象 * String 对象 * 输入流读取文件的步骤 * 1. 创建字节输入流的子类对象 * 2. 调用读取方法read读取 * 3. 关闭资源 * * read()方法, * read()执行一次,就会自动读取下一个字节 * 返回值,返回的是读取到的字节, 读取到结尾返回-1 */ public class FileInputStreamDemo { public static void main(String[] args) throws IOException{ FileInputStream fis = new FileInputStream("c:\\a.txt"); //读取一个字节,调用方法read 返回int //使用循环方式,读取文件, 循环结束的条件 read()方法返回-1 int len = 0;//接受read方法的返回值 while( (len = fis.read()) != -1){ System.out.print((char)len); } //关闭资源 fis.close(); } } /* * int i = fis.read(); System.out.println(i); i = fis.read(); System.out.println(i); i = fis.read(); System.out.println(i); i = fis.read(); System.out.println(i); */09字节输入流FileInputStream读取字节数组
* A: 字节输入流FileInputStream读取字节数组 * a: 方法介绍 * int read(byte[] b) * 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 * 读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。 * int read(byte[] b, int off, int len) * 将输入流中最多 len 个数据字节读入 byte 数组。 * b: 案例代码 /* * FileInputStream读取文件 * 读取方法 int read(byte[] b) 读取字节数组 * 数组作用: 缓冲的作用, 提高效率 * read返回的int,表示什么含义 读取到多少个有效的字节数 */ public class FileInputStreamDemo1 { public static void main(String[] args) throws IOException { FileInputStream fis = new FileInputStream("c:\\a.txt"); // 创建字节数组 byte[] b = new byte[2]; int len = fis.read(b); System.out.println(new String(b));// ab System.out.println(len);// 2 len = fis.read(b); System.out.println(new String(b));// cd System.out.println(len);// 2 len = fis.read(b); System.out.println(new String(b));// ed System.out.println(len);// 1 len = fis.read(b); System.out.println(new String(b));// ed System.out.println(len);// -1 fis.close(); } }10字节输入流FileInputStream读取字节数组的实现原理
* A：字节输入流FileInputStream读取字节数组的实现原理 * a: 原理 * 参见day23_source文件夹中的"读取数组的原理.jpg" * b: 案例代码 public class FileInputStreamDemo1 { public static void main(String[] args) throws IOException { FileInputStream fis = new FileInputStream("c:\\a.txt"); //创建字节数组 byte[] b = new byte[1024]; int len = 0 ; while( (len = fis.read(b)) !=-1){ System.out.print(new String(b,0,len)); } fis.close(); } }11文件复制原理
* A: 文件复制原理 * a: 见day23_source/文件复制原理.jpg12字节流复制文件读取单个字节
* A: 字节流复制文件读取单个字节 * a: 案例代码 /* * 将数据源 c:\\a.txt * 复制到 d:\\a.txt 数据目的 * 字节输入流,绑定数据源 * 字节输出流,绑定数据目的 * * 输入,读取1个字节 * 输出,写1个字节 */ public class Copy { public static void main(String[] args) { //定义两个流的对象变量 FileInputStream fis = null; FileOutputStream fos = null; try{ //建立两个流的对象,绑定数据源和数据目的 fis = new FileInputStream("c:\\t.zip"); fos = new FileOutputStream("d:\\t.zip"); //字节输入流,读取1个字节,输出流写1个字节 int len = 0 ; while((len = fis.read())!=-1){ fos.write(len); } }catch(IOException ex){ System.out.println(ex); throw new RuntimeException("文件复制失败"); }finally{ try{ if(fos!=null) fos.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); }finally{ try{ if(fis!=null) fis.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); } } } } }13字节流复制文件读取字节数组
* A: 字节流复制文件读取字节数组 * a: 案例代码 /* * 字节流复制文件 * 采用数组缓冲提高效率 * 字节数组 * FileInputStream 读取字节数组 * FileOutputStream 写字节数组 */ public class Copy_1 { public static void main(String[] args) { long s = System.currentTimeMillis(); FileInputStream fis = null; FileOutputStream fos = null; try{ fis = new FileInputStream("c:\\t.zip"); fos = new FileOutputStream("d:\\t.zip"); //定义字节数组,缓冲 byte[] bytes = new byte[1024*10]; //读取数组,写入数组 int len = 0 ; while((len = fis.read(bytes))!=-1){ fos.write(bytes, 0, len); } }catch(IOException ex){ System.out.println(ex); throw new RuntimeException("文件复制失败"); }finally{ try{ if(fos!=null) fos.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); }finally{ try{ if(fis!=null) fis.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); } } } long e = System.currentTimeMillis(); System.out.println(e-s); } }14编码表
* A: 编码表 * a: 定义： * 生活中字符和计算机二进制的对应关系表,就是编码表 * b: 分类 * 1、ascii： 一个字节中的7位就可以表示。对应的字节都是正数。0-xxxxxxx * 2、iso-8859-1:拉丁码表 latin，用了一个字节用的8位。1-xxxxxxx 负数。 * 3、GB2312:简体中文码表。包含6000-7000中文和符号。用两个字节表示。两个字节第一个字节是负数,第二个字节可能是正数 * GBK:目前最常用的中文码表，2万的中文和符号。用两个字节表示，其中的一部分文字，第一个字节开头是1，第二字节开头是0 * GB18030：最新的中文码表，目前还没有正式使用。 * 4、unicode：国际标准码表:无论是什么文字，都用两个字节存储。 * Java中的char类型用的就是这个码表。char c = 'a';占两个字节。 * Java中的字符串是按照系统默认码表来解析的。简体中文版 字符串默认的码表是GBK。 * 5、UTF-8:基于unicode，一个字节就可以存储数据，不要用两个字节存储，而且这个码表更加的标准化，在每一个字节头加入了编码信息(后期到api中查找)。 * 6、能识别中文的码表：GBK、UTF-8；正因为识别中文码表不唯一，涉及到了编码解码问题。 * 对于我们开发而言；常见的编码 GBK UTF-8 ISO-8859-1 * 文字--->(数字) ：编码。 “abc”.getBytes() byte[] * (数字)--->文字 : 解码。 byte[] b={97,98,99} new String(b) 15字符输出流写文本FileWriter类
* A: 字符输出流写文本FileWriter类 * a: 方法介绍 * void write(int c) * 写入单个字符 * void write(String str) * 写入字符串 * void write(String str, int off, int len) * 写入字符串的某一部分 * void write(char[] cbuf) * 写入字符数组 * abstract void write(char[] cbuf, int off, int len) * 写入字符数组的某一部分 * b: 案例代码 /* * 字符输出流 * java.io.Writer 所有字符输出流的超类 * 写文件,写文本文件 * * 写的方法 write * write(int c) 写1个字符 * write(char[] c)写字符数组 * write(char[] c,int,int)字符数组一部分,开始索引,写几个 * write(String s) 写入字符串 * * Writer类的子类对象 FileWriter * * 构造方法: 写入的数据目的 * File 类型对象 * String 文件名 * * 字符输出流写数据的时候,必须要运行一个功能,刷新功能 * flush() */ public class WriterDemo { public static void main(String[] args) throws IOException{ FileWriter fw = new FileWriter("c:\\1.txt"); //写1个字符 fw.write(100); fw.flush(); //写1个字符数组 char[] c = {'a','b','c','d','e'}; fw.write(c); fw.flush(); //写字符数组一部分 fw.write(c, 2, 2); fw.flush(); //写如字符串 fw.write("hello"); fw.flush(); fw.close(); } }16字符输入流读取文本FileReader类
* A: 字符输入流读取文本FileReader类 * a: 方法介绍 * int read() * 读取单个字符 * int read(char[] cbuf) * 将字符读入数组 * abstract int read(char[] cbuf, int off, int len) * 将字符读入数组的某一部分。 * b: 案例代码 /* * 字符输入流读取文本文件,所有字符输入流的超类 * java.io.Reader * 专门读取文本文件 * * 读取的方法 : read() * int read() 读取1个字符 * int read(char[] c) 读取字符数组 * * Reader类是抽象类,找到子类对象 FileReader * * 构造方法: 绑定数据源 * 参数: * File 类型对象 * String文件名 */ public class ReaderDemo { public static void main(String[] args) throws IOException{ FileReader fr = new FileReader("c:\\1.txt"); /*int len = 0 ; while((len = fr.read())!=-1){ System.out.print((char)len); }*/ char[] ch = new char[1024]; int len = 0 ; while((len = fr.read(ch))!=-1){ System.out.print(new String(ch,0,len)); } fr.close(); } }17flush方法和close方法区别
* A: flush方法和close方法区别 *a: flush()方法 * 用来刷新缓冲区的,刷新后可以再次写出,只有字符流才需要刷新 *b: close()方法 * 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出 18字符流复制文本文件
* A: 字符流复制文本文件 * a: 案例代码 /* * 字符流复制文本文件,必须文本文件 * 字符流查询本机默认的编码表,简体中文GBK * FileReader读取数据源 * FileWriter写入到数据目的 */ public class Copy_2 { public static void main(String[] args) { FileReader fr = null; FileWriter fw = null; try{ fr = new FileReader("c:\\1.txt"); fw = new FileWriter("d:\\1.txt"); char[] cbuf = new char[1024]; int len = 0 ; while(( len = fr.read(cbuf))!=-1){ fw.write(cbuf, 0, len); fw.flush(); } }catch(IOException ex){ System.out.println(ex); throw new RuntimeException("复制失败"); }finally{ try{ if(fw!=null) fw.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); }finally{ try{ if(fr!=null) fr.close(); }catch(IOException ex){ throw new RuntimeException("释放资源失败"); } } } } }01转换流概述
* A: 转换流概述 * a: 转换流概述 * OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的字符编码表，将要写入流中的字符编码成字节 * 将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去02转换流_字符转字节的过程
* A: 转换流_字符转字节的过程 * a.图解 * 详见day24_source/转换流.JPG图片03OutputStreamWriter写文本文件
* A: OutputStreamWriter写文本文件 * a: OutputStreamWriter * java.io.OutputStreamWriter 继承Writer类 * 就是一个字符输出流，写文本文件 * write()字符，字符数组，字符串 * 字符通向字节的桥梁，将字符流转字节流 * OutputStreamWriter 使用方式 * 构造方法： * OutputStreamWriter(OuputStream out)接收所有的字节输出流 * 字节输出流： FileOutputStream * OutputStreamWriter(OutputStream out, String charsetName) * String charsetName 传递编码表名字 GBK UTF-8 * OutputStreamWriter 有个子类， FileWriter * b: 案例代码 public class OutputStreamWriterDemo { public static void main(String[] args)throws IOException { // writeGBK(); writeUTF(); } /* * 转换流对象OutputStreamWriter写文本 * 采用UTF-8编码表写入 */ public static void writeUTF()throws IOException{ //创建字节输出流，绑定文件 FileOutputStream fos = new FileOutputStream("c:\\utf.txt"); //创建转换流对象，构造方法保证字节输出流，并指定编码表是UTF-8 OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8"); osw.write("你好"); osw.close(); } /* * 转换流对象 OutputStreamWriter写文本 * 文本采用GBK的形式写入 */ public static void writeGBK()throws IOException{ //创建字节输出流，绑定数据文件 FileOutputStream fos = new FileOutputStream("c:\\gbk.txt"); //创建转换流对象，构造方法，绑定字节输出流，使用GBK编码表 OutputStreamWriter osw = new OutputStreamWriter(fos); //转换流写数据 osw.write("你好"); osw.close(); } }04转换流_字节转字符流过程
* A: 转换流_字节转字符流过程 * a: InputStreamReader * java.io.InputStreamReader 继承 Reader * 字符输入流，读取文本文件 * 字节流向字符的敲了，将字节流转字符流 * 读取的方法: * read() 读取1个字符，读取字符数组 * 技巧 * OuputStreamWriter写了文件 * InputStreamReader读取文件 * OutputStreamWriter(OutputStream out)所有字节输出流 * InputStreamReader(InputStream in) 接收所有的字节输入流 * 可以传递的字节输入流： FileInputStream * InputStreamReader(InputStream in,String charsetName) 传递编码表的名字 * b: 图解 * 详见day24_source/转换流.JPG图片05InputSteamReader读取文本文件
* A: InputSteamReader读取文本文件 * a: 案例代码 public class InputStreamReaderDemo { public static void main(String[] args) throws IOException { // readGBK(); readUTF(); } /* * 转换流,InputSteamReader读取文本 * 采用UTF-8编码表,读取文件utf */ public static void readUTF()throws IOException{ //创建自己输入流,传递文本文件 FileInputStream fis = new FileInputStream("c:\\utf.txt"); //创建转换流对象,构造方法中,包装字节输入流,同时写编码表名 InputStreamReader isr = new InputStreamReader(fis,"UTF-8"); char[] ch = new char[1024]; int len = isr.read(ch); System.out.println(new String(ch,0,len)); isr.close(); } /* * 转换流,InputSteamReader读取文本 * 采用系统默认编码表,读取GBK文件 */ public static void readGBK()throws IOException{ //创建自己输入流,传递文本文件 FileInputStream fis = new FileInputStream("c:\\gbk.txt"); //创建转换流对象,构造方法,包装字节输入流 InputStreamReader isr = new InputStreamReader(fis); char[] ch = new char[1024]; int len = isr.read(ch); System.out.println(new String(ch,0,len)); isr.close(); } }06转换流子类父类的区别
* A: 转换流子类父类的区别 * a: 继承关系 OutputStreamWriter: |--FileWriter: InputStreamReader: |--FileReader; * b: 区别 * OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。 * FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。 当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。 * 以下三句话功能相同 * InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。 * InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。 * FileReader fr = new FileReader("a.txt");07缓冲流概述
* A: 缓冲流概述 * a: 概述 * 可提高IO流的读写速度 * 分为字节缓冲流与字符缓冲流 08字节输出流缓冲流BufferedOutputStream
* A: 字节输出流缓冲流BufferedOutputStream * a: BufferedOutputStream * 字节输出流的缓冲流 * java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率 * BufferedOuputStream 继承 OutputStream * 方法,写入 write 字节,字节数组 * 构造方法: * BufferedOuputStream(OuputStream out) * 可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率 * b: 案例代码 public class BufferedOutputStreamDemo { public static void main(String[] args)throws IOException { //创建字节输出流,绑定文件 //FileOutputStream fos = new FileOutputStream("c:\\buffer.txt"); //创建字节输出流缓冲流的对象,构造方法中,传递字节输出流 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c:\\buffer.txt")); bos.write(55); byte[] bytes = "HelloWorld".getBytes(); bos.write(bytes); bos.write(bytes, 3, 2); bos.close(); } }09字节输入流缓冲流BufferedInputStream
* A: 字节输入流缓冲流BufferedInputStream * a: BufferedInputStream * 字节输入流的缓冲流 * 继承InputStream,标准的字节输入流 * 读取方法 read() 单个字节,字节数组 * 构造方法: * BufferedInputStream(InputStream in) * 可以传递任意的字节输入流,传递是谁,就提高谁的效率 * 可以传递的字节输入流 FileInputStream * b: 案例代码 public class BufferedInputStreamDemo { public static void main(String[] args) throws IOException{ //创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:\\buffer.txt")); byte[] bytes = new byte[10]; int len = 0 ; while((len = bis.read(bytes))!=-1){ System.out.print(new String(bytes,0,len)); } bis.close(); } }10四种文件复制方式的效率比较
* A：四种文件复制方式的效率比较 * a: 四中复制方式 * 字节流读写单个字节 125250 毫秒 * 字节流读写字节数组 193 毫秒 OK * 字节流缓冲区流读写单个字节 1210 毫秒 * 字节流缓冲区流读写字节数组 73 毫秒 OK * b: 案例代码 public class Copy { public static void main(String[] args)throws IOException { long s = System.currentTimeMillis(); copy_4(new File("c:\\q.exe"), new File("d:\\q.exe")); long e = System.currentTimeMillis(); System.out.println(e-s); } /* * 方法,实现文件复制 * 4. 字节流缓冲区流读写字节数组 */ public static void copy_4(File src,File desc)throws IOException{ BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src)); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc)); int len = 0 ; byte[] bytes = new byte[1024]; while((len = bis.read(bytes))!=-1){ bos.write(bytes,0,len); } bos.close(); bis.close(); } /* * 方法,实现文件复制 * 3. 字节流缓冲区流读写单个字节 */ public static void copy_3(File src,File desc)throws IOException{ BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src)); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc)); int len = 0 ; while((len = bis.read())!=-1){ bos.write(len); } bos.close(); bis.close(); } /* * 方法,实现文件复制 * 2. 字节流读写字节数组 */ public static void copy_2(File src,File desc)throws IOException{ FileInputStream fis = new FileInputStream(src); FileOutputStream fos = new FileOutputStream(desc); int len = 0 ; byte[] bytes = new byte[1024]; while((len = fis.read(bytes))!=-1){ fos.write(bytes,0,len); } fos.close(); fis.close(); } /* * 方法,实现文件复制 * 1. 字节流读写单个字节 */ public static void copy_1(File src,File desc)throws IOException{ FileInputStream fis = new FileInputStream(src); FileOutputStream fos = new FileOutputStream(desc); int len = 0 ; while((len = fis.read())!=-1){ fos.write(len); } fos.close(); fis.close(); } }11字符输出流缓冲流BufferedWriter
* A: 字符输出流缓冲流BufferedWriter * a: BufferedWriter * 字符输出流缓冲区流 * java.io.BufferedWriter 继承 Writer * 写入方法 write () 单个字符,字符数组,字符串 * 构造方法: * BufferedWriter(Writer w)传递任意字符输出流 * 传递谁,就高效谁 * 能传递的字符输出流 FileWriter, OutputStreamWriter * b: 案例代码 public class BufferedWrierDemo { public static void main(String[] args) throws IOException{ //创建字符输出流,封装文件 FileWriter fw = new FileWriter("c:\\buffer.txt"); BufferedWriter bfw = new BufferedWriter(fw); bfw.write(100); bfw.flush(); bfw.write("你好".toCharArray()); bfw.flush(); bfw.write("你好"); bfw.flush(); bfw.write("我好好"); bfw.flush(); bfw.write("大家都好"); bfw.flush(); bfw.close(); } }12字符输出流缓冲流BufferedWriter特有方法newLine
* A: 字符输出流缓冲流BufferedWriter特有方法newLine * a: 方法介绍 * void newLine() 写换行 * newLine()文本中换行, \r\n也是文本换行 * 方法具有平台无关性 * Windows \r\n * Linux \n * newLine()运行结果,和操作系统是相互关系 * JVM: 安装的是Windows版本,newLine()写的就是\r\n * 安装的是Linux版本,newLine()写的就是\n /* * 将数据源 c:\\a.txt * 复制到 d:\\a.txt 数据目的 * 字节输入流,绑定数据源 * 字节输出流,绑定数据目的 * * 输入,读取1个字节 * 输出,写1个字节 */ * b: 案例代码 public class BufferedWrierDemo { public static void main(String[] args) throws IOException{ //创建字符输出流,封装文件 FileWriter fw = new FileWriter("c:\\buffer.txt"); BufferedWriter bfw = new BufferedWriter(fw); bfw.write(100); bfw.flush(); bfw.write("你好".toCharArray()); bfw.flush(); bfw.write("你好"); bfw.newLine(); bfw.flush(); bfw.write("我好好"); bfw.newLine(); bfw.flush(); bfw.write("大家都好"); bfw.flush(); bfw.close(); } }13字符输入流缓冲流BufferedReader
* A: 字符输入流缓冲流BufferedReader * a: 概述 * 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取 * public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null14字符输入流缓冲流BufferedReader读取文本行
* A: 字符输入流缓冲流BufferedReader读取文本行 * a: BufferedReader * 字符输入流缓冲流 * java.io.BufferedReader 继承 Reader * 读取功能 read() 单个字符,字符数组 * 构造方法: * BufferedReader(Reader r) * 可以任意的字符输入流 FileReader InputStreamReader * BufferedReader自己的功能 * String readLine() 读取文本行 \r\n * 方法读取到流末尾,返回null * b: 小特点 * 获取内容的方法一般都有返回值 * int 没有返回的都是负数 * 引用类型 找不到返回null * boolean 找不到返回false * c: 案例代码 public class BufferedReaderDemo { public static void main(String[] args) throws IOException { int lineNumber = 0; //创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件 BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt")); //调用缓冲流的方法 readLine()读取文本行 //循环读取文本行, 结束条件 readLine()返回null String line = null; while((line = bfr.readLine())!=null){ lineNumber++; System.out.println(lineNumber+" "+line); } bfr.close(); } } /* * String line = bfr.readLine(); System.out.println(line); line = bfr.readLine(); System.out.println(line); line = bfr.readLine(); System.out.println(line); line = bfr.readLine(); System.out.println(line); line = bfr.readLine(); System.out.println(line); */15字符流缓冲区流复制文本文件
* A: 字符流缓冲区流复制文本文件 * a: 案例代码 /* * 使用缓冲区流对象,复制文本文件 * 数据源 BufferedReader+FileReader 读取 * 数据目的 BufferedWriter+FileWriter 写入 * 读取文本行, 读一行,写一行,写换行 */ public class Copy_1 { public static void main(String[] args) throws IOException{ BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log")); BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log")); //读取文本行, 读一行,写一行,写换行 String line = null; while((line = bfr.readLine())!=null){ bfw.write(line); bfw.newLine(); bfw.flush(); } bfw.close(); bfr.close(); } }16IO流对象的操作规律
* A: IO流对象的操作规律 * a: 明确一：要操作的数据是数据源还是数据目的。 * 源：InputStream Reader * 目的：OutputStream Writer * 先根据需求明确要读，还是要写。 * b: 明确二：要操作的数据是字节还是文本呢？ * 源： * 字节：InputStream * 文本：Reader * 目的： * 字节：OutputStream * 文本：Writer * c: 明确三：明确数据所在的具体设备。 * 源设备： * 硬盘：文件 File开头。 * 内存：数组，字符串。 * 键盘：System.in; * 网络：Socket * 目的设备： * 硬盘：文件 File开头。 * 内存：数组，字符串。 * 屏幕：System.out * 网络：Socket * 完全可以明确具体要使用哪个流对象。 * d: 明确四：是否需要额外功能呢？ * 额外功能： * 转换吗？转换流。InputStreamReader OutputStreamWriter * 高效吗？缓冲区对象。BufferedXXX * 已经明确到了具体的体系上。01Properties集合的特点
* A: Properties集合的特点 * a: Properties类介绍 * Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串 * b: 特点 * Hashtable的子类，map集合中的方法都可以用。 * 该集合没有泛型。键值都是字符串。 * 它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。 * 有和流技术相结合的方法。 * c: 方法介绍 * load(InputStream inputStream) 把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中 * load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对） * store(OutputStream outputStream,String commonts) 把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息 * stroe(Writer writer,String comments) 以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符02Properties集合存储键值对
* A: Properties集合存储键值对 * a: 方法介绍 * 集合对象Properties类,继承Hashtable,实现Map接口 * 可以和IO对象结合使用,实现数据的持久存储 * 使用Properties集合,存储键值对 * setProperty等同与Map接口中的put * setProperty(String key, String value) * 通过键获取值, getProperty(String key) * b: 案例代码 public class PropertiesDemo { public static void main(String[] args)throws IOException { function_2(); } /* * 使用Properties集合,存储键值对 * setProperty等同与Map接口中的put * setProperty(String key, String value) * 通过键获取值, getProperty(String key) */ public static void function(){ Properties pro = new Properties(); pro.setProperty("a", "1"); pro.setProperty("b", "2"); pro.setProperty("c", "3"); System.out.println(pro); String value = pro.getProperty("c"); System.out.println(value); //方法stringPropertyNames,将集合中的键存储到Set集合,类似于Map接口的方法keySet Set<String> set = pro.stringPropertyNames(); for(String key : set){ System.out.println(key+"..."+pro.getProperty(key)); } } }03Properties集合的方法load
* A: Properties集合的方法load * a: 方法介绍 * Properties集合特有方法 load * load(InputStream in) * load(Reader r) * 传递任意的字节或者字符输入流 * 流对象读取文件中的键值对,保存到集合 * b: 案例代码 public class PropertiesDemo { public static void main(String[] args)throws IOException { function_1(); } /* * Properties集合特有方法 load * load(InputStream in) * load(Reader r) * 传递任意的字节或者字符输入流 * 流对象读取文件中的键值对,保存到集合 */ public static void function_1()throws IOException{ Properties pro = new Properties(); FileReader fr = new FileReader("c:\\pro.properties"); //调用集合的方法load,传递字符输入流 pro.load(fr); fr.close(); System.out.println(pro); } }04Properties集合的方法store
* A: Properties集合的方法store * a: 方法介绍 * Properties集合的特有方法store * store(OutputStream out) * store(Writer w) * 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存 * b: 案例代码 public class PropertiesDemo { public static void main(String[] args)throws IOException { function_2(); } /* * Properties集合的特有方法store * store(OutputStream out) * store(Writer w) * 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存 */ public static void function_2()throws IOException{ Properties pro = new Properties(); pro.setProperty("name", "zhangsan"); pro.setProperty("age", "31"); pro.setProperty("email", "123456789@163.com"); FileWriter fw = new FileWriter("c:\\pro.properties"); //键值对,存回文件,使用集合的方法store传递字符输出流 pro.store(fw, ""); fw.close(); } }05对象的序列化与反序列化
* A: 对象的序列化与反序列化 * a: 基本概念 * 对象的序列化 * 对象中的数据，以流的形式，写入到文件中保存过程称为写出对象，对象的序列化 * ObjectOutputStream将对象写道文件中，实现序列化 * 对象的反序列化 * 在文件中，以流的形式，将对象读出来，读取对象，对象的反序列化 * ObjectInputStream 将文件对象读取出来06ObjectOutputStream流写对象
* A: ObjectOutputStream流写对象 * a: 简单介绍 * IO流对象,实现对象Person序列化,和反序列化 * ObjectOutputStream 写对象,实现序列化 * ObjectInputStream 读取对象,实现反序列化 * b: 案例代码 public class Person implements Serializable{ public String name; public int age; public Person(String name, int age) { super(); this.name = name; this.age = age; } public Person(){} public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } } public class ObjectStreamDemo { public static void main(String[] args)throws IOException, ClassNotFoundException { // writeObject(); readObject(); } /* * ObjectOutputStream * 构造方法: ObjectOutputStream(OutputSteam out) * 传递任意的字节输出流 * void writeObject(Object obj)写出对象的方法 */ public static void writeObject() throws IOException{ //创建字节输出流,封装文件 FileOutputStream fos = new FileOutputStream("c:\\person.txt"); //创建写出对象的序列化流的对象,构造方法传递字节输出流 ObjectOutputStream oos = new ObjectOutputStream(fos); Person p = new Person("lisi",25); //调用序列化流的方法writeObject,写出对象 oos.writeObject(p); oos.close(); } }07ObjectInputStream流读取对象
* A: ObjectInputStream流读取对象 * a: 简单介绍 * ObjectInputStream * 构造方法:ObjectInputStream(InputStream in) * 传递任意的字节输入流,输入流封装文件,必须是序列化的文件 * Object readObject() 读取对象 * b: 案例代码 /* * IO流对象,实现对象Person序列化,和反序列化 * ObjectOutputStream 写对象,实现序列化 * ObjectInputStream 读取对象,实现反序列化 */ public class ObjectStreamDemo { public static void main(String[] args)throws IOException, ClassNotFoundException { readObject(); } /* * ObjectInputStream * 构造方法:ObjectInputStream(InputStream in) * 传递任意的字节输入流,输入流封装文件,必须是序列化的文件 * Object readObject() 读取对象 */ public static void readObject() throws IOException, ClassNotFoundException{ FileInputStream fis = new FileInputStream("c:\\person.txt"); //创建反序列化流,构造方法中,传递字节输入流 ObjectInputStream ois = new ObjectInputStream(fis); //调用反序列化流的方法 readObject()读取对象 Object obj =ois.readObject(); System.out.println(obj); ois.close(); } }08静态不能序列化
* A: 静态不能序列化 * a: 原因 * 序列化是把对象数据进行持久化存储 * 静态的东西不属于对象，而属于类09transient关键字
* A: transient关键字 * a: 作用 * 被transient修饰的属性不会被序列化 * transient关键字只能修饰成员变量10Serializable接口的含义
* A：Serializable接口的含义 * a: 作用 * 给需要序列化的类上加标记。该标记中没有任何抽象方法 * 只有实现了 Serializable接口的类的对象才能被序列化11序列化中的序列号冲突问题
* A: 序列化中的序列号冲突问题 * a: 问题产生原因 * 当一个类实现Serializable接口后，创建对象并将对象写入文件，之后更改了源代码(比如：将成员变量的修饰符有private改成public)， 再次从文件中读取对象时会报异常 * 见day25_source文件夹下的"序列号的冲突.JPG"文件12序列化中自定义的序列号
* A: 序列化中自定义的序列号 * a: 定义方式 * private static final long serialVersionUID = 1478652478456L; * 这样每次编译类时生成的serialVersionUID值都是固定的 * b: 案例代码 public class Person implements Serializable{ public String name; public /*transient阻止成员变量序列化*/ int age; //类,自定义了序列号,编译器不会计算序列号 private static final long serialVersionUID = 1478652478456L; public Person(String name, int age) { super(); this.name = name; this.age = age; } public Person(){} public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } }13打印流和特性
* A: 打印流和特性 * a: 概述 * 打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式. * 打印流根据流的分类： * 字节打印流 PrintStream * 字符打印流 PrintWriter * 方法： * void print(String str): 输出任意类型的数据， * void println(String str): 输出任意类型的数据，自动写入换行操作 * b: 特点 * 此流不负责数据源,只负责数据目的 * 为其他输出流,添加功能 * 永远不会抛出IOException，但是可能抛出别的异常 * 两个打印流的方法,完全一致 * 构造方法,就是打印流的输出目的端 * PrintStream构造方法 * 接收File类型,接收字符串文件名,接收字节输出流OutputStream * PrintWriter构造方法 * 接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer14打印流输出目的是File对象
* A: 打印流输出目的是File对象 * a: 案例代码 public class PrintWriterDemo { public static void main(String[] args) throws IOException { function_3(); } /* * 打印流,向File对象的数据目的写入数据 * 方法print println 原样输出 * write方法走码表 */ public static void function() throws FileNotFoundException{ File file = new File("c:\\1.txt"); PrintWriter pw = new PrintWriter(file); pw.println(true); pw.write(100); pw.close(); } }15输出语句是char数组
* A: 输出语句是char数组 * a: 案例代码 public class Demo { public static void main(String[] args) { int[] arr = {1}; System.out.println(arr); char[] ch = {'a','b'}; System.out.println(ch); byte[] b = {}; System.out.println(b); } } * b: 结果分析 * println数组，只有打印字符数组时只有容，其余均打印数组的地址 * 因为api中定义了打印字符数组的方法，其底层是在遍历数组中的元素 * 而其他打印数组的方法，都是将数组对象编程Object，其底层再将对象编程String，调用了String s = String.valueOf(x);方法16打印流输出目的是String和流对象
* A: 打印流输出目的是String和流对象 * a: 案例代码 public class PrintWriterDemo { public static void main(String[] args) throws IOException { function_2(); } /* * 打印流,输出目的,是流对象 * 可以是字节输出流,可以是字符的输出流 * OutputStream Writer */ public static void function_2() throws IOException{ // FileOutputStream fos = new FileOutputStream("c:\\3.txt"); FileWriter fw = new FileWriter("c:\\4.txt"); PrintWriter pw = new PrintWriter(fw); pw.println("打印流"); pw.close(); } /* * 打印流,输出目的,String文件名 */ public static void function_1() throws FileNotFoundException{ PrintWriter pw = new PrintWriter("c:\\2.txt"); pw.println(3.5); pw.close(); } }17打印流开启自动刷新
* A: 打印流开启自动刷新 * 案例代码 public class PrintWriterDemo { public static void main(String[] args) throws IOException { function_3(); } /* * 打印流,可以开启自动刷新功能 * 满足2个条件: * 1. 输出的数据目的必须是流对象 * OutputStream Writer * 2. 必须调用println,printf,format三个方法中的一个,启用自动刷新 */ public static void function_3()throws IOException{ //File f = new File("XXX.txt"); FileOutputStream fos = new FileOutputStream("c:\\5.txt"); PrintWriter pw = new PrintWriter(fos,true); pw.println("i"); pw.println("love"); pw.println("java"); pw.close(); } }18打印流复制文本文件
* A: 打印流复制文本文件 * a: 案例代码 /* * 打印流实现文本复制 * 读取数据源 BufferedReader+File 读取文本行 * 写入数据目的 PrintWriter+println 自动刷新 */ public class PrintWriterDemo1 { public static void main(String[] args) throws IOException{ BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt")); PrintWriter pw = new PrintWriter(new FileWriter("d:\\a.txt"),true); String line = null; while((line = bfr.readLine())!=null){ pw.println(line); } pw.close(); bfr.close(); } }19commons-io工具类介绍
* A: commons-io工具类介绍 * a: 工具类介绍 * 解压缩commons-io-2.4.zip文件 * commons-io-2.4.jar需要导入到项目中的jar包，里面存放的是class文件 * commons-io-2.4-sources.jar工具类中原代码 * docs是帮助文档20使用工具类commons_io
* A: 使用工具类commons_io * a: 导入jar包 * 加入classpath的第三方jar包内的class文件才能在项目中使用 * 创建lib文件夹 * 将commons-io.jar拷贝到lib文件夹 * 右键点击commons-io.jar，Build Path→Add to Build Path * b: 学会如何看源代码21IO工具类FilenameUtils
* A: IO工具类FilenameUtils * a: 方法介绍 * getExtension(String path)：获取文件的扩展名； * getName()：获取文件名； * isExtension(String fileName,String ext)：判断fileName是否是ext后缀名； * b: 案例代码 public class Commons_IODemo { public static void main(String[] args) { function_2(); } /* * FilenameUtils类的方法 * static boolean isExtension(String filename,String extension) * 判断文件名的后缀是不是extension */ public static void function_2(){ boolean b = FilenameUtils.isExtension("Demo.java", "java"); System.out.println(b); } /* * FilenameUtils类的方法 * static String getName(String filename) * 获取文件名 */ public static void function_1(){ String name = FilenameUtils.getName("c:\\windows\\"); System.out.println(name); } /* * FilenameUtils类的方法 * static String getExtension(String filename) * 获取文件名的扩展名 */ public static void function(){ String name = FilenameUtils.getExtension("c:\\windows"); System.out.println(name); } }22IO工具类FileUtils
* A: IO工具类FileUtils * a: 方法介绍 * readFileToString(File file)：读取文件内容，并返回一个String； * writeStringToFile(File file，String content)：将内容content写入到file中； * copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制 * copyFile(File srcFile,File destFile);文件复制 * b: 案例代码 public class Commons_IODemo1 { public static void main(String[] args)throws IOException { function_3(); } /* * FileUtils工具类方法 * static void copyDirectoryToDirectory(File src,File desc) * 复制文件夹 */ public static void function_3() throws IOException{ FileUtils.copyDirectoryToDirectory(new File("d:\\demo"), new File("c:\\")); } /* * FileUtils工具类的方法 * static void copyFile(File src,File desc) * 复制文件 */ public static void function_2() throws IOException{ FileUtils.copyFile(new File("c:\\k.jpg"),new File("d:\\k.jpg")); } /* * FileUtils工具类的方法 * static void writeStringToFile(File src,String date) * 将字符串直接写到文件中 */ public static void function_1() throws IOException{ FileUtils.writeStringToFile(new File("c:\\b.txt"),"我爱Java编程"); } /* * FileUtils工具类的方法 * static String readFileToString(File src)读取文本,返回字符串 */ public static void function() throws IOException{ String s = FileUtils.readFileToString(new File("c:\\a.txt")); System.out.println(s); } }1
======================第四节课开始=========
阅读全文
0 0
- (二十五)基础系列 io流
- (二十五)基础系列 入门
- (二十五)基础系列 多线程
- (二十五)基础系列 数据库
- (二十五)基础系列 面向对象
- (二十五)基础系列 API和集合
- (二十五)基础系列 socket 与xml
- (二十五)基础系列 JSP/JSTL/EL
- (二十五)基础系列 AJAX、JQuery
- Java基础<十五>---> IO
- IO流系列(二)
- java基础/IO流(二)
- ZYNQ基础系列（二） IO口模拟HDMI
- C#基础二十五问
- C#基础二十五问
- C#基础二十五问
- C#基础二十五问
- C#基础概念二十五问 --【C#网文收集系列】
- scrapy安装
- Unity3D
- java开发微信端获取code和opendId，access_token,用户列表
- python学习—Day33—综合复习第二弹
- NLP15-基于keras的中文情感挖掘试探
- (二十五)基础系列 io流
- 归并排序——史上最详细图解教程！！！
- NYACM_009
- 微服务：基本介绍
- main()函数执行完后，还会调用执行其他的语句吗？
- Hadoop默认模式、默认配置问题
- 创建控制台应用程序
- 一组数据中只有一个数字出现了一次。其他所有数字都是成对出现的。 请找出这个数字。
- 数组的几种常见排序方式总结(Java程序)
