JAVA中的那些流你知道么-阿里云开发者社区

字节输出流

FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流

FileOutputStream(file file) 创建一个向指定file对象中写入数据的输出文件流

作用：

1.创建一个FileOutputStream对象

2.会根据构造方法中传递的文件文件路径创建一个空的文件

3.会把FileOutputStream对象指定向创建好的文件

使用：

1.创建一个FileOutputStream对象，写入目的地

2.调用FileOutputStream对象中的方法，写入数据

3.释放资源

close() 关闭输出流释放资源

flush() 刷新内容

write(byte[] b) 把字节数组写入输出流

write(byt[] b,int off,int len) 从指定的字节数组邪恶如len字节，从偏移量off开始输出到此输出流

write(int b) 将指定的字节输出流

写单个字节

import java.io.FileOutputStream;
import java.io.IOException;
public class DemoFileOutputStream {
   public static void main(String[] args) throws IOException {
       FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
       fos.write(97);
       fos.close();
  }
}

写多个字节

package file;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class DuoFileOutputStream {
   public static void main(String[] args) throws IOException {
       FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\b.txt");
       // 字节数组
       byte[] bytes = {66,67,68,69,70};
       fos.write(bytes);
       // 字节数组 分割
       byte[] bytes1 = {65,66,67,68,69,70};
       // 从索引2开始 ，写为五个字节
       fos.write(bytes1,2,2);
       // 中文字符写入
       byte[] bytes2 = "你好".getBytes();
       System.out.println(Arrays.toString(bytes2)); //[-28, -67, -96, -27, -91, -67]
       fos.write(bytes2);
       fos.close();
  }

字节追加写入换行

true : 追加写入
flase：覆盖重写
package file;
import java.io.FileOutputStream;
import java.io.IOException;
public class Huanhang {
   public static void main(String[] args) throws IOException {
       FileOutputStream fos = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\c.txt",true);
       for (int i = 0; i <10 ; i++) {
           fos.write("你好".getBytes());
           fos.write("\r\n".getBytes());
      }
       fos.close();
  }
}

字节输入流

读取字节

import java.io.FileInputStream;
import java.io.IOException;
public class DemoRead {
   public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
       int a = 0;
       while ((a = fis.read())!= -1){
           System.out.println((char)a);
      }
       fis.close();
  }
}
import java.io.FileInputStream;
import java.io.IOException;
public class Duoread {
   public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
       // 字符读取
       byte[] bytes = new byte[4];
       // 布尔表达式
       int len = 0;
       while ((len = fis.read(bytes))!=-1){
           System.out.println(new String(bytes));
      }
  }
}

文件复制

数据源：c:\\1.jpg

目的地：c:\\2.jpg

创建字节输入流，读取图片

创建字节输出流，写入图片

字节输入流，读取文件

字节输出流，写入文件

关闭资源

package file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
   public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("D:\\1.jpg");
       FileOutputStream fos = new FileOutputStream("D:\\2.jpg");
       // 第一种
       //int len = 0;
       //while ((len = fis.read())!=-1){
       //   fos.write(len);
       //}
       // 第二种
       byte[] bytes = new byte[1024];
       int a = 0;
       while ((a = fis.read(bytes))!=-1){
           fos.write(bytes,0,a);
      }
       fos.close();
       fis.close();
  }
}

GBK: 两个字节

UTF-8: 三个字节

字节流读取文件中文字符导致乱码故引用字符输入流

字符输入流

字符出入流，是字符输入流的顶层父类，定义一些共性成员方法，一个抽象类

read() 读取单个字符并返回

read(char[] cbuf) 读取多个字符并返回数组

close() 关闭资源

package file;
import java.io.FileReader;
import java.io.IOException;
public class ZiFuRead {
   public static void main(String[] args) throws IOException {
       FileReader fr = new FileReader("D:\\Program Files\\jichu\\src\\file\\c.txt");
       // 第一种方法 单个读取
//       int len = 0;
//       while ((len = fr.read())!= -1){
//           System.out.println((char)len);
//       }
       // 第二种方法 字符数组
       char[] chars = new char[4];
       int ch = 0;
       while ((ch = fr.read(chars))!=-1){
           System.out.println(new String(chars));
      }
       fr.close();
  }

字符输出流

write(int c) 写入单个字符

write(char[] char) 写入字符数组

write(char[] char,int off,int len) 写入字符某一部分，从索引n开始，写入n个字符

write(String str) 写入字符串

write(String str,int off,int len) 写入字符串某一部分，从索引n开始，写入n个字符

flush() 刷新缓冲

close() 关闭资源

package file;
import java.io.FileWriter;
import java.io.IOException;
public class DuoWrite {
   public static void main(String[] args) throws IOException {
       FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\d.txt");
       fw.write("abc");
       fw.write("你好");
       fw.write(97);
       char[] bytes = {96,97,99};
       fw.write(bytes);
       fw.flush();
       fw.close();
  }
}

追加换行写入

package file;
import java.io.FileWriter;
import java.io.IOException;
public class HuanhangWriter {
   public static void main(String[] args) throws IOException {
       // true 追加写入
       // false 覆盖重写
       FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\f.txt",true);
       fw.write("test, 你好");
       fw.write("\r\n");
       fw.write("heihie");
       fw.close();
  }

属性集合

properties 表示一个持久性的属性集，可保存在流中或从流中加载

可以使用store 把集合中的临时数据持久化写入到硬盘中

可以使用load ，把硬盘中保存的文件，读取到集合中使用

properties 是一个双列集合 key 和value 都是字符串默认

setProperty(String key,String value) 写数据

getProperty(String key) 读数据指定key 读value

stringPropertyNames() 返回此属性集列表中的键集，相当于map中的keyset方法

package file;
import java.util.Properties;
import java.util.Set;
public class DemoProperties {
   public static void main(String[] args) {
       // 创建属性集
       Properties p = new Properties();
       // 添加数据
       p.setProperty("张三","166");
       p.setProperty("李四","176");
       p.setProperty("王五","186");
       // 获取key 存储到集合里
       Set<String> s = p.stringPropertyNames();
       // 遍历集合 获取key值
       for (String key : s) {
           // 通过key 获取value
           String value = p.getProperty(key);
           System.out.println(key +"---"+ value);
      }
  }
}

store写入文件

package file;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class DemoProperties {
   public static void main(String[] args) throws IOException {
       // 创建属性集
       Properties p = new Properties();
       // 添加数据
       p.setProperty("张三","166");
       p.setProperty("李四","176");
       p.setProperty("王五","186");
       // 创建字符写入流
       FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\properties.txt");
       // 使用store写入数据到文件
       p.store(fw,"save data");
       // 关闭资源
       fw.close();
  }
}

load读取文件

package file;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class DemoProperties {
   public static void main(String[] args) throws IOException {
       // 创建属性集
       Properties p = new Properties();
       // 使用load 读取文件
       p.load(new FileReader("D:\\Program Files\\jichu\\src\\file\\properties.txt"));
       // 获取key 存储set集合
       Set<String> set = p.stringPropertyNames();
       // 遍历数据
       for (String key : set) {
           String value = p.getProperty(key);
           System.out.println(key +"----"+value);
      }
  }
}

缓冲流

缓冲流也叫高效流

字节缓冲流 BufferedInputStream BufferedOutputStream

字符缓冲流 BufferedReader BufferedWriter

缓冲流的基原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统ID次数，从而提高读写的效率。

节流

BufferedInputStream() 创建一个新的缓冲输入流

BufferedOutputStream() 创建一个新的缓冲输出流

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DemoBufferedOutputStream {
   public static void main(String[] args) throws IOException {
       FileOutputStream fs = new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\e.txt");
       BufferedOutputStream bs = new BufferedOutputStream(fs);
       bs.write("你好".getBytes());
       bs.close();
  }
}
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DemoBufferedOutputStream {
   public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("D:\\program Files\\jichu\\src\\file\\e.txt");
       BufferedInputStream bis = new BufferedInputStream(fis);
       int len = 0;
       while ((len = bis.read())!=-1){
           System.out.println(len);
      }
       bis.close();
  }
}

文件复制

package file;
import java.io.*;
public class DemoBufferedOutputStream {
   public static void main(String[] args) throws IOException {
       long s = System.currentTimeMillis();
       // C:\Users\20185\Desktop\1.jpg
       BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\20185\\Desktop\\1.jpg"));
       // C:\Users\20185\Desktop\2.jpg
       BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\20185\\Desktop\\2.jpg"));
       byte[] bytes = new byte[1024];
       int len = 0;
       while ((len = bis.read(bytes))!=-1){
           bos.write(bytes,0,len);
      }
       bos.close();
       bis.close();
       long e = System.currentTimeMillis();
       System.out.println("共花费"+(e-s)+"毫秒");
  }
}

字符缓冲流

写文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class DemoBufferedWirte {
   public static void main(String[] args) throws IOException {
       FileWriter fw = new FileWriter("D:\\Program Files\\jichu\\src\\file\\g.txt");
       BufferedWriter bw = new BufferedWriter(fw);
       bw.write("你好");
       bw.newLine();
       bw.write("世界");
       bw.close();
  }
}

读文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class DemoBufferedWirte {
   public static void main(String[] args) throws IOException {
       BufferedReader br = new BufferedReader(new FileReader("D:\\Program Files\\jichu\\src\\file\\g.txt"));
       // 获取内容 一行输出
//       String s = br.readLine();
//       System.out.println(s);
       // 定义一个空字符
       String len ="";
       // 当字符不为null 循环打印
       while ((len = br.readLine())!=null){
           System.out.println(len);
      }
       br.close();
  }
}

文本内容排序

3.老虎没打到
4.打到小松鼠
2.上山打老虎
1.一二三四五
package file;
import java.io.*;
import java.util.HashMap;
public class DemoBufferedWirte {
   public static void main(String[] args) throws IOException {
       // 定义一个集合 存储键值
       HashMap<String,String> map = new HashMap<>();
       // 读文件
       BufferedReader br = new BufferedReader(new FileReader("D:\\Program Files\\jichu\\src\\file\\g.txt"));
       // 写文件
       BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\Program Files\\jichu\\src\\file\\out.txt"));
       // 读行文字
       String line ="";
       while ((line = br.readLine())!=null){
           // . 分割内容 存储到集合里
           String[] array = line.split("\\.");
           map.put(array[0],array[1]);
      }
       // 遍历集合 取key 和 value 重新组合
       for (String key : map.keySet()) {
           String vaule = map.get(key);
           line = key +"."+vaule;
           bw.write(line);
           bw.newLine();
      }
       bw.close();
       br.close();
  }
}
1.一二三四五
2.上山打老虎
3.老虎没打到
4.打到小松鼠

转换流

OutputStreamWrite() 写文件

InputStreatRead() 读文件

写文件

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class DemoOutputStreamWrite {
   public static void main(String[] args) throws IOException {
       OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
       osw.write("你好");
       osw.close();
  }

读文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class DemoOutputStreamWrite {
   public static void main(String[] args) throws IOException {
       InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
       int len = 0;
       while ((len = isr.read())!=-1){
           System.out.println((char)len);
      }
       isr.close();
  }

文件类型转换

gbk 转 utf-8
import java.io.*;
public class DemoOutputStreamWrite {
   public static void main(String[] args) throws IOException {
       // gbk 格式读取文件
       InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"),"gbk");
       // utf-8 格式 保存文件
       OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a1.txt"),"utf-8");
       // 读文件 二写入 utf-8的格式
       int len = 0;
       while ((len = isr.read())!=-1){
           osw.write(len);
      }
       osw.close();
       isr.close();
  }

序列化流

ObjectOutputStream() 写文件

ObjectInputStream() 读文件

特有方法：

writeObject() 写文件

readObjet() 读文件

写文件

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class DemoObjectOutputStream {
   public static void main(String[] args) throws IOException {
       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
       oos.writeObject("test");
       oos.close();
  }
}

读文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DemoObjectOutputStream {
   public static void main(String[] args) throws IOException, ClassNotFoundException {
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
       Object o = ois.readObject();
       System.out.println(o);
       ois.close();
  }
}

序列化练习

package file;
import java.io.Serializable;
public class Persin implements Serializable {
   private String name;
   private int age;
   public Persin(){}
   public Persin(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;
  }
   @Override
   public String toString() {
       return "Persin{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
  }
}
package file;
import java.io.*;
import java.util.ArrayList;
public class DemoObjectOutputStream {
   public static void main(String[] args) throws IOException, ClassNotFoundException {
       ArrayList<Persin> list = new ArrayList<>();
       list.add(new Persin("张三",18));
       list.add(new Persin("李四",19));
       list.add(new Persin("王五",20));
       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
       oos.writeObject(list);
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\Program Files\\jichu\\src\\file\\a.txt"));
       Object o = ois.readObject();
       ArrayList<Persin> list1 = (ArrayList<Persin>) o;
       for (Persin p : list1) {
           System.out.println(p);
      }
       ois.close();
       oos.close();
  }
}

打印流

PrintStream() 创建文件
import java.io.*;
public class DemoOutputStreamWrite {
   public static void main(String[] args) throws IOException {
       PrintStream ps = new PrintStream("D:\\Program Files\\jichu\\src\\file\\a.txt");
       ps.println("aaa");
       ps.println(97);
       ps.print("test");
       ps.close();
  }
}

JAVA中的那些流你知道么

字节输出流

写单个字节

写多个字节

字节追加写入换行

字节输入流

读取字节

文件复制

字符输入流

字符输出流

追加换行写入

属性集合

store写入文件

load读取文件

缓冲流

节流

文件复制

字符缓冲流

写文件

读文件

文本内容排序

转换流

写文件

读文件

文件类型转换

序列化流

写文件

读文件

打印流

热门文章

最新文章

相关课程

相关电子书

JAVA中的那些流 你知道么

字节输出流

写单个字节

写多个字节

字节追加写入 换行

字节输入流

读取字节

文件复制

字符输入流

字符输出流

追加换行写入

属性集合

store写入文件

load读取文件

缓冲流

节流

文件复制

字符缓冲流

写文件

读文件

文本内容排序

转换流

写文件

读文件

文件类型转换

序列化流

写文件

读文件

打印流

热门文章

最新文章

相关课程

相关电子书

JAVA中的那些流你知道么

字节追加写入换行