1.字符流
1.1InputStreamReader
/**
* InputStreamReader 是读取字符类
* 读取文件以字符为单位，底层还是字节流
* */
package day23.reader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
//创建一个字符流对象
//1.1创建字节流对象，关联到要操作的文件
FileInputStream in=new FileInputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\day01\\FirstDemo.java");
//1.2创建字符流对象，关联字节流
InputStreamReader reader=new InputStreamReader(in);
//2.读取字符
/*//读取单个字符
System.out.println(reader.read());
//读取一串字符，把字符存在字符数组中
char []cbuf=new char[10];
int len=reader.read(cbuf);
System.out.println(len);
//从流中读取一定长度的字符，存到缓存区，从某个位置开始，读取长度
//reader.read(cbuf, offset, length);*/
//初始化一个缓存区
char[]cbuf=new char[10];
//设置长度
int len=0;
//循环读取数据
while ((len=reader.read(cbuf))!=-1) {
//处理接受的数据
System.out.print(new String(cbuf,0,len));
}
//3.关闭流
in.close();
reader.close();
}
}
输出结果：
1.2OutoutStreamWriter
package day23.writer;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
//写出字节流
public static void main(String[] args) throws IOException {
// 初始化一个字符流对象
OutputStreamWriter writer=new OutputStreamWriter(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\111.txt",true));
//写操作
//写单个字符
writer.write("q");
//写入一个字符数组
char[]cbuf={'s','d','c','a','l','m'};
writer.write(cbuf);
//3.刷入数组，从那个位置开始到哪个位置结束
writer.write(cbuf, 1, 4);
//写入一个字符串
writer.write("Hello");
//刷入
writer.flush();
//关闭
writer.close();
}
}
输出结果：
1.3FileReader
/**
* FileReader是InputStreamReader的子类
* 只能使用平台默认的编码格式
* */
package day23.reader;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
//创建FileReader对象
FileReader reader=new FileReader("C:\\Users\\Administrator\\Desktop\\111.txt");
//读取字符
//声明一个缓冲区
char[]cbuf=new char[10];
int len=0;
//循环读取字符
while ((len=reader.read(cbuf))!=-1) {
//处理字符
System.out.print(new String(cbuf,0,len));
}
//关闭
reader.close();
}
}
输出结果：
1.4FileWriter
package day23.writer;
import java.io.FileWriter;
import java.io.IOException;
//FileWriter是OutputStreamWriter的子类
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
// 初始化一个FileWriter对象
FileWriter writer=new FileWriter("C:\\Users\\Administrator\\Desktop\\123.txt",false);
//写操作
writer.write("This is a FileWriter!");
//刷入
writer.flush();
//关闭
writer.close();
}
}
输出结果：
1.5BufferedReader
/**
* BufferedReader是Reader的子类
* 最大特点就是每次可以读取到一行，一行的定义就是读取到换行符
* */
package day23.reader;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class BuferedReaderDemo {
public static void main(String[] args) throws IOException {
//初始化一个对象
//使用手动设置编码格式
//InputStreamReader input=new InputStreamReader(in, dec);
//使用默认的编码个打
FileReader reader=new FileReader("C:\\Users\\Administrator\\Desktop\\Java1807\\day01\\FirstDemo.java");
BufferedReader br=new BufferedReader(reader);
//读取数据
/*//读取单个字符
System.out.println(br.read());
//读取多个字符
char[]cbuf=new char[5];
System.out.println(br.read(cbuf));*/
//读取行
String str=null;
while (br.ready()) {
str=br.readLine();
System.out.println(str);
}
//关闭流
br.close();
reader.close();
}
}
输出结果：
1.6BufferedWriter
/**
* BufferedWriter是Writer的子类
* 可以写入一行数据，可以换行
* */
package day23.writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import javax.swing.text.AbstractDocument.BranchElement;
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
// 创建BufferedWriter对象
//创建一个Writer子类对象
//可以设置编码集
//OutputStreamWriter osw=new OutputStreamWriter(out, enc);
//默认编码集
FileWriter writer=new FileWriter("C:\\Users\\Administrator\\Desktop\\222.txt",true);
BufferedWriter bw=new BufferedWriter(writer);
//写数据
String str="哎呦，不错哦！";
bw.write(str);
//换行
bw.newLine();
//刷入
bw.flush();
//关闭流
writer.close();
bw.close();
}
}
输出结果：
2.二进制I/O流
2.1DataInputStream
/**
* DataInputStream
* 二进制输入流，可以读取文件，将文件中对应的数据类型还原成java的基本数据类型
* */
package day24.io;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DataInputStreamDemo {
public static void main(String[] args) throws IOException {
//初始化对象
DataInputStream input=new DataInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\data.txt"));
//读取数据，必须按照存入的顺序来读取
System.out.println(input.readBoolean());
System.out.println(input.readByte());
System.out.println(input.readChar());
System.out.println(input.readDouble());
System.out.println(input.readFloat());
System.out.println(input.readLong());
System.out.println(input.readInt());
System.out.println(input.readShort());
System.out.println(input.readUTF());
//关闭流
input.close();
}
}
输出结果：
2.2DataOutputStreamD
/**
* DataOutputStream
* 二进制输出流，可以将java的基本类型直接写到文件中
* */
package day24.io;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamDemo {
public static void main(String[] args) throws IOException {
//初始化对象
DataOutputStream out=new DataOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\data.txt"));
//写数据
out.writeBoolean(true);//写入一个boolean值类型
out.writeByte(3);//写入一个字节类型
out.writeChar('q');
out.writeDouble(1.1);
out.writeFloat(3.14F);
out.writeLong(333L);
out.writeInt(12);
out.writeShort(2209);
out.writeUTF("asda");
//强制刷入
out.flush();
//关闭流
out.close();
}
}
输出结果：
3.打印输出流
3.1PrintStream
/**
* PrintStream 打印输出流
* 可以输出字节流，可以向不同的流中输出数据，自带换行符
* 如果输入烦人是字符，使用PrintWriter，带编码格式
* */
package day24.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class PrintStreamDemo {
public static void main(String[] args) throws FileNotFoundException {
// 初始化对象
PrintStream st=new PrintStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\p1.txt"),false);
//写入数据
//不带换行
st.print(true);
st.print(111);
st.print(12.3F);
st.print("qq1");
//自带换行功能
st.println(false);
st.println("nihao");
st.println("Hello");
st.println(123);
//关闭
st.close();
}
}
输出结果：
3.2PrintWriter
package day24.io;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws FileNotFoundException {
// 初始化对象
PrintWriter writer=new PrintWriter("C:\\Users\\Administrator\\Desktop\\Java1807\\p2.txt");
//写数据
writer.print(true);
writer.print("qq");
writer.print(123);
writer.print(111.1);
//带换行
writer.println("Hello");
writer.println(false);
writer.println(12.45F);
writer.println('f');
//强制刷入
writer.flush();
//关闭流
writer.close();
}
}
输出结果：
4.序列化和反序列化操作
4.1Serializable
package day24.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//如果该类要支持序列化技术，必须实现接口 Sreializable
@SuppressWarnings("serial")
class Student implements Serializable{
String name;
int age;
}
public class SerializableDemo {
//序列化：对象通过编码技术转换成二进制数据存储起来
public static void writeObj() throws FileNotFoundException, IOException {
//初始化对象
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\Student1.txt"));
out.writeChar('C');
out.writeBoolean(true);
Student stu=new Student();
stu.name="qq";
stu.age=21;
out.writeObject(stu);
//强制刷入
out.flush();
//关闭流
out.close();
}
//反序列化：将二进制数据通过解码技术，构建还原成原来的对象
public static void readObj() throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectInputStream in=new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\Student1.txt"));
//读取数据
System.out.println(in.readChar());
System.out.println(in.readBoolean());
Student stu=(Student)in.readObject();
System.out.println(stu.name+" "+stu.age);
//关闭流
in.close();
}
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
writeObj();
readObj();
}
}
输出结果：
4.2练习题
package day23.test1;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
//创建学生类
@SuppressWarnings("serial")
class Student implements Serializable{
//属性
private int sId;
private String name;
private int age;
public int getsId() {
return sId;
}
public void setsId(int sId) {
this.sId = sId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//构造方法
public Student() {
// TODO 自动生成的构造函数存根
}
public Student(int sId,String name,int age) {
this.sId=sId;
this.name=name;
this.age=age;
}
@Override
public String toString() {
System.out.println("sId:"+this.sId+"\tname:"+this.name+"\tage:"+this.age);
return super.toString();
}
}
public class StudentSerializable {
//序列化操作
public static void serializeOperation(ArrayList<Student>list) throws IOException {
//初始化对象，关联字节输出流
FileOutputStream out=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\Student.txt");
ObjectOutputStream oos=new ObjectOutputStream(out);
//序列化对象
oos.writeObject(list);
//强制刷入
oos.flush();
//关闭流
oos.close();
out.close();
}
//反序列化操作
@SuppressWarnings("unchecked")
public static void antiSerializationOperation() throws IOException, ClassNotFoundException {
//初始化对象，关联输入流
FileInputStream in=new FileInputStream("C:\\Users\\Administrator\\Desktop\\Java1807\\Student.txt");
ObjectInputStream ois=new ObjectInputStream(in);
//反序列化
ArrayList<Student>list=(ArrayList<Student>)ois.readObject();
//输出
for (Student student : list) {
student.toString();
}
//关闭流
ois.close();
in.close();
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
//初始化ArrayList对象
ArrayList<Student>list=new ArrayList<Student>();
//添加数据
list.add(new Student(1,"一叶知秋",21));
list.add(new Student(2,"浪子一秋",21));
list.add(new Student(3,"葬剑山庄",21));
list.add(new Student(4,"剑侠情缘",21));
list.add(new Student(5,"葬剑灬尊",21));
//序列化
serializeOperation(list);
//反序列化
antiSerializationOperation();
}
}
输出结果：
5.知识框架
