File类与IO流
file类的静态成员变量(不同的操作系统不同的结果)
String pathSeparator = File.pathSeparator;//与系统有关的路径分隔符 String separator = File.separator;//与系统有关的默认名称分隔符 System.out.println(pathSeparator); System.out.println(separator);
------------------结果------------------
;
\
绝对路径和相对路径
绝对路径：一个完整的路径，以盘符开始的路径 F:\360MoveData\Users\lenovo\Desktop\1.基础班\1-8 File类与IO流 相对路径：一个简化的路径，相对于当前项目的根目录 简化为-->1-8 File类与IO流
file类的构造方法
File(File parent，String child)
根据parent抽象路径名和child路径名字符串创建一个新File实例
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新File实例
File(File parent，String child)
根据parent路径名字符串和child路径名字符串
file类获取功能的方法
File f1 = new File("D:\Probjectjava\webdemo\src\dict.txt"); //获取此文件的绝对路径字符串 System.out.println(f1.getAbsolutePath()); //将此文件转换为路径名字符串 System.out.println(f1.getPath()); //获取此文件的名称 System.out.println(f1.getName()); //获取此文件的文件长度 System.out.println(f1.length());
------------------结果------------------
D:\Probjectjava\webdemo\src\dict.txt
D:\Probjectjava\webdemo\src\dict.txt
dict.txt
13
file类判断功能的方法
File f1 = new File("D:\\Probjectjava\\webdemo\\src\\dict.txt"); //此文件夹是否存在 System.out.println(f1.exists()); //此file是否为目录 System.out.println(f1.isDirectory()); //此file是否为文件 System.out.println(f1.isFile());
------------------结果------------------
true
false
true
file类创建删除功能的方创建文件
File f1 = new File("src\\1.txt"); boolean b1 = f1.createNewFile(); System.out.println(b1); File f1 = new File("D:\\Probjectjava\\webdemo\\src\\1.txt"); boolean b1 = f1.createNewFile(); System.out.println(b1); 创建文件夹： File f1 = new File("src\\aaa"); boolean b1 = f1.mkdir(); System.out.println(b1); 创建多级文件夹 File f1 = new File("src\\aaa\\bbb"); boolean b1 = f1.mkdirs(); System.out.println(b1); 删除文件 File f1 = new File("src\\aaa"); boolean b1 = f1.delete(); System.out.println(b1);
file类遍历目录功能
返回文件名 File f1 = new File("src"); String[] list = f1.list(); for (String s : list) { System.out.println(s); } 返回文件路径 File f1 = new File("src"); File[] files = f1.listFiles(); for (File s : files) { System.out.println(s); }
字节输出流写多个字节的方法
字节输出流写多个字节的方法 FileOutputStream fos = new FileOutputStream(new File("src\\1.txt")); byte[] bytes = {65,66,67,68,69}; fos.write(bytes); //释放资源 fos.close(); 字节输出流量写单个字节的方法 FileOutputStream fos = new FileOutputStream(new File("src\\1.txt")); fos.write(46); //释放资源 fos.close(); 字节流输出字符 FileOutputStream fos = new FileOutputStream(new File("src\\1.txt")); byte[] bytes = "你好".getBytes("gbk"); fos.write(bytes); //释放资源 fos.close();
字节输出流的续写和换行
//续写 FileOutputStream fos = new FileOutputStream("src\\1.txt",true); byte[] bytes = "你好".getBytes("gbk"); fos.write(bytes); fos.close(); //换行 FileOutputStream fos = new FileOutputStream("src\\1.txt",true); byte[] bytes = "你好".getBytes("gbk"); fos.write(bytes); fos.write("\r\n".getBytes("gbk")); fos.close();
字节输入流读取字节数据
FileInputStream fis = new FileInputStream("src\\1.txt"); int len = 0; //读取到空白内容len = -1 while((len = fis.read())!= -1){ System.out.println((char)len); } //释放资源 fis.close();
文件的复制
//需要拷贝的文件 FileInputStream fis = new FileInputStream("文件名"); //拷贝完成的文件 FileOutputStream fos = new FileOutputStream("文件名"); //使用数组缓冲读取多个字节，写入多个字节 byte[] bytes = new byte[1024]; int len = 0; while((len = fis.read())!= -1){ fos.write(bytes,0,len); } fos.close(); fis.close();
使用字符输入流读取中文文件
FileReader fr = new FileReader("src\\1.txt"); int len = 0; while((len = fr.read())!= -1){ System.out.println((char) len); } fr.close();
------------------结果------------------
你
好
啊
a
b
c
文件1.txt文本内容
你好啊abc
FileReader fr = new FileReader("src\\1.txt"); int len = 0; char[] cs = new char[1024]; while((len = fr.read(cs))!= -1){ //把字符数组转化为字符串String(char[] value) //把字符数组的一部分转化为字符串 offset数组的开始索引 count转化的个数 System.out.println(new String(cs,0,len)); } //关闭资源 fr.close();
字符输出流写单个字符到文件
FileWriter fw = new FileWriter("src\\1.txt"); fw.write(97); //必须刷新或者关闭资源才能写入文件，刷新之后fw可以继续使用，close之后fw不能继续使用 fw.flush(); fw.close();
字符输出流写数据
FileWriter fw = new FileWriter("src\\1.txt"); char[] cs = {'a','b','c',}; //写入字符数组 fw.write(cs); 写入字符数组的某一部分 fw.write(cs,1,2); //关闭资源 fw.close();
字节输出流的续写和换行
FileWriter fw = new FileWriter("src\\1.txt",true);//后面加true续写 for (int i = 0;i < 10;i++){ fw.write("hello"+"\r\n"); } fw.close();
//换行符号
windows：\r\n
linux:/n
mac:/r
使用try catch finally处理流中的异常
//提高fw的作用域 //变量在定义的时候可以没有值，但是使用的时候必须有值 FileWriter fw = null; try { //可能产生异常的代码 fw = new FileWriter("src\\1.txt",true); for (int i = 0;i < 10;i++){ fw.write("hello"+"\r\n"); } } catch (IOException e){ //异常处理逻辑 System.out.println(e); } finally { //一定会指定的代码 //创建对象失败，fw默认值就是null,null是不能调用方法的，会抛出nullpointerexception，需要增加一个判断，不是null在把资源释放 if (fw == null){ try { //fw。close方法声明抛出ioexceptio异常对象，所以我们就处理这个异常对象，要么throw，要么try catch fw.close(); } catch (IOException e) { e.printStackTrace(); } } }
使用properties集合存储数据，遍历取出properties集合中的数据
//创建properties对象 Properties prop = new Properties(); //使用setproperties添加数据 prop.setProperty("a","165"); prop.setProperty("b","140"); prop.setProperty("c","180"); //使用stringpropertiesnames把properties集合中的键取出，存储到一个set集合中 Set<String> set = prop.stringPropertyNames(); //遍历set集合 for (String key : set) { String value = prop.getProperty(key); System.out.println(key+value); }
properties集合中的方法store
//创建properties对象 Properties prop = new Properties(); //使用setproperties添加数据 prop.setProperty("a","165"); prop.setProperty("b","140"); prop.setProperty("c","180"); //创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地 FileWriter fw = new FileWriter("src\\1.txt"); //使用properties集合中的方法sore，把集合的临时数据，持久写入到硬盘中存储 prop.store(fw,"save date");
fw.close();
properties集合中的方法load
//创建properties对象 Properties prop = new Properties(); //使用properties集合对象中的load方法读取保存键值的文件 prop.load(new FileReader("src\\1.txt")); //遍历集合 Set<String> set = prop.stringPropertyNames(); for (String key : set) { String value = prop.getProperty(key); System.out.println(key+"="+value); }
bufferoutputstrem字节缓冲输出流
//1.创建fileoutputstrem对象，构造方法中绑定输出的的目的地 FileOutputStream fos = new FileOutputStream("src\\1.txt"); //2.创建bufferedoutputstrem对象，构造方法中传递fileoutputstrem对象，提高outputstrem对象效率 BufferedOutputStream bos = new BufferedOutputStream(fos); //3.使用bufferedoutputstrem对象的方法write，把数据写入到内部缓冲区 bos.write("我把数据写入到内部缓冲区".getBytes("gbk")); //4.使用bufferedoutputstrem对象中的flush方法，把内部缓冲区的数据，刷新到文件中 bos.flush(); //5.释放资源 bos.close();
bufferoutputstrem字节缓冲输入流
//1.创建fileinputstrem对象，构造方法中绑定输出的的目的地 FileInputStream fis = new FileInputStream("src\\1.txt"); //2.创建bufferedinputstrem对象，构造方法中传递fileinputstrem对象，提高fileinputstrem对象效率 BufferedInputStream bis = new BufferedInputStream(fis); //3.记录每次读取的有效字节个数 int len = 0; //4.从输入流中读取一定数量的字节，并将其存储在缓冲区数组中 byte[] bytes = new byte[1024]; while((len = bis.read(bytes))!=-1){ System.out.println(new String(bytes,0,len)); } //5.释放资源 bis.close();
缓冲流效率测试(复制文件)
效率从低到高
1.一个字节一个字节的读写 2.使用数组缓冲区读写 3.使用缓冲流读写 4.使用缓冲流+数组缓冲区读写
bufferwriter字符缓冲输出流
//1.创建字符缓冲输出流，构造方法中传递字符输出流 BufferedWriter bw = new BufferedWriter(new FileWriter("src\\1.txt")); //2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区 for (int i=0;i < 10;i++){ bw.write("你好"); //换行 //bw.write("\r\n"); bw.newLine(); } //3.调用字符换从输出流的方法flush,把内存缓冲区中的数据，刷新到文件中 bw.flush(); //4.释放资源 bw.close();
bufferwriter字符缓冲输入流
//1.创建字符缓冲输入流对象，构造方法中传入字符输入流 BufferedReader br = new BufferedReader(new FileReader("src\\1.txt")); //2.使用字符缓冲输入流对象中的方法read/readline读取文本 String line; while((line = br.readLine())!=null){ System.out.println(line); } //3.释放资源 br.close();
OutputStreamWriter
//创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码名称 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src\\1.txt"),"gbk"); //使用OutputStreamWriter对象中的方法write，把字符串转换为字节存储缓冲区中 osw.write("你好"); //使用OutputStreamWriter的flush方法，把内存缓冲区的字节刷新到新的文件中 osw.flush(); //释放资源 osw.close();
InputStreamWriter
//创建InputStreamReader对象，构造方法中传递字节输入流和编码表名称 InputStreamReader isr = new InputStreamReader(new FileInputStream("src\\1.txt"), "UTF-8"); //使用InputStreamReader的对象中的方法read读取文件 int len = 0; while((len = isr.read())!=-1){ System.out.println((char) len); } //释放资源 isr.close();
对象的序列化流和对象的反序列化流
ObjectInputStream;
ObjectOutputStream
