Java输入输出流学习笔记
一、基本概念
1、按照功能划分为输入流和输出流
输入流 ：只能从中读取数据，而不能向其写出数据
输出流： 只能向其写数据，而不能从中读取数据
输入和输出流：可以被连接到文件、网络套接字或内存缓冲区。
2、按处理数据的单位划分字节流和字符流
二、输入数据流
输入数据流（InputStream）指只能读不能写的数据流，**用于向计算机内输入信息**。java.io包中所有输入数据流都是由抽象类**InputStream**继承而来。从数据流中读取数据时，必须有一个**数据源**与该数据流相连。
输入数据流InputStream中提供的主要数据操作方法：
int read():读一个整数
**int read(byte b[ ]):读多个字节到数组中**
**int read(byte[ ] b,int off,int len)：从何位置开始填入多少字节**
void close() 关闭数据流，同时释放与该数据流相关的资源
int available()返回从数据流中读取的字节数（实际的读操作所读得的字节数可能大于 该返回值）
**示例：从控制台获得用户输入并在控制台上输出。**
import java.io.IOException;
import java.io.InputStream;
public class Echo {
public static void main(String[] args) {
InputStream is = System.in; // 定义InputStream对象
byte[] bytes = new byte[1024];
try {
System.out.println("请输入字符串：");// 提示用户输入字符串
is.read(bytes);// 将输入的字符串保存在数组中
String input = new String(bytes);// 将数组中的内容转换成字符串
System.out.println("您输入的字符串：" + input.trim());// 输出字符串 ，忽略前导空白和尾部空白。
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();// 释放资源
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
三、输出数据流
输出数据流（Output Stream）是指只能写不能读的流，**用于从计算机中输出数据**。java.io包中所有输出数据流大多是从抽象类OutputStream继承而来
**OutputStream类的方法包括：**
write(int b)：将一个整数输出到流中
**write(byte b[ ])：将数组中的数据输出到流中**
**write(byte b[ ], int off,int len)将数组b中从off指定的位置开始len长度的数据输出到流中**
**void flush()：将缓冲区中的数据强制送出**
void close()：关闭流。
**示例：创建OutputStream实例out，并将其赋值为System.out标准输出流。通过write()方法向流中写数据。
**
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDemo {
public static void main(String[] args) {
OutputStream out = System.out; // 实例化OutputStream类
try { // 创建byte数组
byte[] bs = "本实例使用OutputStream输出流，在控制台输出字符串\n".getBytes();
out.write(bs); // 向流中写数据
bs = "输出内容：\n".getBytes();
out.write(bs);
bs = "学习Java很快乐".getBytes();
out.write(bs);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
out.close();// 关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
文件数据流
文件数据流包括FileImputStream和FileOutputStream,用来进行文件的I/O处理，其数据源都应当是文件。
对文件操作要定义文件流。FileInputStream类用来打开一个输入文件，FileOutputStream类用来打开一个输出文件
文件对象的建立：File fp=new File(“tempfile.txt”);
文件流的建立： FileInputStream in=new FileInputStream(fp); FileOutputStream out=new FileOutputStream(fp);
示例：使用FileInputStream类读取E盘text文件夹下的word.txt文件，并将读取结果输出到控制台。
import java.io.*;
public class FileInputStreamDemo {
public static void main(String[] args) {
File file = new File("E:\\text\\word.txt"); // 创建文件对象
try {
FileInputStream fis = new FileInputStream(file); // 创建FileInputStream类对象
int length;
byte by[] = new byte[1024]; // 创建byte对象
while ((lenght = fis.read(by)) != -1) { // 循环读取文件中数据
String str = new String(by, 0, length); // 根据读取信息创建字符串对象
System.out.println("从文件中读取出的数据是：\n" + str); // 输出信息
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
示例：使用FileOutputStream类实现向指定文件中写文件的功能。
import java.io.*;
public class FileOutputStreamDemo {
public static void main(String[] args) {
try {
File file = new File("E://text//writeFile.txt"); // 创建文件对象
if (!file.exists()) { // 如果该文件不存在
file.createNewFile(); // 新建文件
}
FileOutputStream fos = new FileOutputStream(file); // 创建FileOutputStream实例
byte[] bytes = "Java 编程词典软件,学Java必备。".getBytes(); // 创建字节数组
fos.write(bytes); // 向文件中写数据
} catch (Exception e) {
e.printStackTrace();
}
}
}
四、缓冲区数据流
1、缓冲区输入流：BufferedInputStream
与文件流相接：
FileInputStream in=new FileInputStream(“file1.txt”);
BufferedInputStream bin= new BufferedInputStream(in)
BufferedInputStream bin1= new BufferedInputStream(in, 256)
2、缓冲区输出流：BufferedOutputStream
与文件流相接：
FileInputStream os=new FileInputStream(“file2.txt”);
BufferedOutputStream bos=new BufferedOutputStream(os)
BufferedOutputStream bos1 = new BufferedOutputStream(os,256)
**示例:使用BufferedOutputStream类向E盘的Getif.txt文件中写数据。**
import java.io.*;
public class BufferedOutputStreamDemo {
public static void main(String[] args) {
try {
File file = new File("E://Getif.txt"); // 创建文件对象
if (!file.exists()) { // 如果该对象不存在
file.createNewFile(); // 新建文件
}
FileOutputStream fos = new FileOutputStream(file); // 创建FileOutputStream对象
BufferedOutputStream bus = new BufferedOutputStream(fos);
byte[] by = "香蕉 ".getBytes(); // 创建字节数组
bus.write(by); // 向流中写数据
byte[] by2 = "苹果 ".getBytes();
bus.write(by2);
byte[] by3 = "橘子 ".getBytes();
bus.write(by3);
bus.flush(); // 刷新缓存输入流
bus.close(); // 关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
注意：只有缓冲区满时,才会将数据送到输出流。Java在输出数据流中,当对方尚未将数据取走时,程序就会被阻塞。有时要人为地将尚未填满的缓冲区中的数据送出,使用flush()方法.
五、数据输入输出流
DataInputStream和DataOutputStream：一种较为高级的数据输入输出方式，除了字节和字节数组,还可以处理int,float,boolean等类型。还可以用readLine()方法读取一行信息。创建方式如下：
FileInputStream is=new FileInputStream (”file1.txt"));
FileOutputStream os=new FileOutputStream(”file2.txt"));
DataInputStream dis = new DataInputStream(is);
DataOutputStream dos = new DataOutputStream(os);
注意：DataInputStream的方法与DataOutputStream的方法都是成对出现的 。
示例：
import java.io.*;
public class datainput_output {
public static void main(String args[]) throws IOException {
FileOutputStream fos = new FileOutputStream("e:\\text\\a.txt");
DataOutputStream dos = new DataOutputStream(fos);
try {
dos.writeBoolean(true);
dos.writeByte((byte) 123);
dos.writeChar('J');
dos.writeDouble(3.141592654);
dos.writeFloat(2.7182f);
dos.writeInt(1234567890);
dos.writeLong(998877665544332211L);
dos.writeShort((short) 11223);
} finally {
dos.close();
}
DataInputStream dis = new DataInputStream(new FileInputStream("e:\\text\\a.txt"));
try {
System.out.println("\t " + dis.readBoolean());
System.out.println("\t " + dis.readByte());
System.out.println("\t " + dis.readChar());
System.out.println("\t " + dis.readDouble());
System.out.println("\t " + dis.readFloat());
System.out.println("\t " + dis.readInt());
System.out.println("\t " + dis.readLong());
System.out.println("\t " + dis.readShort());
} finally {
dis.close();
}
}
}
**六、管道数据流 PipedInputStream PipedOutputStream **
管道数据流主要用于**线程间的通信**。一个线程中的PipedInputStream对象从另一个线程中互补的PipedOutputStream对象中接收输入数据。类PipedInputStream必须和类PipedOutputStream一起使用，来建立一个通信通道管道数据流必须同时具备可用的输入端和输出端 。
**创建通信通道方式1：**
步骤：
1、建立输入数据流：PipedInputStream pis = new PipedInputStream()
2、建立输出数据流：PipedOutputStream pos = new PipedOutputStream ()
3、输入数据流和输出数据流连起来：pis.connect(pos)或者pos.connect(pis)
**创建通信通道方式1：**
直接将输入流与输出流连接起来 ：
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream(pis);
或：
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream(pos);
示例：例:将数据从输出管道进,从输入管道出.
import java.io.*;
class pipedstream {
public static void main(String args[]) throws IOException {
byte aByteData1 = 123, aByteData2 = 111;
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream(pis);
System.out.println("PipedInputStream");
try {
pos.write(aByteData1);
pos.write(aByteData2);
System.out.println( pis.read());
System.out.println( pis.read());
} finally {
pis.close();
pos.close();
}
}
}
七、文件的处理
File类提供了获得文件基本信息及操作文件的一些工具。创建一个新的File对象有三种构造方法：
File myFile= new File("mymotd");
myFile = new File("F:/ok/"，"mymotd");
File myDir = new File("F:/ok/ ");
myFile = new Fle(myDir，"mymotd");
与文件名相关的方法：
String getName() 获取文件名
String getPath() 获取文件路径
String getAbsolutePath() 获取文件绝对路径
String getParent() 获取文件父目录名称
boolean renameTo(File newName) 更改文件名，成功则返回true，否则返回false
boolean isDirectory() 文件对象是否是目录
long length() 获取文件长度
boolean canRead() 文件对象是否可读
八、随机访问文件
类RandomAccessFile来处理文件中随机内容的输入输出，创建一个随机访问文件：
使用文件名 ：
// RandomAccessFile myRAFile=new RandomAccessFile(String name， String mode)；
RandomAccessFile myRAFile= new RandomAccessFile(“file1.txt”, “r”); // 决定是以只读方式（"r " ）还是以读写方式(“rw”)访问文件
使用文件对象：
// RandomAccessFile myRAFile=new RandomAccessFile(File file， String mode);
File myFile= new File(“mymotd”);
RandomAccessFile myRAFile=new RandomAccessFile( myFile，“rw”);
移动文件读写指针的方法:
long getFilePointer()：返回文件指针的当前位置
void seek(long pos)：将文件指针置于指定的绝对位置。位置值以从文件开始处的字节偏移量pos来计算，pos为0代表文件的开始
long length()：返回文件的长度。位置值为length()，代表文件的结尾
示例：使用 RandomAccessFile类读取文件
import java.io.*;
public class r {
public static void main(String args[]) {
try {
RandomAccessFile file = new RandomAccessFile("myFile.dat", "rw");
long filePoint = 0; // 定义指针
long fileLength = file.length();
while (filePoint < fileLength) {
String s = file.readLine(); // 读取文件中的数据
System.out.println(s);
filePoint = file.getFilePointer(); //返回文件指针的当前位置
}
file.close();
} catch (Exception e) {
}
}
}
八、字符输入输出流
字节流与字符流的区别：字节流以字节为单位传送数据，可以是任何类型的数据，如文本、音频、视频、图片等。
字符流以字符为单位传送数据，只能传送文本类型的数据。
字符流用于处理字符数据的读取和写入，Reader类和Writer类是字符的抽象类。
Reader类定义了操作字符输入流的各种方法。
示例：创建Reader的子类InputStreamReader实例，并将其初始化为控制台的字符输入流，然后通过read()方法将读取的数据输出。
import java.io.*;
public class InputStreamReaderDemo {
public static void main(String[] args) {
// 创建Reader子类InputStreamReader实例
InputStreamReader rin = new InputStreamReader(System.in);
try {
char[] cs = new char[100]; // 创建字符数组
System.out.println("请输入字符串：");// 提示用户输入字符串
rin.read(cs); // 向流中读取数据
String input = new String(cs); // 根据读取内容创建字符串
System.out.println("您输入的字符串：" + input.trim()); // 控制台上输出内容
rin.close(); // 关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
Writer类用于解决字符数据的输出流。
示例：创建Writer类的子类PrintWriter实例out，并将其初始化为控制台的字符输出流。然后通过write()方法向流中写入字符数组，并在控制台上输出。
import java.io.*;
public class PrintWriterDemo {
public static void main(String[] args) {
try {
Writer out = new PrintWriter(System.out); // 创建PrintWriter实例
char[] cs = "本实例使用字符输出流，在控制台输出字符串".toCharArray(); // 创建字符数组
out.write(cs); // 向流中写数据
out.close(); // 将流关闭
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileReader类
FileReader类继承Reader类，并实现了读取字符输入流的各种方法。其构造方法如下：
1）FileReader(File file); 参数说明：file是要读入数据的文件对象。
2）FileReader(String filename); 参数说明： filename表示文件名。
示例：使用FileReader类实现读取word.txt文件中的数据，并将其在控制台上输出。
import java.io.File;
import java.io.FileReader;
public class FileReaderDemo {
public static void main(String[] args) {
File file = new File("E://word.txt"); // 创建文件对象
try {
FileReader fReader = new FileReader(file); // 创建FileReader实例
int length;
while ((length = fReader.read()) != -1) { // 循环读取指定文件内容
System.out.print((char) length);
}
fReader.close(); // 关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}
FileWriter类
FileWriter类实现了文件字符输出流，继承Writer类。其构造方法如下：
1）FileWriter(File file); 参数说明：file是要写入数据的文件对象。
2）FileWriter(String filename); 参数说明： filename表示文件名
示例：使用字符输入、输出流，将文字信息加密后保存到指定文件，再读取。
import java.io.*;
public class FileWriterDemo {
public static void main(String[] args) {
char chars[] = "登录密码是：mrsoft".toCharArray(); // 定义写入文件的字符数组
int n = 0, m = 0;
File file = new File("e://text//word.txt"); // 写入信息的文件
for (int i = 0; i < chars.length; i++) { // 将信息加密后写入文件
chars[i] = (char) (chars[i] ^ 'B');
}
try {
FileWriter fileWriter = new FileWriter(file); // 创建FileWriter对象
fileWriter.write(chars, 0, chars.length); // 向文件写数据
fileWriter.close(); // 将流关闭
FileReader fileReader = new FileReader(file); // 创建FileReader对象
char tom[] = new char[1024];
while ((n = fileReader.read(tom)) != -1) { // 循环读取指定文件中内容
String str = new String(tom, 0, n); // 创建字符串对象
m = n;
System.out.println("密文：" + str); // 将加密后的文件输出
}
fileReader.close(); // 将流关闭
for (int j = 0; j < m; j++) {
tom[j] = (char) (tom[j] ^ 'B'); // 获取解密后数据
}
String ss = new String(tom, 0, m);
System.out.println("明文：" + ss);
} catch (Exception e) {
e.printStackTrace();
}
}
}