在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据时要使用输入流读取数据，而当程序需要将一些数据保存起来时，就要使用输出流。
在java.io包中流的操作主要有字节流、字符流两大类，两类都有输入和输出操作。
在字节流中输出数据主要使用OutStream类完成，输入使用的是InputStream类。
在字符流中输出主要使用Write类完成，输入主要是使用Reader类完成。
字节流
字节流主要操作byte类型数据，以byte数组为准，主要操作类是OutputStream类和InputStream类。
<1>字节输出流：OutputStream类
OutputStream是整个IO包中字节输出流的最大父类
向文件中写入字符串
文件不存在则会自动创建
直接将一个字符串变为byte数组，然后将byte数组直接写入到文件中
import java.io.File;
import java.io.OutputStream;
import java.io.FileOutputStream;
//Function : 向文件中写入字符串
public class OutputStream_demo {
public static void main(String[] args) throws Exception { //异常抛出，不处理
// TODO 自动生成的方法存根
//第一步，找到一个文件
File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
//第二步，通过子类实例化父类对象
OutputStream out = null; //准备好一个输出的对象
out = new FileOutputStream(f); //通过对象多态性，进行实例化
//第三步，进行写操作
String str = "HelloWord"; //准备一个字符串
byte b[] = str.getBytes(); //只能输出byte数组，所以将字符串变成byte数组
out.write(b); //将内容输出，保存文件
//第四步，关闭输出流
out.close(); //关闭输出流
}
}
追加新内容
可以通过FileOutputStream向文件中追加内容。
import java.io.File;
import java.io.OutputStream;
import java.io.FileOutputStream;
//Function : 向文件中写入字符串
public class OutputStream_demo {
public static void main(String[] args) throws Exception { //异常抛出，不处理
// TODO 自动生成的方法存根
//第一步，找到一个文件
File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
//第二步，通过子类实例化父类对象
OutputStream out = null; //准备好一个输出的对象
// out = new FileOutputStream(f); //通过对象多态性，进行实例化
out = new FileOutputStream(f,true); //此处表示在文件末尾追加内容
//第三步，进行写操作
String str = "HelloWord"; //准备一个字符串
byte b[] = str.getBytes(); //只能输出byte数组，所以将字符串变成byte数组
// out.write(b); //将内容输出，保存文件
for(int i=0;i<b.length;i++){
out.write(b[i]);
}
//第四步，关闭输出流
out.close(); //关闭输出流
}
}
<2>字节输入流：InputStream类
和OutputStream一样，InputStream也是抽象类，必须依靠子类
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
//Function : 从文件中读取内容
public class InputStream_demo {
public static void main(String[] args) throws Exception { //异常抛出，不处理
// TODO 自动生成的方法存根
//第一步，找到一个文件
File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
//第二步，通过子类实例化父类对象
InputStream input = null; //准备好一个输出的对象
input = new FileInputStream(f); //通过对象多态性，进行实例化
//第三步，进行读操作
// byte b[] = new byte[1024]; //所有的内容读到此数组中
byte b[] = new byte[(int)f.length()]; //所有的内容读到此数组中，数组大小由文件决定
// input.read(b); //把内容取出，内容读到byte数组中
int len = input.read(b);
//第四步，关闭输入流
input.close();
System.out.println("读入数据的长度："+len); //没有多余的空格产生
System.out.println("内容为："+new String(b,0,len));//把byte数组变为字符串输出
// System.out.println("内容为："+new String(b));//把byte数组变为字符串输出
}
}
在IO包中，提供了两个与平台无关的数据操作流，分别是数据输出流(DataOuputStream)和数据输入流(DataInputStream).
1.写入数据
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//Function : DataOuputStream_demo;
public class DataOutputStream_demo {
public static void main(String[] args) throws Exception {
// TODO 自动生成的方法存根
DataOutputStream dos = null; //声明数据输出流对象
File f = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
dos = new DataOutputStream(new FileOutputStream(f)); //实例化数据输出流对象
String names[] = {"衬衣","手套","围巾"};
float prices[] = {98.3f,30.0f,50.5f};
int nums[] = {3,2,1};
for(int i=0;i<names.length;i++){ //循环写入
dos.writeChars(names[i]); //写入字符串
dos.writeChar('\t'); //加入分隔符
dos.writeFloat(prices[i]); //写入字符串
dos.writeChar('\t'); //加入分隔符
dos.writeInt(nums[i]); //写入字符串
dos.writeChar('\t'); //加入分隔符
}
dos.close();
}
}
2.读取数据
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//Function : DataInputStream_demo;
public class DataInputStream_demo {
public static void main(String[] args) throws Exception {
// TODO 自动生成的方法存根
DataInputStream dis = null; //声明数据输出流对象
File f = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
dis = new DataInputStream(new FileInputStream(f)); //实例化数据输出流对象
String name = null;
float price = 0.0f;
int num = 0;
char temp[] = null;
char c = 0; //存放接收的字符
int len = 0; //接收的字符的个数
try{
while(true){
temp = new char[200];
len = 0;
while((c=dis.readChar()) != '\t'){ //读取字符
temp[len] = c; //接收内容
len++; //读取长度加1
}
name = new String(temp,0,len); //将字符数组变成String
price = dis.readFloat(); //读取float
dis.readChar(); //读取\t
num = dis.readInt(); //读取int
dis.readChar(); //读取\n
System.out.printf("名称：%s,名称：%5.2f,名称：%d\n",name,price,num);
}
}catch(Exception e){
e.printStackTrace();
}
dis.close();
}
}
字符流
在程序中一个字符等于两个字节，Java提供了Reader和Writer两个专门操作字符流的类。
<1>字符输出流Writer
也是一个抽象类
和OutputStream相比，可以直接输出字符串，而不用将字符串变为byte数组之后再输出。
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.Writer;
//Function : 向文件中写入内容
public class Write_demo {
public static void main(String[] args) throws Exception{
// TODO 自动生成的方法存根
//第一步，找到一个文件
File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
//第二步，通过子类实例化父类对象
Writer out = null; //准备好一个输出的对象
// out = new FileWriter(f); //通过对象多态性，进行实例化
out = new FileWriter(f,true); //通过对象多态性，进行实例化
//第三步，进行写操作
String str = "HelloWord!!!"; //准备一个字符串
out.write(str); //把内容取出，内容读到byte数组中
//第四步，关闭输入流
out.close();
}
}
<2>字符输入流Reader
Reader是使用字符的方式从文件中取出数据
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
//Function : 从文件中读取内容
public class Reader_demo {
public static void main(String[] args) throws Exception {
// TODO 自动生成的方法存根
//第一步，找到一个文件
File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
//第二步，通过子类实例化父类对象
Reader reader = null; //准备好一个输出的对象
reader = new FileReader(f); //通过对象多态性，进行实例化
//第三步，进行读操作
char c[] = new char[1024]; //所有的内容读到此数组中
int len = reader.read(c); //将内容输出
//第四步，关闭输入流
reader.close(); //关闭输入流
System.out.println("内容为："+new String(c,0,len)); //把char数组变为字符串输出
}
}
字节流与字符流的区别
字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的
字符流在操作时使用了缓冲区，通过缓冲区再操作文件
如果一个程序频繁地操作一个资源（如文件或者数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
使用字节流更好