JAVA中字符流詳解

字符流：就是在字節流的基礎上，加上編碼，形成的數據流

字符流出現的意義：因為字節流在操作字符時，可能會有中文導致的亂碼，所以由字節流引申出了字符流。

字符輸入流：Reader

常用子類：FileReader

文件字符輸入流常用方法：

read（）；

read（char[ ]）；

read（char[ ] ，offset，len）；

字符輸出流： Writer

常用子類：文件字符輸出流： Filewriter

文件字符輸出常用方法：

writer（）；

writer（char[ ]）；

writer（char[ ]，offset，len）；

writer（string）；

flush（）刷新緩沖區

注意：close（）方法默認調用了flush（）方法，但是flush（）方法只刷新緩沖區，而close（）還會關閉IO流

 

字符輸入流代碼示例：

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo5 {

    public static void main(String[] args) throws IOException{
        FileReader fr=new FileReader(new File("1.txt"));
        char[] ca=new char[1024];
        int count=0;
        while((count=fr.read(ca))!=-1) {
            System.out.println(new String(ca,0,count));
        }
    }
}

 運行結果：

 字符輸出流代碼示例：

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo6 {

    public static void main(String[] args) throws IOException{
        FileReader fr=new FileReader(new File("1.txt"));
        FileWriter fw=new FileWriter(new File("2.txt"));
        char[] ca=new char[1024];
        int count;
        while((count=fr.read(ca))!=-1) {
            fw.write(ca,0,count);
        }
        fr.close();
        fw.close();
    }
}

 

執行結果：

 

字符流與字節流的區別：字符流雖然以字節流為基礎創建的，但是字節流可以支持聲音，視頻，圖片，文本等所有文件類型，而字符流只支持文本文件。

帶緩沖區的字符流：

BufferedReader/BufferedWriter  帶緩沖區的字符輸入流與字符輸出流。

帶緩沖區的字符輸入流：BufferedReader：常用方法：readLine（）  讀取一行，如果為文件末尾，返回值為null。

帶緩沖區的字符輸出流：BufferedWriter:常用方法：writer（string）將字符串寫入 到輸出流。  newLine（）根據系統的行分割符進行換行。

BufferReader代碼示例：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo7 {

    public static void main(String[] args) throws IOException{
        BufferedReader br=new BufferedReader(new FileReader(new File("1.txt")));
        String value;
        while((value=br.readLine())!=null) {
            System.out.println(value);            
        }
        br.close();    
    }
}

 

BufferedWriter代碼示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo8 {

    public static void main(String[] args)throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter("3.txt"));
        BufferedReader br=new BufferedReader(new FileReader("1.txt"));
        String value="";
        while((value=br.readLine())!=null) {
            bw.write(value);
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}

 

編碼與亂碼：

亂碼：編碼與解碼不一致，導致的亂碼問題，每一種編碼格式都有自己獨特的編碼，如果編碼與解碼不一致，勢必會導致亂碼，例如用Unicode編碼，用gbk解碼，就會字符與碼值不匹配，從而導致亂碼。

編碼表：編碼和解碼使用的規則：

ASCII碼：美國信息交換標准代碼。單字節編碼，不支持中文。

gbk:國標碼；

Unicode/utf-8  ：雙字節編碼，支持中文（萬國碼）

代碼示例：

public class  讀取不同編碼的文本文件 {
public static void main(String[] args) throws IOException {
// BufferedReader br=new BufferedReader(new FileReader(new File("C:\\Users\\Administrator\\De
sktop\\6.txt")));
// 改進
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(new File("C:\
\Users\\Administrator\\Desktop\\6.txt")),"gbk"));
String st = br.readLine();
System.out.println(st);
}
}

 

 

轉換流
1.InputStreamReader 將字節流轉換成字符流 輸入
2.OutputStreamWriter 將字節流轉換成字符流 輸出
3. 構造方法：
① InputStreamReader(InputStream in)
② InputStreamReader(InputStream in, String cs)
③ OutputStreamWriter(OutputStream out)
④ OutputStreamWriter(OutputStream out, String charsetName)
4. 作用：
① 可以將字節流轉換成字符流
② 可以使用指定的編碼來讀取或寫入流。

代碼示例：

public class  轉換流 {
public static void main(String[] args) throws IOException {
InputStreamReader is=new InputStreamReader(new FileInputStream(new File("C:\\Users\\Administ
rator\\Desktop\\6.txt")),"gbk");
char[] c=new char[1024];
int value = is.read(c);
System.out.println(Arrays.toString(c));
}
}

 

字節數組字節輸出流
ByteArrayOutputStream
字節數組字節輸出流：
特點： 可以將數據寫入到 byte 數組中，並且該緩沖區可以隨着寫入的數據而自增
① 構造方法 ：
ByteArrayOutputStream()
② 注意：此類中的方法在關閉此流后仍可被調用，而不會產生任何 IOException
③ 常用方法：
1 》 write(byte[]) 將 byte[] 中的值寫入緩沖區字節數組，該緩沖區隨着數據的增多而自增。
2 》 toString() 要想獲取緩沖區的字節數據，可以通過該方法將其轉換為字符串。
代碼示例：

public class  字節數組字節輸出流 {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
String s="abc";
byte[] b=s.getBytes();
System.out.println(Arrays.toString(b));
bos.write(b);
bos.write(b);
bos.close();
System.out.println(Arrays.toString(b));
System.out.println(bos.toString());
}
}

 

對象流 / 序列化與反序列化流
1. 對象流 / 序列化流
ObjectInputStream: 反序列化流
② ObjectOutputStream: 序列化流
1 》常用方法：
writeObject(obj) 將 obj 對象寫入到流中
readObject 讀取流中的數據
① EOFException 表示讀取流意外讀到了文件的末尾 ( 就是一個空文件。 )
2 》構造方法
ObjectOutputStream(OutputStream out)
ObjectInputStream(InputStream in)
3 》序列化版本號：
serialVersionUID 序列化版本號：保證序列化流與反序列化流讀寫一致，保證版本一致性。

代碼示例一：

public class  用序列化流與反序列化流操作集合 {
public static void main(String[] args) {
ArrayList<Teacher> list=new ArrayList<>();
list.add(new Teacher(" 張三 ", 18, new ClassRoom("0318java")));
list.add(new Teacher(" 李四 ", 18, new ClassRoom("0318java")));
list.add(new Teacher(" 王五 ", 18, new ClassRoom("0318java")));
// writeToFile(list,"stu.txt");
// 讀取
System.out.println(readTeacher("stu.txt"));
}
// 帶異常處理的 ，序列化
public static void writeToFile(ArrayList<Teacher> list,String fileName) {
// 序列化流進行寫入
try(
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File(fileName)));
){
oos.writeObject(list);
}catch (Exception e) {
e.printStackTrace();
}
}
// 反序列化
public static ArrayList<Teacher> readTeacher(String fileName) {
ArrayList<Teacher> list=null;
// 反序列化流讀取文件中的集合
try(
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File(fileName)));
){
list = (ArrayList<Teacher>) ois.readObject();
}catch (Exception e) {
e.printStackTrace();
}
return list;
}
}
class Teacher implements Serializable{
/**
*  序列化版本號：默認版本號為 1l
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
private ClassRoom cn;// 班級
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 ClassRoom getCn() {
return cn;
}
public void setCn(ClassRoom cn) {
this.cn = cn;
}
@Override
public String toString() {
return "Teacher [name=" + name + ", age=" + age + ", cn=" + cn + "]";
}
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
}
public Teacher(String name, int age, ClassRoom cn) {
super();
this.name = name;
this.age = age;
this.cn = cn;
}
}
class ClassRoom implements Serializable{
/**
*  序列化版本號：保證序列化流與反序列化流讀寫一致
*/
private static final long serialVersionUID = 3359646767342429683L;
private String no;
public ClassRoom() {
super();
// TODO Auto-generated constructor stub
}
public ClassRoom(String no) {
super();
this.no = no;
}
@Override
public String toString() {
return "ClassRoom [no=" + no + "]";
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}// 班級號碼
}

 

代碼示例二：

import java.io.File;
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;
import java.util.Iterator;

public class Demo9 {

    public static void main(String[] args)throws IOException, Exception {
        ArrayList<Student6> list=new ArrayList<>();
        list.add(new Student6("張三","1001",18));
        list.add(new Student6("李四","1002",19));
        list.add(new Student6("王五","1003",20));
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("4.txt")));
        oos.writeObject(list);
        oos.close();

        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("4.txt") ));
        ArrayList<Student6> list2=(ArrayList<Student6>) ois.readObject();
        Iterator<Student6> it=list2.iterator();
        while(it.hasNext()) {
            Student6 stu=it.next();
            System.out.println("姓名："+stu.getName()+"\t學號："+stu.getStuNo()+"\t年齡+\t："+stu.getAge());
        }        
    }
}
class Student6 implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 2658878058482366562L;
    private String name;
    private String stuNo;
    private int age;
    
    public Student6() {
        super();
    }
    public Student6(String name,String stuNo,int age) {
        this.name=name;
        this.stuNo=stuNo;
        this.age=age;
        
    }
    public void setName(String name) {
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setStuNo(String stuNo) {
        this.stuNo=stuNo;
    }
    public String getStuNo() {
        return stuNo;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Student6 [name=" + name + ", stuNo=" + stuNo + ", age=" + age + "]";
    }    
}

 

 

EOFException表示輸入過程中意外地到達文件尾或流尾的信號

字符流寫入 要刷新/關流才能寫入（刷新也是調用了flush（刷新）方法）
就像水龍頭帶軟管，開水龍頭要等一會兒水才能流出來，就和需要刷新一樣

字節流不需要刷新，是因為字節流是一個字節一個字節讀和寫的，而字符流是三個字節或者兩個字節讀和寫的，所以
字符流需要刷新，而字節流不需要刷新