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.知識框架
