JAVA中的那些流 你知道么

本文涉及的产品
系统运维管理,不限时长
简介: 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();
  }
}
相关文章
|
4月前
|
存储 缓存 Oracle
可能是最漂亮的Java I/O流详解
大家有什么思路吗?评论区一起讨论讨论。我需要使用 Java 逐行读取大约 5-6 GB 的大型文本文件。我怎样才能快速完成此操作?最高赞的回答是叫Peter Lawrey的老哥回答的。大家好,我是南哥。一个Java学习与进阶的领路人,今天指南的是Java I/O流,跟着南哥我们一起在Java之路上成长。本文收录在我开源的《Java学习进阶指南》中,涵盖了想要学习Java、成为更好的Java选手都在偷偷看的核心知识、面试重点。
121 1
可能是最漂亮的Java I/O流详解
|
6月前
|
Java 数据处理
|
6月前
|
Java API
Java中的流
Java中的流
23 0
Java中的流
|
6月前
|
Java 数据处理
JAVA流概述
JAVA流概述
34 1
|
6月前
|
Java
【Java】深入了解Java I/O 流
【Java】深入了解Java I/O 流
60 0
|
6月前
|
Java
Java输入输出:什么是Java中的流(Stream)?
Java输入输出:什么是Java中的流(Stream)?
41 1
|
6月前
|
SQL 存储 分布式计算
|
存储 编解码 Java
Java特殊操作流
Java特殊操作流
39 0
Java特殊操作流
|
存储 Java BI
Java流Strem 2
Java流Strem
45 0
|
存储 Java 关系型数据库
Java流Strem 1
Java流Strem
36 0