java：IO流（处理流（缓冲流，转换流，数据流），对象的序列化，Properties）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

字节缓冲流：（BufferedInputStream，BufferedOutStream）

*按照流的功能来分:节点流和处理流
*节点流可以直接操作数据源:
*InputStream
*--FileInputStream
*OutputStream
*--FileOutputStream
*Reader
*--FileReader
*Writer
*--FileWriter
*处理流:不能直接操作数据源，要结合节点流进行使用，主要作用是用于简化操作和提高效率。
*--缓冲流
*字节缓冲流:BufferedInputStream/BufferedOutputStream
*优点:降低对磁盘IO的访问频率，提高读写效率。
*java.io.BufferedInputStream类
*常用构造方法:
*BufferedInputStream(InputStream in):创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用
*BufferedInputStream(InputStream in, int size)创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
*常用方法:
* read() 参见 InputStream 的 read 方法的常规协定。
* read(byte[] b, int off, int len) 从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
* close() 关闭此输入流并释放与该流关联的所有系统资源。
*java.io.BufferdOutputStream类：该类实现缓冲的输出流
* 常用的构造方法:
* BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
* BufferedOutputStream(OutputStream out, int size)
* 常用的方法:
* write(int b)将指定的字节写入此缓冲的输出流。
* write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
* flush()刷新此缓冲的输出流。
*
*字符缓冲流:BufferedReader/BufferedWriter
*--转换流:将字节流转换为字符流
*InputStreamReader:将字节输入流转换为字符输入流。
*OutputStreamWriter:将字节输出流转为字符输出流。

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 TestBufferedStream {
/**
* 利用缓冲流将D:/mp3/test.mp3复制E:/
* @param args
*/
public static void main(String[] args) {
FileInputStream fis=null;
FileOutputStream fos =null;
BufferedInputStream bis=null;
BufferedOutputStream bos =null;
try {
fis = new FileInputStream("D:/mp3/test.mp3");
fos = new FileOutputStream("E:/test.mp3");
//创建缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
int i;
while((i=bis.read())!=-){
bos.write(i);
}
bos.flush();//刷新缓冲流(将缓冲流与磁盘同步)
System.out.println("复制完成!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bos.close();
bis.close();
fos.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

字符缓冲流：（ BufferedReader/BufferedWriter）

* 字符缓冲流:BufferedReader/BufferedWriter
* java.io.BufferedReader类：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
* 构造方法:
* BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流
* BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。
* 常用的方法:
* readLine() 读取一个文本行。
*
* java.io.BufferedWriter类:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
* 构造方法:
* BufferedWriter(Writer out): 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
* BufferedWriter(Writer out,int size):创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
* 常用方法:
* newLine()写入一个行分隔符。
* flush()刷新该流的缓冲。
* writer(String str):将写入一个字符串。
* close():关闭此流，但要先刷新它。

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 TestBufferedReaderWriter {
public static void main(String[] args) {
FileReader reader=null;
FileWriter writer=null;
BufferedReader br=null;
BufferedWriter bw =null;
try {
reader = new FileReader("D:/reader.txt");
writer = new FileWriter("E:/reader.txt");
br = new BufferedReader(reader);
bw = new BufferedWriter(writer);
String str;
while((str=br.readLine())!=null){
bw.write(str);
bw.newLine();
}
bw.flush();
System.out.println("复制完成!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
br.close();
writer.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}

* 编写一个代码统计器，统计某个目录下的所有代码的行数

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;public class CodeCounter {
static long line;
/**
* 统计代码的行数
*/
public static void calcCounter(File file){
if(file.exists()){
if(file.isDirectory()){
File[] fs = file.listFiles();//获取指定目录下的子目录或子文件
for (File f : fs) {
calcCounter(f);//递归调用
}
}else{
//如果是文件，统计该文件中的行数
String fileName = file.getName();//获取文件名称
//判断该文件是否为java源文件(后缀为.java)或c的源文件(后缀为.c)
if(fileName.endsWith(".java")||fileName.endsWith(".c")){
try {
//使用输入流读取源文件中行数
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
String str;
while((str=br.readLine())!=null){
line++;//统计行数
}
br.close();
fr.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}else{
System.out.println("目录有误!");
}
} public static void main(String[] args) {
File file = new File("D:/CFree");
calcCounter(file);
System.out.println("总共有"+line+"行代码");
}
}

转换流:（InputStreamReader/OutputStreamWriter）

* InputStreamReader:将字节输入流转换为字符输入流,继承了Reader类
* 常用的构造函数:
* InputStreamReader(InputStream in)创建一个使用默认字符集的 InputStreamReader。
*
* OutputStreamWriter:将字节输出流转换为字符输出流
* System.in---->InputStream:标准输入流
* System.out---->PrintStream:标准输出流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;public class TestConverterIO {
public static void main(String[] args) {
// Scanner input = new Scanner(System.in);
// String line = input.nextLine();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
OutputStreamWriter osw =null;
BufferedWriter bw=null;
try {
osw = new OutputStreamWriter(new FileOutputStream("D:/aa.txt"));
bw = new BufferedWriter(osw);//创建一个字符输出缓冲流
String str = br.readLine()
while(!str.equals("exit")){
// System.out.println(str);
bw.write(str);//将控制台输入的字符串写入到D:/aa.txt文件中
bw.newLine();//换行
str = br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
isr.close();
bw.close();
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}

常用处理流（关闭处理流使用关闭里面的节点流）

缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter

---增加缓冲功能，避免频繁读写硬盘。

转换流：InputStreamReader OutputStreamReader实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.

*处理流:
*DataInputStream/DataOutputStream类:方便对java中的基本数据类型和字符串进行操作。二进制文件
*java.io.DataInputStream类:
*构造方法:DataInputStream(InputStream in)
*常用的方法:readXxx():xxx代表数据类型。
* readInt():读取int类型的数据
* readDouble():读取double类型的数据
* readBoolean():读取boolean类型的数据
* ...
* readUTF():读取字符串类型的数据。
*java.io.DataOutputStream类:
*构造方法:DataOutputStream(OutputStream out)
*常用的方法:writeXxx():Xxx代表数据类型
*writeInt(int i):写入一个int类型的值
*writeDouble(double d):写入double类型的值

在使用数据流的时候，必须先写入文件内容，再用输入流去读该文件，不然会出现二进制之前转换的错误。

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class TestDataInputStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("D:/data.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream dis = new DataInputStream(bis);
int i = dis.readInt();
System.out.println("i="+i);
double d = dis.readDouble();
System.out.println("d="+d);
String str = dis.readUTF();
System.out.println("str="+str);
//关闭资源
dis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
}

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class TestDataOutputStream {
public static void main(String[] args) {
try {
FileOutputStream fos = new FileOutputStream("D:/data.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos);
dos.writeInt();
dos.writeDouble(3.14);
dos.writeUTF("hello");
dos.flush();
dos.close();
System.out.println("写入完毕!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
}

对象的序列化 ObjectOutputStream：

*对象的反序列化:将字节序列转化为java对象的过程。
*为什么要序列化:将对象序列化后变成字节序列可以保存在磁盘或通过网络传输，以实现对象共享(字节序列可以跨平台)。
*序列化的条件:必须实现Serializable 接口
*序列化需要使用ObjectOutputStream类将对象写入到磁盘或网络
*java.io.ObjectOutputStream类继承了OutputStream类，按照功能划分的话属于处理流。
*构造方法:ObjectOutputStream(OutputStream out)
*常用的方法:
*writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;public class TestObjectOutputStream {
public static void main(String[] args) {
Student stu = new Student("张三", , "郑州尚学堂");
try {
OutputStream ops = new FileOutputStream("D:/test.obj");
ObjectOutputStream oos = new ObjectOutputStream(ops);
oos.writeObject(stu);
oos.flush();
oos.close();
System.out.println("对象写入完成!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

对象的序列化 ObjectInputStream：

*对象的反序列化:将字节序列转化为java对象的过程。
*为什么要序列化:将对象序列化后变成字节序列可以保存在磁盘或通过网络传输，以实现对象共享(字节序列可以跨平台)。
*序列化的条件:必须实现Serializable 接口
*反序列化需要ObjectInputStream使用类将字节序列转化为对象
*java.io.ObjectInputStream类继承了InputStream类，按照功能划分的话属于处理流。
*构造方法:ObjectInputStream(InputStream in)
*常用的方法:
*readObject() 将字节序列转为对象。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;public class TestObjectInputStream {
public static void main(String[] args) {
try {
InputStream ips = new FileInputStream("D:/test.obj");
ObjectInputStream ois= new ObjectInputStream(ips);
Object obj = ois.readObject();
Student student = (Student)obj; //若有多个对象，可以用循环
System.out.println(student);
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
}

Properties：

* java.util.Properties类:继承了Hashtable类，采用键值对的方式进行存储。
* *.properties文件存储方式是按照键值对的方式进行存储:key=value 常用的构造方法:
* Properties():创建一个无默认值的空属性列表。常用的方法: load(InputStream
* inStream)从输入流中读取属性列表（键和元素对）。 getProperty(String key)用指定的键在此属性列表中搜索属性。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;public class TestProperties {
public static void main(String[] args) {
Properties props = new Properties();
try {
// InputStream ips = new FileInputStream("D:\\code\\ioDemo\\jdbc.properties");//绝对路径
InputStream ips = new FileInputStream("jdbc.properties");//相对路径(相对于当前项目的根目录)
props.load(ips);
String driver = props.getProperty("driver");
String url = props.getProperty("url");
String username = props.getProperty("username");
String password = props.getProperty("password");
System.out.println("驱动名称:" + driver);
System.out.println("资源路径:" + url);
System.out.println("用户名:" + username);
System.out.println("密码:" + password);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}