Java(字节流、字符流、缓冲流、转换流、序列化流)

最新推荐文章于 2023-11-26 23:10:25 发布
置顶 最新推荐文章于 2023-11-26 23:10:25 发布
阅读量193 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yzc_start/article/details/100663973
版权
顶级父类们
字节流

字节输出流【OutputStream】

  • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输
    出到此输出流。
  • public abstract void write(int b) ：将指定的字节输出流。
    - close方法，当完成流的操作时，必须调用此方法，释放系统资源

FileOutputStream类
构造方法

  • public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件
public class FileOutputStreamConstructor throws IOException {
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("b.txt");
}
}

写出字节数据
1.写出字节： write(int b) 方法，每次可以写出一个字节数据

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写出数据
fos.write(97); // 写出第1个字节
fos.write(98); // 写出第2个字节
fos.write(99); // 写出第3个字节
// 关闭资源
fos.close();
}
}
输出结果：
abc

2.写出字节数组： write(byte[] b) ，每次可以写出数组中的数据

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "黑马程序员".getBytes();
// 写出字节数组数据
fos.write(b);
// 关闭资源
fos.close();
}
}
输出结果：
黑马程序员

3.写出指定长度字节数组： write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

package main.yzc.backOffice.test;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("a.txt");
        byte[] bytes = "abcd".getBytes();
        fos.write(bytes,2,2);
        fos.close();
    }
}

数据追加续写

  • public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的
    文件。
  • public FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件
package main.yzc.backOffice.test;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("a.txt",true);
        byte[] bytes = "你好".getBytes();
        fos.write(bytes);
        fos.close();
    }
}

写出换行
Windows系统里，换行符号是 \r\n

public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 定义字节数组
byte[] words = {97,98,99,100,101};
// 遍历数组
for (int i = 0; i < words.length; i++) {
// 写出一个字节
fos.write(words[i]);
// 写出一个换行, 换行符号转成数组写出
fos.write("\r\n".getBytes());
}
// 关闭资源
fos.close();
}
}
输出结果：
a
b
c
d
e

字节输入流【InputStream】
java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入
流的基本共性功能方法。

  • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
  • public abstract int read() ： 从输入流读取数据的下一个字节。
  • public int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

FileInputStream类
构造方法

  • FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系
    统中的 File对象 file命名。
  • FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件
    系统中的路径名 name命名。
public class FileInputStreamConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("b.txt");
}
}

读取字节数据
1.读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fis.read())!=‐1) {
System.out.println((char)b);
}
// 关闭资源
fis.close();
}
}
输出结果：
a
b
c
d
e

2.使用字节数组读取： read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1

public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量，作为有效个数
int len ；
// 定义字节数组，作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=‐1) {
// 每次读取后,把数组的有效字节部分，变成字符串打印
System.out.println(new String(b，0，len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
}
}
输出结果：
ab
cd
e

字节流练习：图片复制

public class Copy {
public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 指定数据源
FileInputStream fis = new FileInputStream("D:\\test.jpg");
// 1.2 指定目的地
FileOutputStream fos = new FileOutputStream("test_copy.jpg");
// 2.读写数据
// 2.1 定义数组
byte[] b = new byte[1024];
// 2.2 定义长度
int len;
// 2.3 循环读取
while ((len = fis.read(b))!=‐1) {
// 2.4 写出数据
fos.write(b, 0 , len);
}
// 3.关闭资源
fos.close();
fis.close();
}
}
字符流

字符输入流【Reader】

  • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  • public int read() ： 从输入流读取一个字符。
  • public int read(char[] cbuf) ： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

FileReader类

  • FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。
public class FileReaderConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);
// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");
}
}

读取字符数据
1.读取字符： read 方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1 ，循环读取

public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fr.read())!=‐1) {
System.out.println((char)b);
}
// 关闭资源
fr.close();
}
}
输出结果：
黑
马
程
序
员

2.使用字符数组读取： read(char[] cbuf) ，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1

public class FISRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存有效字符个数
int len ；
// 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=‐1) {
System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
}
}
输出结果：
黑马
程序
员

字符输出流【Writer】

  • void write(int c) 写入单个字符。
  • void write(char[] cbuf) 写入字符数组。
  • abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,off数组的开始索引,len
    写的字符个数。
  • void write(String str) 写入字符串。
  • void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个
    数。
  • void flush() 刷新该流的缓冲。
  • void close() 关闭此流，但要先刷新它。

FileWriter类
构造方法

  • FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称
public class FileWriterConstructor {
public static void main(String[] args) throws IOException {
// 使用File对象创建流对象
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("b.txt");
}
}

写出字符： write(int b) 方法，每次可以写出一个字符数据

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
fw.write('C'); // 写出第3个字符
fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区，并未保存到文件。
*/
fw.close();
}
}
输出结果：
abC田

写出字符数组 ： write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串转换为字节数组
char[] chars = "黑马程序员".toCharArray();
// 写出字符数组
fw.write(chars); // 黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(b,2,2); // 程序
// 关闭资源
fos.close();
}
}

写出字符串： write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的
数据，更为方便

public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串
String msg = "黑马程序员";
// 写出字符数组
fw.write(msg); //黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(msg,2,2); // 程序
// 关闭资源
fos.close();
}
}

续写和换行：操作类似于FileOutputStream。

IO异常的处理

JDK7前处理
之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用 try…catch…finally 代码块

JDK7的处理(扩展知识点了解内容)
还可以使用JDK7优化后的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

JDK9的改进(扩展知识点了解内容)
JDK9中 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close

缓冲流

概述：
缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：

  • 字节缓冲流： BufferedInputStream ， BufferedOutputStream
  • 字符缓冲流： BufferedReader ， BufferedWriter

字节缓冲流
构造方法

  • public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
  • public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率

public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 读写数据
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != ‐1) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");
}
}
缓冲流使用数组复制时间:666 毫秒

字符缓冲流
构造方法

  • public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
  • public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

  • BufferedReader： public String readLine() : 读一行文字。
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("‐‐‐‐‐‐");
}
// 释放资源
br.close();
}
}
  • BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("黑马");
// 写出换行
bw.newLine();
bw.write("程序");
bw.newLine();
bw.write("员");
bw.newLine();
// 释放资源
bw.close();
}
}
输出效果:
黑马
程序
员
转换流

InputStreamReader类
构造方法

  • InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
  • InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class ReaderDemo2 {
public static void main(String[] args) throws IOException {
// 定义文件路径,文件为gbk编码
String FileName = "E:\\file_gbk.txt";
// 创建流对象,默认UTF8编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
// 创建流对象,指定GBK编码
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
int read;
// 使用默认编码字符流读取,乱码
while ((read = isr.read()) != ‐1) {
System.out.print((char)read); // ��Һ�
}
isr.close();
// 使用指定编码字符流读取,正常解析
while ((read = isr2.read()) != ‐1) {
System.out.print((char)read);// 大家好
}
isr2.close();
}
}

OutputStreamWriter类
构造方法

  • OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
  • OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

public class OutputDemo {
public static void main(String[] args) throws IOException {
// 定义文件路径
String FileName = "E:\\out.txt";
// 创建流对象,默认UTF8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
// 写出数据
osw.write("你好"); // 保存为6个字节
osw.close();
// 定义文件路径
String FileName2 = "E:\\out2.txt";
// 创建流对象,指定GBK编码
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
// 写出数据
osw2.write("你好");// 保存为4个字节
osw2.close();
}
}

练习：转换文件编码

1. 指定GBK编码的转换流，读取文本文件。
2. 使用UTF-8编码的转换流，写出文本文件。

public class TransDemo {
public static void main(String[] args) {
// 1.定义文件路径
String srcFile = "file_gbk.txt";
String destFile = "file_utf8.txt";
// 2.创建流对象
// 2.1 转换输入流,指定GBK编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
// 2.2 转换输出流,默认utf8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
// 3.读写数据
// 3.1 定义数组
char[] cbuf = new char[1024];
// 3.2 定义长度
int len;
// 3.3 循环读取
while ((len = isr.read(cbuf))!=‐1) {
// 循环写出
osw.write(cbuf,0,len);
}
// 4.释放资源
osw.close();
isr.close();
}
}
序列化

1.概述：Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、 对象的类型 和 对象中存储的属性 等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型 和 对象中存储的数据 信息，都可以用来在内存中创建对象

ObjectOutputStream类
构造方法

  • public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的
    ObjectOutputStream。
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

  1. 一个对象要想序列化，必须满足两个条件:
  • 该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
  • 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int age; // transient瞬态修饰成员,不会被序列化
public void addressCheck() {
System.out.println("Address check : " + name + " ‐‐ " + address);
}
}
  1. 写出对象方法
    public final void writeObject (Object obj) : 将指定的对象写出。
public class SerializeDemo{
public static void main(String [] args) {
Employee e = new Employee();
e.name = "zhangsan";
e.address = "beiqinglu";
e.age = 20;
try {
// 创建序列化流对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
// 写出对象
out.writeObject(e);
// 释放资源
out.close();
fileOut.close();
System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列
化。
} catch(IOException i) {
i.printStackTrace();
}
}
}
输出结果：
Serialized data is saved

ObjectInputStream类
构造方法

  • public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

  • public final Object readObject () : 读取一个对象。
public class DeserializeDemo {
public static void main(String [] args) {
Employee e = null;
try {
// 创建反序列化流
FileInputStream fileIn = new FileInputStream("employee.txt");
ObjectInputStream in = new ObjectInputStream(fileIn);
// 读取一个对象
e = (Employee) in.readObject();
// 释放资源
in.close();
fileIn.close();
}catch(IOException i) {
// 捕获其他异常
i.printStackTrace();
return;
}catch(ClassNotFoundException c) {
// 捕获类找不到异常
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
// 无异常,直接打印输出
System.out.println("Name: " + e.name); // zhangsan
System.out.println("Address: " + e.address); // beiqinglu
System.out.println("age: " + e.age); // 0
}
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个
ClassNotFoundException 异常。

反序列化操作2
另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操
作也会失败，抛出一个 InvalidClassException 异常。发生这个异常的原因如下：

  • 该类的序列版本号与从流中读取的类描述符的版本号不匹配
  • 该类包含未知数据类型
  • 该类没有可访问的无参数构造方法
public class Employee implements java.io.Serializable {
// 加入序列版本号
private static final long serialVersionUID = 1L;
public String name;
public String address;
// 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
public int eid;
public void addressCheck() {
System.out.println("Address check : " + name + " ‐‐ " + address);
}
}

练习：序列化集合

  1. 把若干学生对象 ，保存到集合中。
  2. 把集合序列化。
  3. 反序列化读取时，只需要读取一次，转换为集合类型。
  4. 遍历集合，可以打印所有的学生信息
public class SerTest {
public static void main(String[] args) throws Exception {
// 创建 学生对象
Student student = new Student("老王", "laow");
Student student2 = new Student("老张", "laoz");
Student student3 = new Student("老李", "laol");
ArrayList<Student> arrayList = new ArrayList<>();
arrayList.add(student);
arrayList.add(student2);
arrayList.add(student3);
// 序列化操作
// serializ(arrayList);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
// 读取对象,强转为ArrayList类型
ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
for (int i = 0; i < list.size(); i++ ){
Student s = list.get(i);
System.out.println(s.getName()+"‐‐"+ s.getPwd());
}
}
private static void serializ(ArrayList<Student> arrayList) throws Exception {
// 创建 序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
// 写出对象
oos.writeObject(arrayList);
// 释放资源
oos.close();
}
}
打印流

PrintStream类
构造方法

  • public PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流
PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

public class PrintDemo {
public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);
}
}
Yzc_start
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现字节流与图片的转化
01-09
Java实现字节流与图片的转化
day21_缓冲流、转换流、序列化流、Commons IO.pdf
11-02
它们分别将字节流转换为字符流和将字符流转换为字节流，主要处理字符编码问题。例如，我们可以使用`InputStreamReader`与`BufferedReader`组合，或者`OutputStreamWriter`与`BufferedWriter`组合，以实现高效的字符...
Java IO 转换流 字节转字符流
ddmm2012的博客
09-01 298
Java IO 转换流 字节转字符流 @author ixenos 字节流 输入字节流：---------| InputStream 所有输入字节流的基类。 抽象类。------------| FileInputStream 读取文件的输入字节流。------------| BufferedInputStream 缓冲输入字节流。 该类内部其实就是维护了...
Java SE（九）之 IO流（字节流，字符流，缓冲流）
ji_meng的博客
10-05 661
I表示intput，把硬盘文件中的数据读入到内存的过程，称之输入，负责读；O表示output，把内存中的数据写出到硬盘文件的过程，称之输出，负责写。File：它是文件和目录路径名的抽象表示文件和目录是可以通过File封装成对象的；File类的对象代表操作系统的文件，File封装了对文件进行：删除、获取信息、创建文件或文件夹等操作。但是不能读写文件内容；对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已（可以存在或不存在）将来是要通过具体的操作把这个路径的内容转换为具体存在的。
Java——I/O流之字节、字符缓冲流
程序员阿龙的博客
07-28 292
缓冲流,也叫高效流，是对4个基本的`FileXxx`流的增强，所以也是4个流，按照数据类型分类通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。下面就是缓冲流的两个类写数据读数据。...
缓冲字节流 java_Java 带缓冲的字节流和字符流
weixin_42116672的博客
02-15 291
输入流就是文件从硬盘到内存的中间媒介，那么输出流就是文件从内存到硬盘的中间媒介。首先来看看FileOutputStream的继承了哪些类，java.lang.Objectjava.io.OutputStreamjava.io.FileOutputStream具体该类如何实现，我们还是结合以下代码来看。importjava.io.*;publicclassFileOutputStreamTest01...
ByteIO_java_字节流_
10-04
总的来说，`ByteIO.java`文件可能包含了字节流的基本用法，如文件读写、数据传输、缓冲优化等。通过学习和理解这段代码，开发者可以深入理解Java字节流的工作原理，提升在处理二进制数据和网络通信时的能力。
Java编程中字节流与字符流IO操作示例
09-02
总的来说，Java中的IO流操作涉及大量的类和方法，包括转换流（如`BufferedReader`和`BufferedWriter`）、过滤流（如`FilterReader`和`FilterWriter`）以及更高级的流操作，如对象序列化。理解这些基本概念和操作，...
IO流与序列化
05-09
3. **转换流**：InputStreamReader和OutputStreamWriter用于在字节流和字符流之间转换，支持不同的字符编码。 4. **数据流**：DataInputStream和DataOutputStream允许读写基本数据类型，如int、double等，常用于二...
JavaIO字节输出流的总结共6页.pdf.zip
11-22
- `ObjectOutputStream`允许我们将Java对象转换为字节流，实现对象的序列化，便于存储或网络传输。 6. **转换字节流OutputStreamWriter** - 当需要从字节流转换为字符流时，可以使用`OutputStreamWriter`。它内部...
详述java中的字符流、字节流与缓冲流
YJT180的博客
09-27 194
在java中，文件的输入和输出通过流（stream）来实现，而输入的英文为Input,输出的英文为Output，因此，java中传输文件的途径又叫做IO流。流按照处理数据的单位，可以分为字节流和字符流；按照流向分为输入流和输出流（注意：输入流和输出流都是站在程序的角度参照的）。 字节流 •字节流用于处理以字节为单位的二进制文件（如音乐、图片等） 字节流的输入流 •InputSt...
JAVA，IO的字符、字节流，缓冲流，转换流，打印流
小道仙的后宫
01-31 1331
本文主要介绍，字符，字节流，缓冲流，转换流，打印流。 一，字节流（输出，输入）： 1，输出流（字节输出流），写入方法写入，可以写一个字节，字节片段，也可以规定写入一部分字节的一部分。2，InputStream（字节输入流），读取方法读取，可以读一个字节，字节片段，也可以规定读取某些字节片段的一部分。字符 流（Reader，Writer）：1，FileWriter（字符输出流），写入方法写入，可以...
Java IO流、字节流、字符流、缓冲流、对象操作流、Properties基础详解
weixin_46665411的博客
11-12 579
byte[] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中。byte[] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中。比如说IO流中的释放资源。可以把对象以字节的形式写到本地文件中，直接打开文件，是都不懂的，需要再次用对象操作流读到内存中。对象操作输出流（对象反序列化流）：把写到本地文件中的对象读到内存中，或者接收网络中传输的对象。
【Java语言面向对象】（82）字节字符转换流
FairyKunKun的博客
03-08 220
字节流可以读字符类的文件(FileInputStream)，字符流也可以读取字符类的文件(FileReader) FileInputStream ----->转换成---->FileReader? 如果能转 InputStream ---->Reader package com.njwbhz.march.week2.part0308; import java.io.*; public class TestStream..
java转换流（字节流转换成字符流）
最新发布
weixin_50208718的博客
11-26 705
1.InputStreamReader是Reader的子类，可以将InputStream（字节流）包装（转换）成Reader(转换流)。2.OutputStreamWiter是Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)。3.当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文乱码问题，所以建议将字节流转换成字符流。4.可以在使用时指定编码格式（比如 utf-8，gbk，gb2312，ISO8859-1等）。
Java 转换流
热门推荐
博客
04-18 1万+
开发工具与关键技术：Java 、MyEclipse 作者：邹赛 撰写时间：2019/4/16 Java IO流中提供了两种用于将字节流转换为字符流的转换流。其中InputStreamReader用于将字节输入流转换为字符输入流，其中OutputStreamWriter用于将字节输出流转换为字符输出流。使用转换流可以在一定程度上避免乱码，还可以指定输入输出所使用的字符集 1、OutputStream...
字节字符转换流
tianhumanong的博客
04-23 1290
转换流：以将一个字节流转换为字符流，也可以将一个字符流转换为字节流 字节字符转换流位于java.io包 1.OutputStreamWriter类 OutputStreamWriter：可以将输出的字符流转换为字节流的输出形式 字符流转换成字节流图解 ...
Java字节流转换 如何实现数据类型的转换
我点评的博客
07-17 618
字节流转换就是将不同的数据类型转换为字节序列，或者将字节序列转换为不同的数据类型。DataInputStream可以将字节流转换为Java基本数据类型，如int、double、float等，而DataOutputStream可以将Java基本数据类型转换为字节流。而字节流转换则是实现这种转换的一种方法，它可以将不同的数据类型转换为字节流，或者将字节流转换为不同的数据类型。本文将介绍如何使用Java字节流转换实现数据类型的转换。通过本文，我们了解了Java字节流转换的基本概念，并且实现了数据类型的转换。
java超长字符序列化_转载：Java的字节流、字符流和序列化区别
weixin_28751115的博客
02-25 72
原文出处链接：https://blog.csdn.net/qq_17310871/article/details/100516118Java IO流牢记六个字：读进来，写出去对象序列化对象序列化与反序列化：将Java对象转变成字节流存储，称之为对象序列化。从字节流中恢复一个Java对象，称之为对象反序列化。 即是说，将对象转化为二进制，用于保存，或者网络传输。序列化资格：只有实现了 Seriali...
提升IO效率：缓冲流、转换流与序列化流详解
在第21天的学习中，我们将深入探讨Java中三种强大的高级流：缓冲流、转换流和序列化流。这些流是在基础IO流之上构建的，旨在提升数据处理的效率和灵活性。 1. 缓冲流（也称为高效流）是Java IO流的重要扩展，针对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值