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

最新推荐文章于 2024-04-26 14:00:07 发布

雨霖先森

最新推荐文章于 2024-04-26 14:00:07 发布

阅读量229

点赞数 1

分类专栏： Java基础文章标签： java jvm 数据结构开发语言面试

本文链接：https://blog.csdn.net/GL280599ZL/article/details/127625009

版权

Java基础专栏收录该内容

44 篇文章 1 订阅

订阅专栏

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();
	}
}

雨霖先森

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
IO流的字符流+对象流+打印流+内存流+随机访问流（2）

abstract class Reader -- 字符输入流的基类（抽象类）abstract class Writer -- 字符输出流的基类（抽象类）class InputStreamReader extends Reader -- 字符输入转换流class OutputStreamWriter extends Writer - 字符输出转换流作用：将字节流转换为字符流class FileReader extends InputStreamReader -- 文件字符输入流。
复制链接

扫一扫