IO流
IO流是用来读写数据的,流使用完就要释放资源,(1024*8)Java默认较好存储单元
I :intput 把硬盘文件中的数据读入到内存的过程,称:输入 负责读
O:output 把内存中的数据写出到硬盘文件的过程,称:输出 负责写
IO流分类
Windows文件不区分大小写
文件字节输入流:FileInputStream
Windows文件不区分大小写
以内存为基准,把磁盘文件中的数据以字节的形式读取到内存中
构造对象
读取方法
public class Demo { public static void main(String[] args) throws IOException { FileInputStream fis1 = new FileInputStream(new File("day11\abc.txt")); System.out.println((char) (fis1.read())); int b;//单字节循环读文本 while ((b=fis1.read())!=-1){ System.out.println((char)b); } fis1.close(); System.out.println("------------"); FileInputStream fis2 = new FileInputStream("day11\DEF.txt"); System.out.println((char)(fis2.read())); int len;//字节数组循环读文本 byte[] bs = new byte[2]; while ((len = fis2.read(bs))!=-1){ System.out.println(new String(bs,0,len)); } fis2.close(); } }1.如何使用字节输入流读取中文内容输出不乱码呢?
定义一个与文件一样大或者大于的字节数组,一次性读取完文件的全部字节2.直接把文件数据全部读取到一个字节数组可以避免乱码,是否存在问题?
如果文件过大,字节数组可能引起内存溢出一个字节一个字节读取效率较慢
一个字节数组一个字节数组读取效率提升
读取中文字符会乱码
文件字节输出流:FileOutputStream
以内存为基准,把内存中的数据以字节的形式写出到磁盘文件中去的流
构造对象
写出方法
刷新关闭方法
public class Demo { public static void main(String[] args) throws IOException { FileOutputStream fos1 = new FileOutputStream(new File("day11\dzz1.txt")); FileOutputStream fos1_1 = new FileOutputStream(new File("day11\dzz1_1.txt"),true); FileOutputStream fos2 = new FileOutputStream("day11\dzz2.txt"); FileOutputStream fos2_2 = new FileOutputStream("day11\dzz2_2.txt",true); fos1.write(65);//写入一个字节 for (int i = 0 ; i < 10 ;i++) { fos1_1.write(97); } byte[] bs = {'a','b','c','d'}; fos2.write(bs);//写入一个字节数组 fos2.flush(); fos2.write("rn".getBytes()); fos2.write(bs,1,2); fos1.close(); fos1_1.close(); fos2.close(); fos2_2.close(); } }fos1.write("rn".getBytes()) → 换行
文件字符输入流:FileReader
以内存为基准,把磁盘文件中的数据以字符的形式读取到内存中去
构造对象
读取方法
public class DemoReader { public static void main(String[] args) throws IOException { method02(); } //字符数组循环读取 private static void method02() throws IOException { //1.创建文件字符输入流FileReader类的对象fr,绑定源文件 FileReader fr = new FileReader("day12\f2.txt"); //2.文件字符输入流FileReader类的对象fr调用read方法,以字符的方式读取文件内容 //定义int变量len,用来保存每次读取到的字符的个数 int len; //定义长度为3的字符数组chs,用来保存每次读取到的多个字符的内容(最多3个) char[] chs = new char[3];//{'a','好','大'} //从fr关联的文件中读取多个字符(最多3个),存储到方法参数字符数组chs中, //返回读取的字符的个数赋值给变量len, //最后判断len的值是否不等于-1 while ((len = fr.read(chs)) != -1) { System.out.println(new String(chs,0,len)); } //3.文件字符输入流FileReader类的对象fr调用close方法,关闭流,释放资源 fr.close(); } //单字符循环读取 private static void method01() throws IOException { //1.创建文件字符输入流FileReader类的对象fr,绑定源文件 FileReader fr = new FileReader("day12\f2.txt"); //2.文件字符输入流FileReader类的对象fr调用read方法,以字符的方式读取文件内容 //定义int变量ch,用来保存每次读取到的一个字符对应的int数字 int ch; //从fr关联的文件中读取一个字符,返回对应的int数字赋值给左侧变量ch //最后判断ch的值是否不等于-1 while ((ch = fr.read()) != -1) { System.out.print((char)ch); } //3.文件字符输入流FileReader类的对象fr调用close方法,关闭流,释放资源 fr.close(); } }
文件字符输出流:FileWriter
以内存为基准,把内存中的数据以字符的形式写出到磁盘文件中去的流
构造对象
写入方法
刷新关闭方法
public class DemoWriter { public static void main(String[] args) throws IOException { //1.创建文件字符输出流FileWriter类的对象fw,绑定目标文件 //没有写第二个参数,默认就是false,覆盖/重新写入 //每次创建一个新的空的文件f3.txt //FileWriter fw = new FileWriter("day12\f3.txt"); //第二个参数是true,表示追加写入(从文件的末尾开始写) FileWriter fw = new FileWriter("day12\f3.txt",true); //2.文件字符输出流FileWriter类的对象fw调用write方法,以字符的方式写出内容到文件 //写出单个字符 fw.write('a'); fw.write(98); //写出换行 fw.write("rn"); //写出一个字符数组 char[] chs = {'好', '好', '学', '习', '天', '天', '向', '上', '!'}; fw.write(chs); //写出一个字符数组的一部分, 把"天天向上,重新写一遍" fw.write(chs,4,5); //写出换行 fw.write("rn"); //写出一个字符串 String s = "好想有个女朋友!"; fw.write(s); //写出一个字符串的一部分,把"有个女朋友!"再写一遍 fw.write(s,2,6); //写出换行 fw.write("rn"); //3.文件字符输出流FileWriter类的对象fw调用close方法,关闭流,释放资源 fw.close(); } }fw.write("rn"); → 换行
缓冲流
缓冲流也称高效流,或则高级流 字节流也称为原始流
作用:缓冲流自带缓冲区,可以提高原始字节流,字符流读写数据的性能
缓冲区长度1024*8 8192
字节缓冲流
字节缓冲输入流:BufferedInputStream
字节缓冲输出流:BufferedOutputStream构造对象
提高字节输入输出流读取数据的性能,读写功能上并无变化
字节缓冲流为什么提高了操作数据的性能?
字节缓冲流自带8KB缓冲区
可以提高原始字节流、字符流读写数据的性能public class DemoCopyTxt { public static void main(String[] args) throws IOException { //1.创建字节缓冲输入流BufferedInputStream类的对象bis,绑定源文件 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day11\f4.txt")); //2.创建字节缓冲输出流BufferedOutputStream类的对象bos,绑定目标文件 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11\f5.txt")); //3.按行循环读(源文件)写(目标文件) //定义int变量len,用来保存每次读取到的一行字节串(不含换行符) int len; //从bis关联的文件中读取对应的字节数(不包含回车换行符的)返回赋值给int变量len //最后判断len的值是否不等于-1 while ((len = bis.read()) != -1) { //把len中保存的字节串内容写出到bos绑定的目标文件中 bos.write(len); //写入换行符 bos.write("rn".getBytes()); } //4.关闭流,释放资源 bis.close(); bos.close(); } }
字符缓冲流
字符缓冲输入流:BufferedReader
字符缓冲输出流:BufferedWriter构造对象
字符缓冲输入流:BufferedReader
字符缓冲输出流:BufferedWriter
字符缓冲流的功能如何使用?
public BufferedReader(Reader r)
性能提升了,多了readLine()按照行读取的功能public BufferedWriter(Writer w)
性能提升了,多了newLine()换行的功能public class DemoCopyTxt { public static void main(String[] args) throws IOException { //1.创建字符缓冲输入流BufferedReader类的对象br,绑定源文件 BufferedReader br = new BufferedReader(new FileReader("day12\f4.txt")); //2.创建字符缓冲输出流BufferedWriter类的对象bw,绑定目标文件 BufferedWriter bw = new BufferedWriter(new FileWriter("day12\f5.txt")); //3.按行循环读(源文件)写(目标文件) //定义String变量line,用来保存每次读取到的一行字符串(不含换行符) String line; //从br关联的文件中读取一行字符串(不包含回车换行符的)返回赋值给String变量line //最后判断line的值是否不等于null while ((line = br.readLine()) != null) { //把line中保存的字符串内容写出到bw绑定的目标文件中 bw.write(line); //写入换行符 bw.newLine(); } //4.关闭流,释放资源 br.close(); bw.close(); } }
转换流
解决乱码问题
字符输入转换流:InputStreamReader
可以把原始的字节流按照指定编码转换成字符输入流
字符输入转换流:OutputStreamWriter
可以把字节输出流按照指定编码转换成字符输出流
public class DemoTransferTest { public static void main(String[] args) throws IOException { //1.创建InputStreamReader类的对象isr,指定编码表GBK,同时绑定源文件f9_gbk.txt InputStreamReader isr = new InputStreamReader(new FileInputStream("day12\f9_gbk.txt"), "GBK"); //2.创建OutputStreamWriter类的对象osw,指定编码表UTF-8,同时绑定目标文件f13_utf8.txt OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day12\f13_utf8.txt"), "UTF-8"); //3.字符数组循环读(源文件)写(目标文件) int len; char[] chs = new char[1024*8]; while ((len = isr.read(chs)) != -1) { osw.write(chs, 0, len); } //4.关闭流释放资源 isr.close(); osw.close(); } }
序列化对象
类要进行序列化 / 反序列化
必须实现: java.io.Serializable接口 (序列化标记型接口)
对象序列化
作用:
以内存为基础,把内存中的对象存储到磁盘文件中去,称为对象序列化
对象字节输出流:ObjectOutputStream
构造对象
序列化方法
对象反序列化
作用:
以内存为基准,把存储到磁盘文件中去的对象数据恢复成内存中的对象,称为对象反序列化
对象字节输入流:ObjectInputStream
构造对象
序列化方法
public class Person implements Serializable { //定义一个永不变化的序列号 //无论如何修改类的信息,该序列号不会发生变化 private static final long serialVersionUID = 666888999L; private String name; //private int age; public int age; //private static int age;//被static修饰的内容,不能序列化 //private transient int age;//被transient修饰的内容,不能序列化 //toString方法,空参/满参构造,set/get方法 @Override public String toString() { return "Person{" + "name='" + name + ''' + ", age=" + age + '}'; } public Person() { } public Person(String name, int age) { this.name = name; this.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; } }public class DemoReadWriterObject { public static void main(String[] args) throws Exception { writeObject(); readObject(); } //从文件读取一个对象出来 private static void readObject() throws IOException, ClassNotFoundException { //1.创建InputStream类的子类FileInputStream对象fis,绑定源文件 //InputStream is = new FileInputStream("day12\info.txt"); //2.创建ObjectInputStream类对象,传递fis //ObjectInputStream ois = new ObjectInputStream(is); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12\info.txt")); //3.创建ObjectInputStream类对象调用readObject方法,从文件读取字节封装成对象并返回 Person p = (Person) ois.readObject(); System.out.println(p); //4.创建ObjectInputStream类对象调用close方法 ois.close(); } //把对象写出到文件 private static void writeObject() throws IOException { //满参构造创建Person类的对象 Person p = new Person("张三", 18); //1.创建OutputStream类的子类FileOutputStream对象fos,绑定目标文件 //OutputStream os = new FileOutputStream("day12\info.txt"); //2.创建ObjectOutputStream类对象,传递fos //ObjectOutputStream oos = new ObjectOutputStream(os); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day12\info.txt")); //3.ObjectOutputStream类对象调用writeObject方法,把对象写出到目标文件 oos.writeObject(p); //4.ObjectOutputStream类对象调用close方法 oos.close(); } }
打印流
作用:
打印流可以实现方便、高效的打印数据到文件中去。
可以实现打印什么数据就是什么数据,例如打印整数97写出去就是97;打印boolean的true,写出去就是true
PrintStream
构造对象
方法
PrintWriter
构造对象
方法
1.打印流有几种?各有什么特点?
打印流一般是指:PrintStream,PrintWriter两个类。
打印功能2者是一样的使用方式
PrintStream继承自字节输出流OutputStream,支持写字节
PrintWrite继承自字符输出流Writer,支持写字符
2.打印流的优势是什么?
两者在打印功能上都是使用方便,性能高效(核心优势)
public class DemoPrinterWriter {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter pw = new PrintWriter("day12\f14.txt");
//PrintStream ps = new PrintStream("day12\f14.txt");
//public void print(Xxx yyy): 原样输出不带换行
pw.print(97);
pw.print('b');
pw.print(66.66);
pw.print(true);
pw.print("hello");
//public void println(Xxx yyy): 原样输出带换行
pw.println();
pw.println(97);
pw.println('b');
pw.println(66.66);
pw.println(true);
pw.println("hello");
//关闭流
pw.close();
}
}
commons-io
作用:
打印流可以实现方便、高效的打印数据到文件中去。
可以实现打印什么数据就是什么数据,例如打印整数97写出去就是97;打印boolean的true,写出去就是true
PrintStream
构造对象
方法
PrintWriter
构造对象
方法
1.打印流有几种?各有什么特点?
打印流一般是指:PrintStream,PrintWriter两个类。
打印功能2者是一样的使用方式
PrintStream继承自字节输出流OutputStream,支持写字节
PrintWrite继承自字符输出流Writer,支持写字符
2.打印流的优势是什么?
两者在打印功能上都是使用方便,性能高效(核心优势)
public class DemoPrinterWriter {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter pw = new PrintWriter("day12\f14.txt");
//PrintStream ps = new PrintStream("day12\f14.txt");
//public void print(Xxx yyy): 原样输出不带换行
pw.print(97);
pw.print('b');
pw.print(66.66);
pw.print(true);
pw.print("hello");
//public void println(Xxx yyy): 原样输出带换行
pw.println();
pw.println(97);
pw.println('b');
pw.println(66.66);
pw.println(true);
pw.println("hello");
//关闭流
pw.close();
}
}
commons-io是apache开源基金组织提供的一组有关IO操作的类库
可以提高IO功能开发的效率,很多有关io操作的类,有两个主要的类FileUtils, IOUtils
作用:
使用commons-io简化io流读写
使用方式:
1.在项目中创建一个文件夹:lib
2.将commons-io-x.x.jar文件复制到lib文件夹
3.在jar文件上点右键,选择 Add as Library -> 点击OK
4.在类中导包使用FileUtils主要有如下方法
两个工具类: IOUtils public static void copy(InputStream is,OutputStream os): 复制文件的 public static void closeQuietly(...): 关闭资源,内部帮助我们处理异常 FileUtils public static void copyDirectoryToDirectory(File srcDir,File destDir): 拷贝文件夹 public static void writeStringToFile(File file,String str): 写字符串到文本文件中。 public static String readFileToString(File file): 读取文本文件,返回字符串。 */ public class Demo05CommonsIO { public static void main(String[] args) throws IOException { //工具类静态方法,实现文件的复制 IOUtils.copy(new FileInputStream("day12\io\copy\from\jzc.flv"),new FileOutputStream("day12\io\copy\to\jzc.flv")); //工具类静态方法,实现文件夹的复制 FileUtils.copyDirectoryToDirectory(new File("day12\io"),new File("day12\abc")); //工具类静态方法,把字符串直接写入到文件中 FileUtils.writeStringToFile(new File("day12\f13.txt"),"CommonsIO真TM好用!!!!"); //工具类静态方法,从文件中读取字符串出来 String str = FileUtils.readFileToString(new File("day12\f13.txt")); } }



