java IO流
文件
文件就是保存数据的地方。
文件流,文件在程序中时以流的形式来操作的
创建文件
相关方法:
根据路径构建一个Fiile对象:new File (String pathname);
根据父目录文件+子路径构建:new File(File parent , String child);
根据父目录+子路径构建 :new File ( String parent , String child);
package IOStream.opp1; import org.junit.jupiter.api.Test; import java.io.File; import java.io.IOException; public class demo01 { public static void main(String[] args) { } ////方式一 根据路径构建一个Fiile对象 @Test public void create01(){ String filPath = "e:\\news1.txt"; File file = new File(filPath); try{ file.createNewFile(); System.out.println("创建文件成功"); }catch (IOException e) { throw new RuntimeException(e); } } //方式2 根据父目录文件+子路径构建 @Test // 此处@Test 使用一些jar包,直接测试,不需要mian引用编译. try() catch{} 现实测试的结果 public void creat02(){ File parentFilePath = new File("e:\\"); String fileName = "news2.txt"; File file = new File(parentFilePath , fileName); // 先写 file.createNewFile() // 然后 快捷键 CTRL + alt + t 选try catch try { file.createNewFile(); System.out.println("创建成功"); } catch (IOException e) { throw new RuntimeException(e); } } //方法三 根据父目录+子路径构建 @Test public void creat03(){ String parentFilePath = "e:\\"; String childFPath = "news3.txt"; File file = new File(parentFilePath, childFPath); try { file.createNewFile(); System.out.println("创建成功"); } catch (IOException e) { throw new RuntimeException(e); } } }
获取文件信息
getName getAbsolutePath getParent length exits isFile isDirectory
package IOStream.opp1; import org.junit.jupiter.api.Test; import java.io.File; public class demo02 { public static void main(String[] args) { } // @Test public void info(){ File fileName = new File("e:\\news.txt"); //调用相应的方法 //getName getAbsolutePath getParent length exits isFile isDirectory System.out.println("文件名字:" + fileName.getName()); System.out.println("文件绝对路径" + fileName.getAbsolutePath()); System.out.println("文件父目录" + fileName.getParent()); System.out.println("文件大小(字节)" + fileName.length()); System.out.println("文件是否在" + fileName.exists()); System.out.println("文件是否是一个文件" + fileName.isFile()); System.out.println("是否是一个目录" + fileName.isDirectory()); } }
文件相关操作方法还有很多,请根据实际需要调用即可。在 File 目录下查找
目录操作
mkdir 创建一级目录、mkdirs创建多级目录、delete删除空目录
file.delete()返回 true or false,csdn的网友说这个慎用,因为:
用这个函数删除文件删到你找到找不到……
而且还是秒删……压根儿反应不过来。
如果你特别恨一个人,请用File.delete()函数删除他的重要文件。
package IOStream.opp1; import org.junit.jupiter.api.Test; import java.io.File; public class demo03 { public static void main(String[] args) { } //判断 d:\\news.txt 是否存在,如果存在则删除 //这里我们需要体会到,在java编程中,目录也可当作文件 @Test public void m1(){ String fileName = "f:\\news01.txt"; File file = new File(fileName); if (file.exists()){ if (file.delete()){ //删除文件,返回true System.out.println("存在,删除"); System.out.println(fileName + "delete success"); }else { System.out.println("失败"); } }else{ System.out.println(fileName + " is null"); } } //判断 f:\\demo 是否存在,如果存在则删除 //这里我们需要体会到,在java编程中,目录也可当作文件 @Test public void m2(){ String filePath = "f:\\demo"; File file2 = new File(filePath); if (file2.exists()){ if (file2.delete()){ //删除空目录,返回true System.out.println("存在,删除"); System.out.println(filePath + "delete success"); }else { System.out.println("失败"); } }else{ System.out.println(filePath + " is null"); } } //判断是否存在,不存在则创建 //不能用此方法目录创建多级目录,创建多级目录要用mkdirs(); public void m3(){ String filePath = "f:\\demo"; File file2 = new File(filePath); if (file2.exists()){ System.out.println("存在"); }else{ if(file2.mkdir()){ //创建成功,返回true System.out.println("成功"); }else { System.out.println("失败"); } } } @Test public void m4(){ String filePath = "f:\\demo\\121"; File file2 = new File(filePath); if (file2.exists()){ System.out.println("存在"); }else{ if(file2.mkdirs()){ //创建成功,返回true System.out.println("成功"); }else { System.out.println("失败"); } } } }
IO流原理和分类
java程序中,对于数据的输入/输出操作是以“流”的方式进行
在java.io包下提供各种接口
- 按操作数据单位不同分为:字节流(8bit)二进制文件,字符流(按字符)文本文件
- 按数据流的流向不同分为:输入流、输出流
- 按流的角色的不同分为:结点流、处理流/包装流
InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输出流
Writer 字节输入流
上述的四个流都是抽象类的
FileInputStream
InputStream字节输入流
package IOStream.opp2; import org.junit.jupiter.api.Test; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * 演示FileInputStream的使用 */ public class Demo01 { public static void main(String[] args) { } /** * 演示读取文件 * 缺点:是单个字节读取,效率地下 * -->优化:使用 read(byte[] b) */ @Test public void readFile01(){ String filePath = "e:\\hello.txt"; int readData = 0; FileInputStream fileInputStream = null; try { //创建FileInputStream 对象,用于读取文件 fileInputStream = new FileInputStream(filePath); //从该输入流读取一个字节的数据。如果没有输入可用,此方法阻止 //如果返回-1,表示读取完毕 while ((readData = fileInputStream.read()) !=-1){ System.out.print((char) readData); //转为char类型 } } catch (IOException e) { throw new RuntimeException(e); }finally { //关闭文件流,释放资源 try { fileInputStream.close(); } catch (IOException e) { throw new RuntimeException(e); } } } /** * * -->优化:使用 read(byte[] b) */ @Test public void readFile02(){ String filePath = "e:\\hello.txt"; //定义一个字节数组 byte[] buf = new byte[8]; //一次读取8个字节 int readLen = 0; FileInputStream fileInputStream = null; try { //创建FileInputStream 对象,用于读取文件 fileInputStream = new FileInputStream(filePath); //从该输入流读取最多b.length字节的数据到字节组。此方法将阻塞,知道某些输入可用 //如果返回-1,表示读取完毕 //如果读取正常,返回实际读取的字节数 while ((readLen = fileInputStream.read(buf)) !=-1){ System.out.print(new String(buf,0, readLen)); } } catch (IOException e) { throw new RuntimeException(e); }finally { //关闭文件流,释放资源 try { fileInputStream.close(); } catch (IOException e) { throw new RuntimeException(e); } } } }
FileOutputStream
OutputStream字节输出流
package IOStream.opp2; import org.junit.jupiter.api.Test; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class Demo02 { public static void main(String[] args) { } /** * 演示使用FileOutStream 将数据写到文件中 * 如果该文件不存在,则创建该文件 */ @Test public void writeFile(){ //创建FileOutStream对象 String filePath = "e:\\a.txt"; FileOutputStream fileOutputStream = null; try { //得到一个FileOutStream对象 // new FileOutputStream(filePath) 的创建方式,当写入内容时,会覆盖原来的内容 //new FileOutputStream(filePath , true) 创建方式,当写入内容是,是追加到文件后,不会覆盖 fileOutputStream = new FileOutputStream(filePath , true); //写一个字节 // fileOutputStream.write('H'); //写一个字符串 String str = "hello world"; //要换行,可以加一个\n ,但是 \n 也占一个字节,数组的一个位置 // fileOutputStream.write(str.getBytes()); //str.getBytes() 可以把字符串 -> 字节数组 //write(byte[] b , int off ,int len) 将len字节从位于偏移量 off 的指定字节数组写入次文件流 fileOutputStream.write(str.getBytes(),0,3); //这里添加了数组坐标,确定从数组的哪一个位置写入,写入多少个字节 } catch (IOException e) { throw new RuntimeException(e); } finally { try { fileOutputStream.close(); } catch (IOException e) { throw new RuntimeException(e); } } } }
文件拷贝
package IOStream.opp2; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * 文件拷贝 */ public class Demo03 { public static void main(String[] args) { //完成文件拷贝 将e:\\a.txt 拷贝到f:\\ /** * 思路: 文件② <-(输出流)--- java程序 <-(输入流)--- 文件① * 1. 创建文件的输入流,将文件读入程序 * 2. 创建文件的输入流,将读到的文件数据,写入到指定的文件 */ String srcFilePath = "e:\\a.txt"; //也可以拷贝其他文件,但是文件过大会出现问题,下面定义的数组大小要适当扩大 String destFilePath = "e:\\a2.txt "; FileInputStream fileInputStream = null; FileOutputStream fileOutputStream = null; try { fileInputStream = new FileInputStream(srcFilePath); fileOutputStream = new FileOutputStream(destFilePath); //定义一个数组,提高读入的的效率 byte[] buf = new byte[1024]; int readLen = 0; while ((readLen = fileInputStream.read(buf))!=-1){ //读取到后,就写入文件 通过fileOutputStream //即 边读边写 fileOutputStream.write(buf, 0 , readLen); //一定要使用这个方法 } System.out.println("拷贝成功"); } catch (IOException e) { throw new RuntimeException(e); }finally { try { //关闭输入流,输出流,释放资源 if (fileInputStream != null) { fileInputStream.close(); } if (fileOutputStream != null) { fileOutputStream.close(); } } catch (IOException e) { throw new RuntimeException(e); } } } }
文件字符流说明
FileReader、FileWriter是文件字符流
相关方法
new FileReader(File/String)
- read:每次读取单个字符,返回该字符,如果到文件末尾返回-1
- read(char[]) : 批量读取多个字符到数组,返回读取到的字符数,如果到文件末尾返回-1
- 相关API:
new String(char[]) : 将char[]转换为String
new String(char[], off , len ) : 将char[]的部分转换为String
FileReader
package IOStream.opp3; import org.junit.jupiter.api.Test; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class demo01 { /** * 单个字符读取文件 */ public static void main(String[] args) { String filePath = "e:\\story.txt"; FileReader fileReader = null; int data = 0; try { fileReader = new FileReader(filePath); //循环读取,使用read,单个字符读取 while ((data = fileReader.read()) !=-1){ System.out.print((char) data); } } catch (IOException e) { throw new RuntimeException(e); }finally { if (fileReader != null){ try { fileReader.close(); } catch (IOException e) { throw new RuntimeException(e); } } } } /** * 字符数组读取文件 */ @Test public void readFile01(){ System.out.println("============方法2============="); String filePath = "e:\\story.txt"; FileReader fileReader = null; int radeLen = 0; char[] buf = new char[8]; try { fileReader = new FileReader(filePath); //循环读取,使用read(buf),返回的是实际读取到的字符数 //如果返回-1,说明文件结束 while ((radeLen = fileReader.read(buf)) !=-1){ System.out.print(new String(buf,0,radeLen)); } } catch (IOException e) { throw new RuntimeException(e); }finally { if (fileReader != null){ try { fileReader.close(); } catch (IOException e) { throw new RuntimeException(e); } } } } }
FileWriter
注意:使用FileWriter后,必须要关闭(close)或者刷新(flush),否者写入不到指定文件
package IOStream.opp3; import java.io.FileWriter; import java.io.IOException; public class demo02 { public static void main(String[] args) { String filePath = "e:\\note.txt"; //创建FileWriter对象 FileWriter fileWriter = null; char[] chars = {'a','b','c','d'}; try { fileWriter = new FileWriter(filePath); //默认是覆盖方式 //方法一: 写入单个字符 write(int) fileWriter.write('H'); //方法二:写入指定数组 write(char[]) fileWriter.write(chars); //方法三:写入数组的指定部分 write(char[], off, len) fileWriter.write("璃月摩拉克斯".toCharArray(),0,3); //方法四:写入整个字符串 write( string) fileWriter.write(" 巴巴托斯"); //方法五“写入字符串的指定部分 write(string , off , len) fileWriter.write("须弥纳西妲",0,2); //在数据量大的情况下,可以使用循环操作。 } catch (IOException e) { throw new RuntimeException(e); } finally { try { fileWriter.close(); } catch (IOException e) { throw new RuntimeException(e); } //使用FileWriter后,必须要关闭(close)或者刷新(flush),才能真正写入到文件中 //关闭文件流,等价 flush()+关闭 } System.out.println("程序结束..."); } }
节点流、处理流
节点流可以从一个特定的数据源读写数据 (效率会低一些),如FileReader、FileWriter
数据源就是存放数据的地方
处理流(也叫,包装流)是”连接“在已存在的流(结点流 或 处理流)之上,为程序提供更加强大的读写功能,如BufferedReader、BufferedWriter
BufferedReader类中,有属性Reader,即可以封装一个结点流,该节点是任意的,只要是Reader子类
处理流的设计模式
处理流对节点流进行包装,使用了修饰器设计模式,不会直接与数据源相连【模拟修饰器设计模式】
处理流的功能主要体现在以下两个方面:
- 性能的提高:主要以增加缓冲的方式来提高输入处处的效率
- 操作的便捷:处理流可能提供了一些列便捷方式来一次输入输出大批量数据,使用更加灵活方便
BufferedReader和BufferedWriter属于字符流
BufferedReader
BufferReader 读取文本文件
package IOStream.opp3; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; /** * BufferReader的使用 */ public class demo03 { public static void main(String[] args) throws IOException { String filePath = "e:\\story.txt"; //创建 BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath)); //读取 String line; //按行读取,效率高 //说明 //BufferedReader.readLine() 是按行读取文件 //当返回null 时,表示文件读取完毕 while ((line = bufferedReader.readLine()) !=null){ System.out.println(line); } //关闭流,这里注意,只需要关闭BufferedReader,因为底层会自动关闭其他的Reader类型节点流。 bufferedReader.close(); } }
BufferedWriter
package IOStream.opp3; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; /** * BufferedWriter的使用 */ public class demo04 { public static void main(String[] args) throws IOException { String filePath = "e:\\ok.txt"; //默认覆盖。如果要在后边追加内容,FileWriter( ,) 里加上布尔类型true BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true)); bufferedWriter.write("BNU1"); bufferedWriter.newLine(); //插入一个与系统相关的换行 bufferedWriter.write("BNU2"); bufferedWriter.write("BNU3"); //关闭外层流即可,传入的FileWriter会在底层关闭 bufferedWriter.close(); } }
Buffered拷贝
(结合BufferedReader、BufferedWriter一起使用)(文本文件)
BufferedReader和BufferedWriter属于字符流,按照字符操作,不要去操作二进制文件,否则该二进制文件会损坏。
二进制文件一般是音视频文件、图片文件、doc文档、pdf文档等
package IOStream.opp3; import java.io.*; /** * 拷贝文件 */ public class demo05 { public static void main(String[] args) { String srcFilePath = "e://story.txt"; String destFilePath = "e://story2.txt"; BufferedReader br = null; BufferedWriter bw = null; String line; try { br = new BufferedReader(new FileReader(srcFilePath)); bw = new BufferedWriter(new FileWriter(destFilePath)); //readLine() 读取一行内容,但是没有换行 while ((line = br.readLine())!=null){ bw.write(line); bw.newLine(); //换行 } } catch (IOException e) { throw new RuntimeException(e); } finally { try { if (br != null ){ br.close(); } if (bw !=null){ bw.close(); } } catch (IOException e) { throw new RuntimeException(e); } } } }
Buffered字节处理流
BufferedOutputStream、 BufferedInputStream
字节处理流拷贝文件
二进制文件的拷贝,二进制文件一般是音视频文件、图片文件、doc文档、pdf文档等
可以操作文本文件吗?当然可以
package IOStream.opp3; import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils; import java.io.*; /** * 二进制文件的拷贝 * BufferedOutputStream、 BufferedInputStream的使用 */ public class demo06 { public static void main(String[] args) { String srcFilePath = "e:\\123.png"; String destFilePath = "e:\\1232.png"; BufferedInputStream bis = null; BufferedOutputStream bos = null; try { bis = new BufferedInputStream(new FileInputStream(srcFilePath)); bos = new BufferedOutputStream(new FileOutputStream(destFilePath)); //循环的读取文件,并写入到destFilePath byte[] buff = new byte[1024]; int readLen = 0; while ((readLen = bis.read(buff)) != -1){ bos.write(buff,0,readLen); } } catch (IOException e) { throw new RuntimeException(e); } finally { //关闭流,关闭外层流即可,底层会自动关闭节点 try { if(bis != null) { bis.close(); } if (bos !=null){ bos.close(); } } catch (IOException e) { throw new RuntimeException(e); } } } }
对象处理流
ObjectInputStream和ObjectOutputStream
序列化和反序列化
- 序列化就是 保存数据时,保存数据的值和数据类型
- 反序列化就是 恢复数据时,恢复数据的值和数据类型
- 需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,该类必须实现如下两个接口之一:
- Serializable //这个一个标准接口
- Externalizable //该接口有方法需要实现,因此我们一般实现上面的Serializable 接口
ObjectOutputStream
完成数据的序列化 保存数据时,保存数据的值和数据类型
package IOStream.opp4; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.Serializable; public class demo01 { public static void main(String[] args) throws IOException { //序列化后,保存的文件格式 String filePath = "e:\\data.txt"; ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath)); //序列化后数据到e:\data.txt oos.writeInt(100); //int->integer 实现了Serializable接口 oos.writeBoolean(true); //boolean-> Boolean 实现了Serializable接口 oos.writeChar('s'); //char-> character 实现了Serializable接口 oos.writeDouble(9.5); //double -> Double 实现了Serializable接口 oos.writeUTF("巴巴托斯"); //String //保存一个Dog对象 oos.writeObject(new Dog("旺财",10)); oos.close(); System.out.println("序列化形式"); } } //如果需要序列化某个类的对象, 需要实现Serializable ,否则报错 class Dog implements Serializable { private String name; private int age; public Dog(String name, int age) { this.name = name; this.age = age; } }
ObjectInputStream
恢复数据时,恢复数据的值和数据类型
数据序列化 ObjectOutputStream
package IOStream.opp4; import IOStream.opp5.Dog; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class demo01 { public static void main(String[] args) throws IOException { //序列化后,保存的文件格式 String filePath = "e:\\data.txt"; ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath)); //序列化后数据到e:\data.txt oos.writeInt(100); //int->integer 实现了Serializable接口 oos.writeBoolean(true); //boolean-> Boolean 实现了Serializable接口 oos.writeChar('s'); //char-> character 实现了Serializable接口 oos.writeDouble(9.5); //double -> Double 实现了Serializable接口 oos.writeUTF("巴巴托斯"); //String //保存一个Dog对象 oos.writeObject(new Dog("旺财",10)); oos.close(); System.out.println("序列化形式完成"); } } //如果需要序列化某个类的对象, 需要实现Serializable ,否则报错
对某个Dog对象进行定义
package IOStream.opp5; import java.io.Serializable; public class Dog implements Serializable{ private String name; private int age; public Dog(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Dog{" + "name='" + name + '\'' + ", age=" + age + '}'; } 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; } }
反序列化ObjectInputStream
package IOStream.opp4; import IOStream.opp5.Dog; import java.io.*; public class demo02 { public static void main(String[] args) throws IOException, ClassNotFoundException { //指定反序列化的文件 String filePath = "e:\\data.txt"; ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath)); //读取 //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致 //2. 否则会出现异常 System.out.println(ois.readInt()); System.out.println(ois.readBoolean()); System.out.println(ois.readChar()); System.out.println(ois.readDouble()); System.out.println(ois.readUTF()); //dog 的编译类型是Object ,dog的运行类型是 Dog Object dog = ois.readObject(); // System.out.println("运行类型"+ dog.getClass()); // System.out.println(dog); // System.out.println(ois.readObject()); //细节 //如果我们希望调用Dog的方法,我们需要向下转型 //需要我们将Dog类的定义,拷贝到可以引用的位置 Dog dog2 = (Dog)dog; System.out.println(dog2.getName()); System.out.println(dog2.getAge()); //关闭流 ois.close(); } }
对象处理流使用细节
注意事项:
- 读写顺序要一致
- 要求序列化或反序列化对象,需要实现Serializable
- 序列化的类中建议添加SerialVersionUID ,为了提高版本的兼容性
- 序列化对象时,默认将里面虽有属性都进行序列化,
但除了static或transient修是的成员
- 序列化对象时,要求里面的属性的类型也需要实现序列化接口
- 序列化具备可继承性,也就是如果某类已经实现序列化,则它所有的子类也已经默认实现了序列化
这也就是个序列号(版本号)
private static final long SerialVersionUID = 1L;
标准输入输出流
类型
System.in 标准输入 InputStream 键盘
System.out 标准输出 PrintStream 屏幕
package IOStream.opp6; import java.io.BufferedInputStream; import java.io.InputStream; public class demo01 { public static void main(String[] args) { //System 类 的 public final static InputStream in = null; //System.in 编译类型 InputStream //System.in 运行类型 BufferedInputStream // 标准输入 键盘 System.out.println(System.in.getClass()); // //System.out public final out = null; //编译类型:PrintStream //运行类型:PrintStream //标准输出 显示器 System.out.println(System.out.getClass()); /** * class java.io.BufferedInputStream * class java.io.PrintStream */ } }
Scanner scanner = new Scanner(System.in); System.out.println("输入内容"); String next = scanner.next(); System.out.println(next);
乱码引出转换流
转换流-InputStreamReader、OutputStreamWriter
package IOStream.opp7; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class demo01 { public static void main(String[] args) throws IOException { //读取 e:\\a.txt 文件到程序 //思路 //1. 创建字符输入流 BufferedReader [处理流] //2. 使用BufferedReader 对象读取a.txt //3. 默认情况下,读取文件是UTF-8 编码 String filePath = "e:\\story2.txt"; BufferedReader br = new BufferedReader(new FileReader(filePath)); String s = br.readLine(); System.out.println("读到的内容"+ s); br.close(); } }
InputStreamReader
- InputStreamReader:Reader子类,可以将InputStream(字节流)包装(转换)成Reader (字符流)
- OutPutStreamWriter : Writer 子类,实现将OutPutStream(字节流)包装成Writer 字符流
- 当处理纯文本数据时,如果使用字符流效率更高,并且可以有效解决中文问题,所以建议将字节流转化成字符流
- 可以在使用时,指定编码格式(UTF-8 , GBK ,GB2312, ISO8859-1等)
package IOStream.opp7; import java.io.*; /** * 使用InputStreamReader 转换流解决中文乱码问题 * 将字节流 FileInputSteam 转成字符流 InputStreamReader,指定编码UTF-8、gbk */ public class demo02 { public static void main(String[] args) throws IOException { String filePath = "e:\\story2.txt"; //1. 把字节流 FileInputSteam 转成字符流 InputStreamReader //2. 指定编码 gbk // InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk"); //3. 把InputStreamReader传入BufferedReader // BufferedReader br = new BufferedReader(isr); //2和3可以合在一起写 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk")); //4. 读取 String s = br.readLine(); System.out.println("读取内容" + s); //关闭 br.close(); } }
OutputStreamWriter
package IOStream.opp7; import java.io.*; /** * 演示OutputStreamWriter的使用 * 把FileOutputStream 字节流,转成字符流 OutPutStreamWriter * 指定处理的编码 gbk等 */ public class demo03 { public static void main(String[] args) throws IOException { String filePath = "e:\\story23.txt"; OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), "utf-8"); osw.write("hi,摩拉克斯"); osw.close(); System.out.println("保存成功"); } }
打印流
PrintStream打印流只有输出流,没有输入流
PrintStream
package IOStream.opp7; import java.io.FileNotFoundException; import java.io.PrintStream; /** * 演示 PrintStream 字节打印流 */ public class PrintStream_ { public static void main(String[] args) throws FileNotFoundException { PrintStream out = System.out; //默认情况下,PrintStream 输出数据的位置是 标准输出 ,即 显示器 out.print("hello"); //print 底层使用得使writer , 所以我们可以直接调用writer进行打印/输出 out.close(); //我们也可以去修改打印流输出的位置(设备) //修改到e:\f1.txt //“璃月”会输出到位置e:\\f1.txt //源码:是native 方法修改了out System.setOut(new PrintStream("e:\\f1.txt")); System.out.println("璃月"); } }
PrintWriter
package IOStream.opp7; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class PrintWriter_ { public static void main(String[] args) throws IOException { //PrintWriter printWriter = new PrintWriter(System.out); PrintWriter printWriter = new PrintWriter(new FileWriter("e://f2.txt")); //设置输出的位置e://f2.txt printWriter.print("hi,璃月"); printWriter.close(); //关闭流 } }
配置文件 Properties
读文件
传统方案:还是需要修改代码本身,实际运用及其不方便
import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class Properties01 { public static void main(String[] args) throws IOException { //读取mysql.properties 文件,并得到ip、user 、 pwd BufferedReader br = new BufferedReader(new FileReader("e:\\mysql.txt")); String line = ""; while ((line = br.readLine()) !=null){ String[] split = line.split("="); System.out.println(split[0] + "值是:" + split[1]); } br.close(); } }
文件:
ip = 127.0.0.1 user = root pwd = 12345
方案二:Properties类
常见方法:
load
:加载配置文件的键值对到Properties对象list
:将数据显示到指定设备getProperty(key)
根据键值获值setProperty(key,value)
:设置键值对存储到配置文件中,在idea中,保存信息到配置文件,如果含有中文,会存储unicode码
package IOStream.opp7; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Properties; public class Properties02 { public static void main(String[] args) throws IOException { //1.创建properties对象 Properties properties = new Properties(); //2.加载配置文件 properties.load(new FileReader("e:\\mysql.txt")); //3.把键值对k-v 显示到控制台 properties.list(System.out); //4.根据key 获取对于的值 String user = properties.getProperty("user"); String pwd = properties.getProperty("pwd"); System.out.println("用户" + user + " 密码" + pwd); } }
写文件
package IOStream.opp7; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Properties; public class Properties03 { public static void main(String[] args) throws IOException { // 使用Properties 类来创建 配置文件,修改配置文件内容 Properties properties = new Properties(); //创建 //如果该文件没有key 就是创建 //如果该文件有key,就是修改 properties.setProperty("charset", "utf-8"); properties.setProperty("user", "root汤姆"); properties.setProperty("pwd", "888888"); //将键值对k-v 存储到文件中 properties.store(new FileOutputStream("e://data007.txt"),null); //null是占位的,是注释,表示没有注释 // properties.store(new FileOutputStream("e://data007.txt"),"你好"); //带来“你好”的注释 System.out.println("保存成功"); } }
家庭作业
作业一:
package IOStream.opp7; import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; public class homework01 { public static void main(String[] args) throws IOException { String filePath = "e:\\mytemp"; File file = new File(filePath); if(!file.exists()){ if (file.mkdirs()){ System.out.println("创建成功"); }else { System.out.println("创建失败"); } } String filePath2 = filePath + "\\hello.txt"; file = new File(filePath2); if(!file.exists()) { //创建文件 if (file.createNewFile()) { System.out.println("文件创建成功"); //如果文件存在,我们就使用BufferedWriter 字符流 BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file)); bufferedWriter.write("hello GENSHIN IMPAT"); bufferedWriter.close(); } else { System.out.println("文件创建失败"); } }else { System.out.println("文件存在"); } } }
作业二:
package IOStream.opp7; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class homework02 { public static void main(String[] args) { String filePath = "e:\\story002.txt"; BufferedReader br = null; String line = ""; int lineNum = 0; try { br = new BufferedReader(new FileReader(filePath)); while ((line = br.readLine())!=null){ System.out.println(++lineNum + line); } } catch (IOException e) { throw new RuntimeException(e); } finally { try { if (br !=null){ br.close(); } } catch (IOException e) { throw new RuntimeException(e); } } } }
如果追加条件,所读的文件编码为gbk编码,则修改第13行代码为
br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
package IOStream.opp7; import java.io.*; public class homework02 { public static void main(String[] args) { String filePath = "e:\\story2.txt"; BufferedReader br = null; String line = ""; int lineNum = 0; try { br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk")); while ((line = br.readLine())!=null){ System.out.println(++lineNum + line); } } catch (IOException e) { throw new RuntimeException(e); } finally { try { if (br !=null){ br.close(); } } catch (IOException e) { throw new RuntimeException(e); } } } }
作业三:
package IOStream.opp7; import org.junit.jupiter.api.Test; import java.io.*; import java.util.Properties; public class homework03 { public static void main(String[] args) throws IOException { String filePath = "e:\\dog.properties"; Properties properties = new Properties(); properties.load(new FileReader(filePath)); // properties.list(System.out); String name = properties.get("name")+ ""; // object->String int age = Integer.parseInt(properties.get("age")+""); //object->int String color = properties.get("color")+""; Dog dog = new Dog(name, age, color); System.out.println("==========对象信息==========="); System.out.println(dog); //序列化 String serFilePath = "e://dog.dat"; ObjectOutputStream oss = new ObjectOutputStream(new FileOutputStream(serFilePath)); oss.writeObject(dog); //关闭 oss.close(); System.out.println("序列化完成..."); } //反序列化的一个方法 @Test public void m1() throws IOException, ClassNotFoundException { String serFilePath = "e:\\dog.dat"; ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(serFilePath)); Dog dog = (Dog) objectInputStream.readObject(); System.out.println("反序列化后:"); System.out.println(dog); objectInputStream.close(); } } class Dog implements Serializable{ private String name; private int age; private String color; public Dog(String name, int age, String color) { this.name = name; this.age = age; this.color = color; } 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; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } @Override public String toString() { return "Dog{" + "name='" + name + '\'' + ", age=" + age + ", color='" + color + '\'' + '}'; } }