IO流的字符流+对象流+打印流+内存流+随机访问流（2）

浅浅的花香味﹌ 2024-04-20 11:20 79阅读 0赞

## IO流的字符流+对象流+打印流+内存流+随机访问流（2） ##

### 一、字符流 ###

#### 1.利用字符输出转换流 向文件写入数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输出流，当文件不存在时都会创建文件

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ggc.txt"));
    		
    		//2.写入数据
    		//osw.write(97);//写入ASCII
    		//char[] cs = {'a','b','c','我','爱','你'};
    		//osw.write(cs);//写入数组
    		//osw.write(cs,2,3);//写入字符数组，偏移量，长度
    		
    		//osw.write("abc我爱你");//写入字符串
    		osw.write("abc我爱你", 3, 3);//写入字符串，偏移量，长度
    		
    		//3.关闭资源
    		osw.close();
    	}
    }

##### 3.在文件末尾追加 #####

###### 方案一 ######

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象
    		OutputStreamWriter ows = new OutputStreamWriter(new FileOutputStream("ggc.txt",true));
    		
    		//2.写入数据
    		ows.write("abx我爱你",2,3);//写入字符串，偏移量，长度
    		
    		//3.关闭资源
    		ows.close();
    	}
    }

###### 方案二 ######

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    import java.io.FileNotFoundException;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		
    		OutputStreamWriter ows = null;
    		try {
        
    			//1.创建流对象 + 指定编码格式
    			//osw = new OutputStreamWriter(new FileOutputStream("hhy.txt",true),Charset.forName("UTF-8"));
    			ows = new OutputStreamWriter(new FileOutputStream("ggc.txt",true),"GBK");
    			//2.写入数据
    			ows.write("abx我爱你",2,3);//写入字符串，偏移量，长度
    		} catch (FileNotFoundException e) {
        
    			e.printStackTrace();
    		} catch (IOException e) {
        
    			e.printStackTrace();
    		}finally {
        
    			//3.关闭资源
    			if (ows != null) {
        
    				try {
        
    					ows.close();
    				} catch (IOException e) {
        
    					e.printStackTrace();
    				}
    			}
    		}
    		
    
    	}
    }

#### 2.利用字符输入转换流 读取文件里的数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输入流，当文件不存在时都会报文件未找到异常 – FileNotFoundException

import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Test04 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象
    		InputStreamReader isr = new InputStreamReader(new FileInputStream("ggc.txt"));
    		
    		//2.读取数据
    		//isr.read(); -- 读取的是字符的ASCII，读取到文件末尾就返回-1
    		int read = isr.read();
    		System.out.println((char)read);
    	    read = isr.read();
    	    System.out.println((char)read);
    	    read = isr.read();
    		System.out.println((char)read);
    		read = isr.read();
    		System.out.println((char)read);
    		read = isr.read();
    		System.out.println((char)read);
    	    read = isr.read();
    	    System.out.println(read);
    	    
    	    //3.关闭资源
    	    isr.close();
    	}
    }

改进方案1
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Test05 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建数据
    		InputStreamReader isr = new InputStreamReader(new FileInputStream("ggc.txt"));
    		
    		//2.读取数据
    		int read;
    		while ((read = isr.read()) != -1) {
        
    			System.out.println((char)read);
    		}
    		
    		//3.关资源
    		isr.close();
    	}
    }

改进方案2
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Test06 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象
    		InputStreamReader isr = new InputStreamReader(new FileInputStream("ggc.txt"));
    		
    		//2.读取数据
    		//len = isr.read(cs) -- 读取cs长度的数据，并把数据存入到字符数组中并返回读取到的有效字符数，如果读取到文件末尾则返回-1
    		char[] cs = new char[1024];
    		int len;
    		while ((len = isr.read(cs)) != -1) {
        
    			System.out.println(new String(cs, 0, len));
    		}
    		
    		//3.关闭资源
    		isr.close();
    	}
    }

##### 3.积极处理异常 #####

##### 4.设置指定编码格式 #####

import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.nio.charset.Charset;
    
    public class Test07 {
        
    
    	public static void main(String[] args){
        
    		
    		
    		InputStreamReader isr = null;
    		try {
        
    			//1.创建流对象
    			//isr = new InputStreamReader(new FileInputStream("ggc.txt"),"GBK");
    			isr = new InputStreamReader(new FileInputStream("ggc.txt"),Charset.forName("UTF-8"));
    			//2.读取数据
    			//len = isr.read(cs) -- 读取cs长度的数据，并把数据存入到字符数组中并返回读取到的有效字符数，如果读取到文件末尾则返回-1
    			char[] cs = new char[1024];
    			int len;
    			while ((len = isr.read(cs)) != -1) {
        
    				System.out.println(new String(cs, 0, len));
    			}
    		} catch (FileNotFoundException e) {
        
    			e.printStackTrace();
    		} catch (IOException e) {
        
    			e.printStackTrace();
    		}finally {
        
    			//3.关闭资源
    			if (isr != null) {
        
    				try {
        
    					isr.close();
    				} catch (IOException e) {
        
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

##### 5.拷贝文本文件 #####

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    
    public class Copy {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		InputStreamReader isr = new InputStreamReader(new FileInputStream("ggc.txt"),"GBK");
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("copy.txt"),"GBK");
    		
    		char[] cs = new char[1024];
    		int len;
    		while ((len = isr.read(cs)) != -1) {
        
    			osw.write(cs, 0, len);
    		}
    		isr.close();
    		osw.close();
    	}
    }

#### 3.利用文件字符输出流 向文件写入数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输出流，当文件不存在时都会创建文件

##### 3.在文件末尾追加 #####

import java.io.FileWriter;
    import java.io.IOException;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		//FileWriter fw = new FileWriter("ggc.txt");
    		
    		//1.创建流对象 + 末尾追加
    		FileWriter fw = new FileWriter("ggc.txt",true);
    		
    		//2.写入数据
    		fw.write("123我爱你");
    		
    		//3.关闭资源
    		fw.close();
    	}
    }

#### 4.利用文件字符输入流 读取文件里的数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输入流，当文件不存在时都会报文件未找到异常 – FileNotFoundException

import java.io.FileReader;
    import java.io.IOException;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		FileReader fs = new FileReader("ggc.txt");
    		
    		//2.读取数据
    		char[] cs = new char[1024];
    		int len;
    		while ((len = fs.read(cs)) != -1) {
        
    			System.out.println(new String(cs, 0, len));
    		}
    		//3.关闭资源
    		fs.close();
    	}
    }

##### 3.拷贝文本文件 #####

import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Copy {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		FileReader fr = new FileReader("IO笔记.txt");
    		FileWriter fw = new FileWriter("copy.txt");
    	
    		char[] cs = new char[1024];
    		int len;
    		while((len = fr.read(cs)) != -1){
        
    			fw.write(cs, 0, len);
    		}
    		
    		fr.close();
    		fw.close();
    	}
    }

#### 5.利用带有缓冲区的字符输出流 向文件写入数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输出流，当文件不存在时都会创建文件

##### 3.在文件末尾追加 #####

import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    
    		//1.创建流对象(文件字符输出流 --> 带有缓冲区的字符输出流)
    		//默认缓冲区大小：8192字符
    		//BufferedWriter bw = new BufferedWriter(new FileWriter("ggc.txt"));
    
    		//1.创建流对象(文件字节输出流 --> 字符输出转换流 --> 带有缓冲区的字符输出流)
    		//默认缓冲区大小：8192字符
    		//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("ggc.txt"),"GBK"));
    
    		//1.创建流对象(文件字符输出流 --> 带有缓冲区的字符输出流) + 末尾追加
    		//默认缓冲区大小：8192字符
    		//BufferedWriter bw = new BufferedWriter(new FileWriter("hhy.txt",true));
    
    		//1.创建流对象(文件字节输出流 --> 字符输出转换流 --> 带有缓冲区的字符输出流) + 末尾追加
    		//默认缓冲区大小：8192字符
    		//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("hhy.txt",true),"GBK"));
    
    		//1.创建流对象(文件字符输出流 --> 带有缓冲区的字符输出流)
    		//自定义缓冲区大小：2048字符
    		BufferedWriter bw = new BufferedWriter(new FileWriter("hhy.txt"),2048);		
    		
    		//2.写入数据
    		bw.write("123abc我爱你");
    		
    		//3.关闭资源
    		bw.close();
    	}
    }

#### 6.利用带有缓冲去的字符输入流 读取文件里的数据 ####

##### 1.文件存在的情况 #####

##### 2.文件不存在的情况 #####

> 经验：所有的输入流，当文件不存在时都会报文件未找到异常 – FileNotFoundException

import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象(文件字符输入流 --> 带有缓冲区的字符输入流)
    		//默认缓冲区大小：8192字符
    		//BufferedReader br = new BufferedReader(new FileReader("hhy.txt"));
    		
    		//1.创建流对象(文件字节输入流 --> 字符输入转换流 --> 带有缓冲区的字符输入流)
    		//默认缓冲区大小：8192字符
    		//BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("hhy.txt"), "GBk"));
    		
    		//1.创建流对象(文件字符输入流 --> 带有缓冲区的字符输入流)
    		//自定义缓冲区大小：2048字符
    		BufferedReader br = new BufferedReader(new FileReader("hhy.txt"),2048);
    		
    		//2.读取数据
    		char[] cs = new char[1024];
    		int len;
    		while ((len = br.read(cs)) != -1) {
        
    			System.out.println(new String(cs, 0, len));
    		}
    		
    		//3.关闭资源
    		br.close();
    	}
    }

##### 3.拷贝文本文件 #####

###### 方案一 ######

import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Copy01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		BufferedReader br = new BufferedReader(new FileReader("ggc.txt"));
    		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    		
    		char[] cs = new char[1024];
    		int len;
    		while ((len = br.read(cs)) != -1) {
        
    			bw.write(cs, 0, len);
    		}
    		
    		br.close();
    		bw.close();
    	}
    }

###### 方案二 ######

import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Copy02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		BufferedReader br = new BufferedReader(new FileReader("ggc.txt"));
    		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    		
    		//br.readLine() -- 读取一行数据，如果读取到文件末尾则返回null
    		String readLine;
    		while ((readLine = br.readLine()) != null) {
        
    			bw.write(readLine);
    			bw.newLine();//换行
    		}
    		br.close();
    		bw.close();
    	}
    }

#### 7.字符流总结 ####

##### 应用场景：处理文本文件 #####

abstract class Reader -- 字符输入流的基类（抽象类）
    abstract class Writer -- 字符输出流的基类（抽象类）
    
    class InputStreamReader extends Reader -- 字符输入转换流
    class OutputStreamWriter extends Writer - 字符输出转换流
    作用：将字节流转换为字符流
    
    class FileReader extends InputStreamReader -- 文件字符输入流
    class FileWriter extends OutputStreamWriter - 文件字符输出流
    
    class BufferedReader extends Reader -- 带缓冲区的字符输入流 
    class BufferedWriter extends Writer -- 带缓冲区的字符输出流
    缓冲区大小为：8192字符

### 二、对象流 ###

#### 1.作用： ####

> 可以将程序中的对象写入到文件里，也可以将文件中的对象取出到程序中

#### 2.概念： ####

> 1.序列化/钝化：将程序中的对象写入到文件中的过程  
> 2.反序列化/活化：将文件中的对象读取到程序中的过程  
> 3.对象要想通过对象输入流写入到文件中，对象所属的类就必须实现序列化接口(Serializable)  
> 4.序列化接口中没有任何的代码，这种接口称之为标记型接口  
> 5.transient修饰了属性，该属性不会随着对象而写入到文件中  
> 6.static修饰了属性，该属性不会随着对象而写入到文件中（静态属性不属于对象的属性）

class ObjectInputStream --- 对象输入流
    	class ObjectOutputStream -- 对象输出流

#### 3.利用对象输出流 向文件写入数据 ####

import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.util.Date;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws FileNotFoundException, IOException {
        
    		
    		//1.创建流的对象
    		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ggc.txt"));
    		
    		//2.写入数据
    		oos.writeInt(100);
    		oos.writeDouble(123.123);
    		oos.writeBoolean(true);
    		oos.writeUTF("abc123我爱你");
    		oos.writeObject(new Date());
    		
    		//3.关闭资源
    		oos.close();
    	}
    }

#### 4.利用对象输入流 读取文件里的数据 ####

import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.util.Date;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        
    		
    		//1.创建流的对象
    		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ggc.txt"));
    		
    		//2.读取数据
    		int readInt = ois.readInt();
    		double readDouble = ois.readDouble();
    		boolean readBoolean = ois.readBoolean();
    		String readUTF = ois.readUTF();
    		Date date = (Date) ois.readObject();
    		
    		
    		System.out.println(readInt);
    		System.out.println(readDouble);
    		System.out.println(readBoolean);
    		System.out.println(readUTF);
    		System.out.println(date);
    		
    		//3.关闭资源
    		ois.close();
    		
    	}
    }

#### 5.利用对象输出流 向文件写入 自定义对象 ####

import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class Test03 {
    
    	public static void main(String[] args) throws FileNotFoundException, IOException {
    		
    		//1.创建流的对象
    		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ggc.txt"));
    		
    		//2.写入数据
    		oos.writeObject(new User("12345678","123456","卧龙","诸葛亮",1000,300));
    		oos.writeObject(new User("12345679","123455","大都督","周瑜",1000,350));
    		oos.writeObject(new User("12345677","123444","江东小霸王","孙策",2000,500));
    		oos.writeObject(new User("12345676","123333","常山赵子龙","赵云",1000,400));
    		oos.writeObject(null);
    		
    		//3.关闭资源
    		oos.close();
    	}
    	
    }

import java.io.Serializable;
    
    public class User implements Serializable{
        
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	private String username;
    	private String password;
    	private String name;
    	private String role;
    	private double hp;
    	private double mp;
    	
    	public User() {
        
    	}
    
    	public User(String username, String password, String name, String role, double hp, double mp) {
        
    		this.username = username;
    		this.password = password;
    		this.name = name;
    		this.role = role;
    		this.hp = hp;
    		this.mp = mp;
    	}
    
    	public String getUsername() {
        
    		return username;
    	}
    
    	public void setUsername(String username) {
        
    		this.username = username;
    	}
    
    	public String getPassword() {
        
    		return password;
    	}
    
    	public void setPassword(String password) {
        
    		this.password = password;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public String getRole() {
        
    		return role;
    	}
    
    	public void setRole(String role) {
        
    		this.role = role;
    	}
    
    	public double getHp() {
        
    		return hp;
    	}
    
    	public void setHp(double hp) {
        
    		this.hp = hp;
    	}
    
    	public double getMp() {
        
    		return mp;
    	}
    
    	public void setMp(double mp) {
        
    		this.mp = mp;
    	}
    
    	@Override
    	public String toString() {
        
    		return "User [username=" + username + ", password=" + password + ", name=" + name + ", role=" + role + ", hp="
    				+ hp + ", mp=" + mp + "]";
    	}
    
    	
    }

#### 6.利用对象输入流 读取文件里的自定义对象 ####

import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    public class Test04 {
        
    
    	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        
    		//1.创建流对象
    		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ggc.txt"));
    		
    		//2.读取数据
    		User user;
    		while ((user =(User) ois.readObject()) != null) {
        
    			System.out.println(user);
    		}
    		
    		//3.关闭资源
    		ois.close();
    	}
    }

### 三、内存流 ###

#### 1.含义：将数据存储在内存中 ####

> 注意：内存流是关闭不掉的（因为程序员没有权限关闭流到内存的通道）  
> 应用场景：频繁使用的数据不会存入文件中，因为内存与硬盘交互的越多程序性能越低，所以可以将频繁使用的数据通过内存流存入到内存中

class ByteArrayInputStream --- 内存输入流
    	class ByteArrayOutputStream -- 内存输出流

#### 2.使用内存输出流 ####

import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		ByteArrayOutputStream baos = new ByteArrayOutputStream();
    		
    		//2.写入数据
    		baos.write("123abc".getBytes());
    		
    		//获取对象中的数据 -- 以字节数组的形式
    		byte[] byteArray = baos.toByteArray();
    		System.out.println(new String(byteArray));
    		
    		//获取对象中的数据 -- 以字符串的形式
    		String string = baos.toString();
    		System.out.println(string);
    		
    		//内存流是关闭不掉的（因为程序员没有权限关闭流到内存的通道）
    		baos.close();
    	}
    }

#### 3.使用内存输入流 ####

import java.io.ByteArrayInputStream;
    import java.io.IOException;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象(创建流时，将数据存储到流对象中)
    		ByteArrayInputStream bais = new ByteArrayInputStream("123abcd".getBytes());
    		
    		//2.读取数据
    		byte[] bs = new byte[1024];
    		int len;
    		while ((len = bais.read(bs)) != -1) {
        
    			System.out.println(new String(bs, 0, len));
    		}
    		//内存流是关闭不掉的（因为程序员没有权限关闭流到内存的通道）
    		bais.close();
    	}
    }

### 四、打印流 ###

class PrintStream -- 字节打印流 （输出流）
    		注意：可以将字节流转换为字节打印流
    	class PrintWriter -- 字符打印流 （输出流）
    		注意：可以将字节流/字符流转换为字符打印流
    	注意：系统标准输入、输出、错误输出流的重定向

#### 1.使用字节打印流 ####

import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws FileNotFoundException {
        
    		
    		//1.创建流的对象
    		//PrintStream ps = new PrintStream("ggc.txt");
    		
    		//1.创建流对象(文件字节输出流 --> 字节打印流) + 末尾追加内容
    		
    		PrintStream ps = new PrintStream(new FileOutputStream("ggc.txt"));
    		
    		//2.写入数据
    		ps.println("123456adc我爱你");
    		
    		//3.关闭资源
    		ps.close();
    	}
    }

#### 2.使用字符打印流 ####

import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		//PrintWriter pw = new PrintWriter("ggc.txt");
    		
    		//1.创建流对象(文件字节输出流 --> 字符打印流) + 末尾追加内容
    		//PrintWriter pw = new PrintWriter(new FileOutputStream("ggc.txt",true));
    		
    		//1.创建流对象(文件字符输出流 --> 字符打印流) + 末尾追加内容
    		PrintWriter pw = new PrintWriter(new FileWriter("ggc.txt",true));
    		
    		//2.写入数据
    		pw.println("123abc牛头人");
    		
    		//3.关闭资源
    		pw.close();
    	}
    }

### 五、重定向 ###

#### 1.含义： ####

> 重新定义系统标准的输入流/输出流及错误输出流的方向

#### 2.系统标准的输入流（方向：控制台->程序） ####

> 重定向 – System.setIn(new FileInputStream(“hhy.txt”));
> 
> 重定向后（方向：文件->程序）

import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Scanner;
    
    public class Test03 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		//重定向
    		System.setIn(new FileInputStream("ggc.txt"));
    		
    		Scanner scan = new Scanner(System.in);
    		String next = scan.next();
    		System.out.println(next);
    		scan.close();
    	}
    }

#### 3.系统标准的输出流（方向：程序->控制台） ####

> 重定向 – System.setOut(new PrintStream(“hhy.txt”));
> 
> 重定向后（方向：程序->文件）

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.PrintStream;
    
    public class Test04 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//重定向
    		System.setOut(new PrintStream(new FileOutputStream("ggc.txt",true)));
    		
    		PrintStream out = System.out;
    		out.println("小赵小可爱，皇冠给你带~~~");
    	}
    }

#### 4.系统标准的错误输出流（方向：程序->控制台） ####

> 重定向 – System.setErr(new PrintStream(“hhy.txt”));
> 
> 重定向后（方向：程序->文件）

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.PrintStream;
    
    public class Test05 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//重定向
    		System.setErr(new PrintStream(new FileOutputStream("ggc.txt",true)));
    		
    		PrintStream err = System.err;
    		err.println("小赵小可爱，皇冠给你带~~~");
    	}
    }

### 六、随机访问流 ###

#### 1.含义： ####

> 该类认为文件是一个大型的byte数组，底层由隐藏的指针(下标)，指针默认为0(可以设置指针的位置)，  
> 可以从指针的位置开始读取或写入(说明该流有两个方向)

#### 2.模式： ####

>     r -- 读
>       				rw - 读写

#### 3.利用随机访问流 向文件写入数据 ####

import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test01 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		RandomAccessFile r = new RandomAccessFile("ggc.txt","rw");
    		
    		//2.写入数据
    		r.write("123abc我爱你".getBytes());
    		
    		//3.关闭资源
    		r.close();
    	}
    }

#### 4.利用随机访问流 向文件写入数据在文件末尾追加 ####

import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test02 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		File file = new File("ggc.txt");
    		RandomAccessFile raf = new RandomAccessFile(file, "rw");
    		
    		//设置指针位置
    		raf.seek(file.length());//将指针设置到文件末尾
    		
    		//2.读取数据
    		raf.write("123abcd我爱你哟".getBytes());
    		
    		//3.关闭资源
    		raf.close();
    	}
    }

#### 5.利用随机访问流 读取文件里的数据 ####

import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test03 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流对象
    		RandomAccessFile raf = new RandomAccessFile("ggc.txt", "r");
    		
    		//2.读取数据
    		byte[] b = new byte[1024];
    		int len;
    		while ((len = raf.read(b)) != -1) {
        
    			System.out.println(new String(b, 0, len));
    		}
    		//3.关闭资源
    		raf.close();
    	}
    }

#### 6.利用随机访问流 读取文件里的数据从英文处开始读取 ####

import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test04 {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		//1.创建流的对象
    		RandomAccessFile raf = new RandomAccessFile("ggc.txt", "r");
    		
    		//设置文件指针
    		raf.seek(3);
    		
    		//2.读取数据
    		byte[] b = new byte[1024];
    		int len;
    		while ((len = raf.read(b)) != -1) {
        
    			System.out.println(new String(b, 0, len));
    		}
    		
    		//3.关闭资源
    		raf.close();
    	}
    }

#### 7.拷贝文本文件 ####

import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class Copy {
        
    
    	public static void main(String[] args) throws IOException {
        
    		
    		FileReader fr = new FileReader("ggc.txt");
    		FileWriter fw = new FileWriter("copy.txt");
    		
    		char[] cs = new char[1024];
    		int len;
    		while ((len = fr.read(cs)) != -1) {
        
    			fw.write(cs, 0, len);
    		}
    		fr.close();
    		fw.close();
    	}
    }