java：IO流（File，字节流/输入输出流（InputStream（FileInputStream），OutputStream（FileOutStream）），字符流（Reader，Writer））
File：
* java.io.File类:代表一个文件或目录。
* 常用的构造方法:
* File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
* File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
* File(File parent, String child)根据 parent对象 和 child 路径名字符串创建一个新 File 实例。
*
* 常用方法1:
* getName()返回由此抽象路径名表示的文件或目录的名称。
* getPath()将此抽象路径名转换为一个路径名字符串。
* isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
* isDirectory()测试此抽象路径名表示的文件是否是一个目录。
* length() 返回由此抽象路径名表示的文件的长度。目录是没有大小。
* canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
* canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
* canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
* exists()测试此抽象路径名表示的文件或目录是否存在。
* mkdir()创建此抽象路径名指定的目录。只能创建一级目录(父目录必须存在)
* mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
* createNewFile()当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
* delete()删除此抽象路径名表示的文件或目录，如果都是文件夹则删除最下级空文件夹，如果文件夹包含文件，则谁也不删除。
* 注意:java中'\'字符是转义符，如果利用'\'表示路径必须写出"\\"
import java.io.File; import java.io.IOException; public class TestFile { public static void main(String[] args) { // File file = new File("D:\\code\\day6\\TestArray.java"); // File file = new File("D:/code/day6/TestArray.java"); File file = new File("D:/code/day6","TestArray.java"); System.out.println("文件名称:"+file.getName()); System.out.println("文件路径:"+file.getPath()); System.out.println("File对象是否表示文件:"+file.isFile()); System.out.println("File对象是否表示目录:"+file.isDirectory()); System.out.println("文件的大小:"+file.length()+"字节"); System.out.println("该文件是否可执行:"+file.canExecute()); System.out.println("该文件是否可读:"+file.canRead()); System.out.println("该文件是否可写:"+file.canWrite()); System.out.println("该文件是否存在:"+file.exists()); System.out.println("------------------------------"); File file2 = new File("D:/test/aa/bb"); if(!file2.exists()){ // file2.mkdir();//创建目录 file2.mkdirs();//创建多级目录 System.out.println("目录创建成功!"); } File file3 = new File(file2,"aa.txt"); try { if(!file3.exists()){ file3.createNewFile();//创建文件 } } catch (IOException e) { e.printStackTrace(); } //删除文件 file3.delete(); //删除目录 file2.delete(); } }
*File类中的常用方法2:
* File[] listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
* lastModified()返回此抽象路径名表示的文件最后一次被修改的时间。
*需求:模拟Dos命令中的dir命令，输出D:\code目录下所有子目录或子文件的名称
2017/05/31 18:13 <DIR> day6
2017/06/01 17:28 <DIR> day7
2017/06/01 17:49 12,941 day7.zip
import java.io.File; import java.text.SimpleDateFormat; import java.util.Date; public class TestFile2 { public static void main(String[] args) { File file = new File("D:/code"); File[] subFiles = file.listFiles();//获取子文件或子目录 for (File f : subFiles) { StringBuffer sb=new StringBuffer(); long time = f.lastModified();//获取文件的最后修改时间 Date date = new Date(time); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); String dateStr = sdf.format(date); sb.append(dateStr+"\t");//2017/05/31 18:13 //判断是否为目录 if(f.isDirectory()){ sb.append("<DIR>\t\t"); } //判断是否为文件 if(f.isFile()){ long fileSize = f.length();//获取文件大小 sb.append("\t"+fileSize+"\t"); } //获取文件名称 String fileName = f.getName(); sb.append(fileName); System.out.println(sb); } } }
* 需求:输出某个目录下的所有子目录或子文件的路径
* 递归算法:将复杂的问题分解成若干个相同的子问题进行解决。
import java.io.File; public class TestFile3 { public static void showPath(File file){ File[] fs = file.listFiles();//获取指定目录下所有的直接子目录或子文件。 for (File f : fs) { if(f.isDirectory()){ String path = f.getAbsolutePath(); System.out.println(path); showPath(f);//递归调用 }else{ String path = f.getAbsolutePath(); System.out.println(path); } } } public static void main(String[] args) { File file = new File("D:/test"); showPath(file); } }
*数据源:原始数据的源头。
*流的分类
*1.按照方向可以分为:输入流和输出流(相对于应用程序来说).
* 输入流:数据源--->应用程序(磁盘或网络)
* 输出流 :应用程序--->数据源
*2.按照读写单位来分:字节流和字符流
* 字节流:每次读写1个字节。
* 字符流:每次读写1个字符。
*3.按照功能来分:节点流和处理流
* 节点流:能直接操作数据源或目的地的流。
* 处理流:不能直接操作数据源或目的地(不能单独使用)，处理流必须与节点流结合使用，其主要作用是简化流的操作和提高流的读写效率。
*
*字节流:InputStream(字节输入流)/OutputStream(字节输出流)
* java.io.InputStream类:抽象类
* --java.io.FileInputStream类:继承了InputStream，从文件系统中的某个文件中获得输入字节。
* 常用的构造方法:
* FileInputStream(File file):通过打开一个到实际文件的连接来创建一个 FileInputStream
* FileInputStream(String name): 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
* 常用的方法:
* read()从此输入流中读取一个数据字节。
* read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
* read(byte[] b, int off, int len) 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
* close()关闭此文件输入流并释放与此流有关的所有系统资源。
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class TestInputStream { public static void main(String[] args) { FileInputStream fis =null; try { // File file = new File("D:/test/aa.txt"); // FileInputStream fis = new FileInputStream(file); fis = new FileInputStream("D:/test/aa.txt"); int i; while((i=fis.read())!=-1){ char c=(char)i; System.out.print(c); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } }
FileInputStream输入方法2：
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 *String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 */ public class TestInputStream2 { public static void main(String[] args) { FileInputStream fis =null; try { fis = new FileInputStream("D:/test/aa.txt"); byte[] bs = new byte[1024];//用于保存从输入流读取的字节 fis.read(bs); String content = new String(bs); System.out.println(content); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } }
FileInputStream输入方法3：
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * read(byte[] b, int off, int len)从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。 * String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 */ public class TestInputStream3 { public static void main(String[] args) { FileInputStream fis =null; try { File file = new File("D:/test/aa.txt"); fis = new FileInputStream(file); byte[] bs = new byte[1024];//用于保存从输入流读取的字节 int len = fis.read(bs,0,bs.length); String content = new String(bs,0,len);//不同！！！ System.out.println(content); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } }
FileOutStream输出方法：
*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
*
*常用的方法:
* write(int b)将指定字节写入此文件输出流。
* write(byte[] b)将 b.length 个字节从指定 byte 数组写入此文件输出流中。
* write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
* close()关闭此文件输出流并释放与此流有关的所有系统资源。
import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class TestOutputStream { public static void main(String[] args) { File file = new File("D:/test/aa.txt"); FileOutputStream fos=null; try { // fos = new FileOutputStream(file); // fos = new FileOutputStream("D:/test/aa.txt"); // fos = new FileOutputStream(file, true);//是否追加 fos = new FileOutputStream("D:/test/aa.txt", true); fos.write('z'); fos.write('z'); fos.write('s'); fos.write('x'); fos.write('t'); fos.write('!'); System.out.println("写入完成!"); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } }
*需求:将D:/mp3/test.mp3复制到F:/test.mp3
*分析:
*1.使用字节输入流FileInputStream读取D:/mp3/test.mp3文件
*2.使用字节输出流FileOutputStream写入F:/test.mp3文件中
//复制的时候，输入和输入的后缀名必须相同：
//复制的时候，只能复制文件，文件夹不能复制！必须得创建
方法1：
fis=new FileInputStream("D:/kuang/cc/Notepad_6.4.5.exe");
fos=new FileOutputStream("D:/kuang/cc/zz/12231.exe"); //后面加true时，TXT文件，exe，jpg，文件都会追加
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileCopy { public static void main(String[] args) { FileInputStream fis=null; FileOutputStream fos=null; try { fis = new FileInputStream("D:/mp3/test.mp3"); fos = new FileOutputStream("F:/test.mp3"); //1.使用输入流读取文件 int i; while((i=fis.read())!=-1){ fos.write(i); } System.out.println("复制完毕!"); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); fos.close(); } catch (IOException e) { e.printStackTrace(); } } } }
方法2：
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileCopy2 { public static void main(String[] args) { FileInputStream fis=null; FileOutputStream fos=null; try { fis = new FileInputStream("D:/mp3/test.mp3"); fos = new FileOutputStream("F:/test.mp3"); //1.使用输入流读取文件 byte[] bs = new byte[1024]; int len; while((len=fis.read(bs,0,bs.length))!=-1){ //2.使用输出流写入目的地 fos.write(bs,0,len); } System.out.println("复制完毕!"); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); fos.close(); } catch (IOException e) { e.printStackTrace(); } } } }
FileOutputStream方法3:
*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
*
*常用的方法:
* write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
* close()关闭此文件输出流并释放与此流有关的所有系统资源。
*/
byte[] byt=new byte[1024]; int len; while((len=fis.reade(byt))!=-1){ fos.write(byt); //后面有大量空格，范围更大 }
FileOutputStream方法:
*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
* String类中的方法: byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
*常用的方法:
* write(byte[] b)将 b.length 个字节从指定 byte 数组写入此文件输出流中。
import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class TestOutputStream2 { public static void main(String[] args) { FileOutputStream fos=null; try { fos = new FileOutputStream("D:/test/aa.txt", true); String str="what are you name?"; fos.write(str.getBytes(),0,str.length()); System.out.println("写入完成!"); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } }
字符流：
*字符流:以字符为单位进行读写。Reader/Writer
*Reader(字符输入流):抽象类
*--InputStreamReader类:转换流属于处理流，将字节流转换字符流。
*----FileReader类:用来读取字符文件的便捷类。
* 常用的构造方法:
* FileReader(File file)在给定从中读取数据的 File 的情况下创建一个新 FileReader。
* FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新 FileReader。
* 常用的方法:
* read() 读取单个字符。
* read(char[] cbuf) 将字符读入数组。
* read(char[] cbuf, int offset, int length)将字符读入数组中的某一部分。
* close()关闭该流并释放与之关联的所有资源。
*
*String类
*String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
*String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TestReader3 { public static void main(String[] args) { File file = new File("F:/测试.txt"); FileReader fileReader=null; try { fileReader = new FileReader(file); char[] cs = new char[1024];//缓冲区 int len = fileReader.read(cs,0,cs.length); String str = new String(cs,0,len); System.out.println(str); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fileReader.close(); } catch (IOException e) { e.printStackTrace(); } } } }
String类
*String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TestReader2 { public static void main(String[] args) { File file = new File("F:/测试.txt"); FileReader fileReader=null; try { fileReader = new FileReader(file); char[] cs = new char[1024];//缓冲区 fileReader.read(cs); String str = new String(cs); System.out.println(str); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fileReader.close(); } catch (IOException e) { e.printStackTrace(); } } }
import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TestReader { public static void main(String[] args) { File file = new File("F:/测试.txt"); FileReader fileReader=null; try { fileReader = new FileReader(file); int i; while((i=fileReader.read())!=-1){ char c = (char)i; System.out.print(c); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fileReader.close(); } catch (IOException e) { e.printStackTrace(); } } } }
Homework：
1.使用字节流复制D:/mp3下所有文件和目录到到F:/mp3目录下（完成一个目录的复制）
2.使用字符流复制D:/test下所有的文件和目录到F:/test目录下，要求F盘符下如果没有test文件夹，进行自动创建。
eg：
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * 1.使用字节流复制D:/mp3下所有文件和目录到到F:/mp3目录下（完成一个目录的复制）--->复制整个目录(包含有文件和文件夹) * 分析: * 1.复制文件夹(使用递归获取目录结构和名称) * a.使用递归遍历该文件夹的所有文件或文件夹 * b.在目标位置创建同名的文件夹 * c.复制该文件到目标位置 * 2.复制文件 */ public class Homework { /** * 复制文件到目标位置 * @param source:源文件 * @param target:目的地 */ public void copyFile(File source,File target){ FileInputStream fis=null; FileOutputStream fos=null; try { fis = new FileInputStream(source);//将源文件转换为输入流 fos = new FileOutputStream(target);// 目的地 byte[] bs = new byte[1024];//缓冲区 int len; //使用输入流读取数据 while((len=fis.read(bs))!=-1){ //使用输出流写入数据 fos.write(bs, 0, len); } fos.flush();//刷新缓冲区 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { fis.close(); fos.close(); } catch (IOException e) { e.printStackTrace(); } } } /** * 复制整个目录到指定位置 * @param source: D:/mp3/test.mp3 * @param target: F:/mp3 */ public void copyDir(File source,File target){ //如果目标位置不存在，先创建目录 if(!target.exists()){ target.mkdirs(); } //遍历源文件的目录结构，如果是子目录在目的地创建相同名称目录，如果是子文件需要将该文件复制到目的地位置 File[] fs = source.listFiles(); for (File file : fs) { String fileName = file.getName(); File f = new File(target,fileName); //如果是文件，直接复制到目的地 if(file.isFile()){ copyFile(file,f); } //如果是目录,在目的地创建子目录 if(file.isDirectory()){ //创建目录 f.mkdirs(); //递归调用 copyDir(file,f); } } } public static void main(String[] args) { Homework homework = new Homework(); File source = new File("D:/mp3"); File target = new File("F:/mp3"); homework.copyDir(source,target); System.out.println("目录复制完成!"); } }
