IO流——常用IO流详解
1：字节流
字节流：用于处理以字节为单位的二进制文件（如音乐，图片等）
InputStream 是抽象类 它的对应子类FileInputStream可以被实例化
构造方法：
FileInputStream常用构造方法：
FileInputStream(File file) ：通过File对象创建FileInputStream对象。
FileInputStream(String name) ：通过文件（非“目录”）路径创建FileInputStream对象。
常用方法：
int read()：从输入流中读取单个字节的数据；如果已到达文件末尾，则返回 -1。
int read(byte[] b)：从输入流中将最多b.length个字节的数据读入一个byte数组中，以整数形 式返回存入数组中的实际字节个数；如果已到达文件末尾，则返回 -1。 void close()：关闭此文件输入流并释放与此流有关的所有系统资源
OutputStream是抽象类，它的子类FileOutputStream可以被实例化
构造方法：
FileOutputStream(File file) ：通过File对象创建FileOutputStream对象。
FileOutputStream(String name) ：通过文件（非“目录”）路径创建 FileOutputStream对象。
FileOutputStream(File file, boolean append)：通过File对象创建 FileOutputStream对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头
常用方法：
FileOutputStream常用方法：
void write(int b)：将指定的单个字节数据写入此文件输出流。
void write(byte[] b, int off, int len)：将byte数组中从off开始的len个字节写入此文件输出流。
void flush()：刷新字节输出流并强制写出缓冲内所有字节数据。
void close()：关闭此文件输出流并释放与此流有关的所有系统资源。
package com.xt.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputStreamTest {
public static void main(String[] args) {
FileInputStream fis=null;
FileOutputStream fos=null;
try {
/**
* 读和写都是站在程序的角度来看的，读文件用FileInputStream 写文件用FileOutPutStream
*/
fis=new FileInputStream("C:\\中心.jpg");
fos=new FileOutputStream("D:\\重要.jpg");
//第一种方法：一个字节一个字节的读
/*int date;
while((date=fis.read())!=-1) {
System.out.println(date);
}*/
//第二种方法：1024个字节1024个字节的读
byte[] bufferDate=new byte[1024];
int length;
while((length=fis.read(bufferDate))!=-1) {
fos.write(bufferDate, 0, length);
}
fos.flush();//强制全部读出来所有的数据
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//释放资源
if(fos!=null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis!=null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.1：缓冲字节流
缓冲输入流：BufferedInputStream BufferedInputStream(InputStream in)：
缓冲输出流：BufferedOutputStream BufferedOutputStream(OutputStream out)
package com.xt.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferInputStreamTest {
public static void main(String[] args) {
try {
BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("C:\\中心.jpg"));
BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("D:\\重要k.jpg"));
/*int b;
while((b=bufferedInputStream.read())!=-1) {
bufferedOutputStream.write(b);
}*/
byte[] bufferByte=new byte[1024];
int length;
while((length=bufferedInputStream.read(bufferByte))!=-1) {
bufferedOutputStream.write(bufferByte, 0, length);
}
bufferedOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2：字符流
Reader是抽象类，它的子类FileReader 可以被实例化
构造方法：
FileReader常用构造方法： FileReader(File file) ：通过File对象创建FileReader对象。
FileReader(String fileName) ：通过文件（非“目录”）路径创建FileReader对象。
常用方法：
FileReader常用方法： int read()：从输入流中读取单个字符的数据，如果已到达流的末尾，则返回 -1 。
int read(char[] cbuf)：从输入流中将最多cbuf.length个字符的数据读入一个char数组中，以整数形式返回存入
数组中的实际字节个数，如果已到达流的末尾，则返回 -1 。
void close()：关闭此文件输入流并释放与此流有关的所有系统资源。
Writer是抽象类，它的子类FileWriter可以被实例化
构造方法：
FileWriter(File file) ：通过File对象创建FileWriter对象。
FileWriter(String fileName) ：通过文件（非“目录”）路径创建FileWriter对象。
FileWriter(File file, boolean append)：通过File对象创建FileWriter对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。
常用方法：
void write(int c)：将指定的单个字符数据写入此文件输出流。
void write(char[] cbuf, int off, int len)：将char数组中从off开始的len个字符写入此文件输出流。
void flush()：刷新字符输出流缓冲。
void close()：关闭此文件输出流并释放与此流有关的所有系统资源。
package com.xt.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
class FileReaderAndFileWriter {
public static void main(String[] args) {
Reader reader=null;
Writer writer=null;
try {
reader=new FileReader("C:\\unintall.log");
writer=new FileWriter("D:\\unintall.log");
char[] buffer=new char[1024];
int length;
while((length=reader.read(buffer))!=-1) {
writer.write(buffer, 0, length);
}
writer.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
if(writer!=null) {
writer.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(reader!=null) {
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.1：缓冲字符流
BufferedReader:缓冲字符输入流 BufferedReader(Reader in)：
BufferedWriter :缓冲字符输出流 BufferedWriter(Writer out)
package com.xt.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferReaderTest {
public static void main(String[] args) {
try {
BufferedReader bufferedReader =new BufferedReader(new FileReader("C:\\unintall.log"));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\unintall.log"));
//第一种方法
// int date;
// while((date=bufferedReader.read())!=-1) {
// bufferedWriter.write(date);
// }
// bufferedWriter.flush();
//
//
//第二种方法
char[] bufferDate=new char[1024];
int length;
while((length=bufferedReader.read(bufferDate))!=-1) {
bufferedWriter.write(bufferDate, 0, length);
}
bufferedWriter.flush();
//第三种方法
// String lineDate;
// while((lineDate=bufferedReader.readLine())!=null) {
// bufferedWriter.write(lineDate);
// bufferedWriter.newLine();
// }
// bufferedWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3:转换流
转化只能是字节向字符转化
InputStreamReader(Reader in)
OutputStreamWriter(Writer out)
因为InputStreamReader是Reader的子类，所以同样可以用缓冲字符流BufferedReader(new InputStreamReader(Reader in))
t同理
package com.xt.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
public class InputStreamReaderTest {
public static void main(String[] args) {
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\aa.txt"),"UTF-8"));
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\bb.txt"), "UTF-8"));
String lineDate;
while((lineDate=bufferedReader.readLine())!=null) {
bufferedWriter.write(lineDate);
bufferedWriter.newLine();
}
bufferedWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
数据流
package com.xt.io;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataInputStreamTest {
public static void main(String[] args) {
double[] scores = {20,50,42,62};
DataOutputStream dataOutputStream=null ;
try {
dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\data.data")) ;
for (double score : scores) {
dataOutputStream.writeDouble(score);
}
dataOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(dataOutputStream!=null) {
try {
dataOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
try {
DataInputStream dataInputStream=new DataInputStream(new FileInputStream("D:\\data.data"));
while(true) {
System.out.println(dataInputStream.readDouble());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e) {
}
}
}
