在整个IO 包中，流的操作就分两种
字节流
字节输出流 OutputStream、字节输入流 InputStream
字符流，一个字符 = 两个字节
字符输出流 Writer、字符输入流是 Reader
IO 操作的基本步骤
在java 中使用IO 操作必须按照以下的步骤完成：
1、使用File 找到一个文件
2、使用字节流或字符流的子类为OutputStream、InputStream、Writer、Reader 进行实例化操作
3、进行读或写的操作
4、关闭：close()，在流的操作中最终必须进行关闭。
字节输出流：OutputStream
在java.io 包中 OutputStream 是字节输出流的最大父类
public abstract cla OutputStream
extends Object
implements Closeable,Flushable
此类是一个抽象类，所以使用时需要依靠子类进行实例化操作
如果此时要完成文件的输出操作，则使用FileOutputStream 为 OutputStream 进行实例化操作。
OutputStream 提供了以下的写入数据方法：
写入全部字节数组： public void write(byte[] b) throws IOException
写入部份字节数组： public void write(byte[] b,int off,int len) throws IOException
定入一个数据： public abstract void wirte(int b) throws IOException
package org.ouputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutPutStreamDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化
String str = "Hello World"; //要输出的信息
byte b[] = str.getBytes(); //将String变为byte数组
opts.write(b); //写入数据
opts.close(); //关闭
}
}
以上的操作是全部的字节数组内容输出，当然，也可以通过循环一个个的输出
package org.ouputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo02 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化
String str = "Hello World"; //要输出的信息
byte b[] = str.getBytes(); 将String变为byte数组
for (int i=0;i<b.length;i++){
opts.write(b[i]); //写入数据
}
opts.close(); //关闭
}
}
但是，以上执行的时候可以发现也会存在一些问题，每次执行完之后，所有的内容将会被新的内容替换。如果希望追加内容，则需要观察FileOutputStream类的构造方法：
public FileOuputStream(File file,boolean append) throws FileNotFoundException
如果将append 的内容设置为true，则表示增加内容
package org.ouputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo02 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
OutputStream opts = new FileOutputStream(file,true); //声明字节输出流 通过子类实例化
String str = "Hello World\r\n"; //要输出的信息 "\r\n" 表示回车
byte b[] = str.getBytes(); 将String变为byte数组
for (int i=0;i<b.length;i++){
opts.write(b[i]); //写入数据
}
opts.close(); //关闭
}
}
字节输入流：InputStream
使用InputStream 可以读取输入流的内容，那么此类的定义如下：
public abstract class InputStream
extends Object
implements Closeable
此类也属于一个抽象类，那么如果要想使用的话，则肯定还是依靠其子类，如果现在是文件操作则使用是FileInputStream,FileInputStream类的构造方法：
public FileInputStream(File file) throws FileNotFoundException
实例化之后就可以通过如下的方法取得数据：
将内容读入到字节数组之中：public int read(byte[] b) throws IOException
每次读一个数据：public abstract int read() throws IOException
package org.inputstreamdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作
byte b[] = new byte[2000]; //开辟空间接收读取的内容
int len = ipts.read(b); //将内容读入到byte数组中
System.out.println(new String(b,0,len));//输出内容
ipts.close();//关闭
}
}
以上是一种比较常见的读取形式，但是以上的代码有一个缺点，会受到开辟空间的限制。如果现在想动态的开辟数组的空间，则可以根据文件的大小来决定 。采用read()方法一个个的读取数据
package org.inputstreamdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo02 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作
byte b[] = new byte[(int)file.length()]; //开辟空间接收读取的内容
for (int i=0;i<b.length;i++){
b[i] = (byte) ipts.read(); //一个个的读取数据
}
System.out.println(new String(b)); //输出内容，直接转换
ipts.close(); //关闭
}
}
字符输出流：Writer
Writer 类是在io包中操作字符的最大父类，主要功能是完成字符流的输出。Writer类的定义格式：
public abstract class Writer
extends Object
implements Appendable,Closeable,Flushable
与OutputStream 一样，都属于抽象类，如果要进行文件中的保存，则使用FileWriter
写入操作：public void write(String str) throws IOException，不用再转换
package org.writerdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件
Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化
String str = "Hello World\r\n"; //要输出的信息
wt.write(str); //写入数据
wt.close(); //关闭
}
}
程序也可以进行内容的追加： public FileWriter(File file,bollean append) throws IOException
package org.writerdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件
Writer wt = new FileWriter(file,true); //声明字符输出流 通过子类实例化 表示可以追加
String str = "Hello World\r\n"; //要输出的信息
wt.write(str); //写入数据
wt.close(); //关闭
}
}
字符输入流：Reader
字符输入流与字节输入流不同的地方在与，使用的是char 数组。Reader类的定义：
public abstract class Reader
extends Object
implements Readable,Closeable
是一个抽象类，要是现在进行文件的读取使用 FileReader
读取的方法：
读取一组字符： public int read(char[] cbuf) throws IOException
读取一个个字符： public int read() throws IOException
package org.readerdemo;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class ReaderDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作
char str[] = new char[1024]; //开辟空间接收读取的内容
int len = rd.read(str); 将内容读入到char 数组中
System.out.println(new String(str,0,len)); 输出内容
rd.close();
}}
以上完成了一个字符的输入流，那么当然也可以通过循环的方式，一个个的进行读取的操作
package org.readerdemo;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class ReaderDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作
char str[] = new char[(int) file.length()]; //开辟空间接收读取的内容
for (int i =0;i<str.length;i++){
str[i]=(char) rd.read(); //一个个的读取数据
}
System.out.println(new String(str)); //输出内容，直接转换
rd.close();
}
}
字节流与字符流的区别
以上操作的代码有两组，那么实际中应该使用那组更好呢？
为了看清楚区别，下面以一对简单的程序为例，此程序就是向文件中保存内容。
范例：使用OutputStream 完成
package org.ouputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo02 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件
OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化
String str = "Hello World"; //要输出的信息
byte b[] = str.getBytes(); 将String变为byte数组
for (int i=0;i<b.length;i++){
opts.write(b[i]); //写入数据
}
}
}
以上的程序执行时没有关闭发现内容可以正常的输出，下面再看字符流
package org.writerdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件
Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化
String str = "Hello World\r\n"; //要输出的信息
wt.write(str); //写入数据
}
}
以上的字符流并没有关闭。但是执行之后文件中并不存在内容，意味着没有输出。
但是现在使用Writer 类中的一个访法：flush()。
package org.writerdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件
Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化
String str = "Hello World\r\n"; //要输出的信息
wt.write(str); //写入数据
wt.flush(); //刷新
}
}
实际上来讲，最早的操作中，并没有刷新，但是因为使用了关闭，所以表示会强制刷新，刷新的是缓冲区（内存）
得出这样的一个结论：
字节流在操作的时候是直接与文件本身关联，不使用缓冲区
字节 --> 文件
字符流在操作的时候是通过缓冲区与文件操作
字符 --> 缓冲 --> 文件
综合比较来讲，在传输或者在硬盘上保存的内容都是以字节的形式存在的，所以字节流的操作较多，但是在操作中文的时候字符流比较好使
分享到：
相关推荐
Java中的字节流和字符流是IO操作中的两种基本类型，它们主要用于数据的输入和输出。字节流处理的数据单位是字节，而字符流处理的是Unicode字符。 字节流： 字节流主要由两个核心类构成：`InputStream`和`...
转换流：在字节流和字符流之间，Java提供了解决两者不兼容问题的转换流，即InputStreamReader和OutputStreamWriter。InputStreamReader是字节输入流到字符输入流的桥梁，而OutputStreamWriter则是字节输出流到字符...
Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。 Java 内用 Unicode 编码存储字符，字符流...
Java 字节流和字符流的区别详解 Java 中的字节流和字符流是两种不同的输入 / 输出流，它们之间的区别是非常重要的。在本文中，我们将详细介绍 Java 中的字节流和字符流的区别，并通过示例代码来演示它们的使用。 ...
与字节流一样，字符流也有缓冲的概念，可以使用 BufferedReader 和 BufferedWriter 对性能进行优化，减少与底层 I/O 操作的交互次数。 总结： Java 的 IO 流系统是基于流的，提供了对数据的读写操作。字节流适用于...
Java字节流主要包括InputStream和OutputStream两个基类及其子类，字符流则包括Reader和Writer两个基类及其子类。 首先，InputStream是所有字节输入流的父类，它提供了多个方法用于从数据源读取单个字节、字节数组或...
在Java编程语言中，输入/输出（I/O）操作是处理数据流的关键部分，而字符流与字节流则是实现这些操作的两种基本方式。理解它们的区别和应用场景对于任何Java开发者来说都是至关重要的。 ### 字节流 字节流是最基本...
### Java字符流和字节流详解 #### 一、引言 在Java中，I/O流主要用于处理输入输出操作，包括文件读写等。根据处理数据类型的不同，Java I/O流主要分为字节流和字符流两大类。字节流处理的是8位的字节数据，而字符流...
Java 字节流与字符流的介绍 Java 中的流操作可以分为两种：字节流和字符流。字节流是指以 byte 为单位进行读写操作的流...Java 的流操作分为字节流和字符流两种，字节流是最基本的，字符流是为了处理字符而提出来的。
Java IO系统分为两大类：字节流和字符流。字节流主要用于处理任何类型的原始数据，如图片、音频文件或者二进制文件，而字符流则专注于处理基于文本的数据。本文将深入探讨这两类流的原理、用途以及它们之间的关联。 ...
Java中的流被分为两类：字节流和字符流。字节流处理的是8位的数据，适用于所有类型的数据，包括图像、音频等非文本数据；字符流处理的是16位的Unicode字符，主要用于处理文本数据。 字节流分为输入流和输出流，Java...
在Java中，流分为字节流和字符流两大类，它们都是抽象的概念，用于表示数据流动的方向。字节流处理的数据单位是字节，而字符流处理的是Unicode编码的字符。 一、字节流 字节流分为输入流和输出流，Java中最基础的...
在Java编程语言中，字节流（Byte Stream）和字符流（Character Stream）是处理输入输出数据的两种基本方式。字节流主要用于处理任何类型的二进制数据，如图片、音频、视频等，而字符流则专为处理基于Unicode编码的...
### Java IO字符流和字节流详解 #### 一、引言 在Java编程中，输入输出（简称IO）操作是十分重要的一个方面。通过IO操作，我们可以读取文件、网络数据、用户输入等，也可以将数据写入到文件、网络、控制台等。Java...
Java中的字节流和字符流是处理数据输入输出的核心工具，...以上就是关于Java字节流和字符流的基本操作以及相关练习的解析，它们是Java进行数据I/O操作的基础，理解和掌握这些知识对于进行文件操作和网络通信至关重要。
Java的IO流是按照数据的流向分为输入流和输出流，按照数据类型分为字节流和字符流。字节流处理的是二进制数据，适用于任何类型的文件，包括文本文件和非文本文件（如图片、音频、视频等）。字符流则用于处理字符数据...
Java字节流是一种用于处理字节数据的流处理机制，在Java中，字节流不包含边界数据的连续流，字节流是由字节组成的，Java里字符由两个字节组成。字节流是最基本的，它是按字节来处理二进制数据。 字节流基类有：字节...
在Java编程语言中，字节流（Byte Stream）和字符流（Character Stream）是处理输入输出数据的两种基本方式。它们构成了Java I/O系统的核心，用于读写文件、网络通信等场景。字节流和字符流的区别在于处理数据的基本...
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、...代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。