3.IO体系

文章目录

一.IO流分类和操作模板
二.系统属性
三.字节的输出流
四.字节输入流
五.复制文件内容FileInputStream
六.内存流
七.转换流
八.缓冲流
九.打印流
十.Scanner
十一.重定向标准输出,输入流
十二.对象流

一.IO流分类和操作模板

根据流向划分:输入流和输出流
根据数据的单位划分:字节流和字符流
根据功能的划分:节点流和包装流
四大基流:
1. 字符输入,输出流
2. 字节输入,输出流

![image][Reader]

不能创建四大基流的对象,只能创建其子类对象,无论什么流,都有close方法,用来关闭资源,
操作文件就得开通一个流对象,关联我们的磁盘文件,如果不关闭资源,那么的文件一直被程序引用着
,不能删除,也不能更改
IO流操作的模板:
1. 创建源或者目标对象(文件)
  拿文件流举例
  1. 输入操作:把文件中的数据流向到程序中,此时文件是源,程序是目标
  2. 输出操作:把程序中的数据流向到文件中,此时文件是目标,程序是源
2. 创建IO流对象(水管)
  1. 输入操作:创建流对象
  2. 输出操作:创建输出流对象
3. 具体IO操作
  1. 输入操作:输入流对象的read方法
  2. 输出操作:输入流对象的write方法
4. 关闭资源(勿忘)
  1. 输入操作:输入流对象.close();
  2. 输出操作:输出流对象.close();
5. 操作IO流
  读进来,写出去.
  1. 读进来:进来强调输入,读说明read方法
  2. 写出去:出去强调输出,写说明是write方法

二.系统属性

纯文本文件
文件流:

FileputStream:文件的字节输入流
FileOutputStream:文件的字节输出流
FileReader:文件的字节输入流
FileWriter:文件的字符输出流
键 相关值的描述
java.version Java 运行时环境版本
java.vendor Java 运行时环境供应商
java.vendor.url Java 供应商的 URL
java.home Java 安装目录
java.vm.specification.version Java 虚拟机规范版本
java.vm.specification.vendor Java 虚拟机规范供应商
java.vm.specification.name Java 虚拟机规范名称
java.vm.version Java 虚拟机实现版本
java.vm.vendor Java 虚拟机实现供应商
java.vm.name Java 虚拟机实现名称
java.specification.version Java 运行时环境规范版本
java.specification.vendor Java 运行时环境规范供应商
java.specification.name Java 运行时环境规范名称
java.class.version Java 类格式版本号
java.class.path Java 类路径
java.library.path 加载库时搜索的路径列表
java.io.tmpdir 默认的临时文件路径
java.compiler 要使用的 JIT 编译器的名称
java.ext.dirs 一个或多个扩展目录的路径
os.name 操作系统的名称
os.arch 操作系统的架构
os.version 操作系统的版本
file.separator 文件分隔符（在 UNIX 系统中是“/”）
path.separator 路径分隔符（在 UNIX 系统中是“:”）
line.separator 行分隔符（在 UNIX 系统中是“/n”）
user.name 用户的账户名称
user.home 用户的主目录
user.dir 用户的当前工作目录

三.字节的输出流

新建类FileOutputStreamDemo

public class FileOutputStreamDemo {

	public static void main(String[] args) throws Exception {
		//创建源
		File file = new File("file.txt");
		//创建管道,true表明可以追加
		FileOutputStream output = new FileOutputStream(file, true);
		//写入操作
		//output.write(65);
		output.write("ABCDE".getBytes());
		output.write("huangkun".getBytes(), 2, 3);
		//关闭资源对象
		output.close();
	}
}

void write(byte[] b)  将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void write(byte[] b, int off, int len)  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
void write(int b)  将指定字节写入此文件输出流。

四.字节输入流

int read()  从此输入流中读取一个数据字节。
int read(byte[] b)  从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
int read(byte[] b, int off, int len)  从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

新建类FileInputStreamDemo

public class FileInputStreamDemo {
	public static void main(String[] args) throws Exception {
		//创建源
		File file = new File("file.txt");
		//创建InputStream对象
		InputStream is = new FileInputStream(file);
		//读写操作 
		
		//int read();
		//读写一个字符并返回一个int类型,如果没有字符了,返回-1;
/*		System.out.println(is.read());
		System.out.println(is.read());
		System.out.println(is.read());
		System.out.println(is.read());
		System.out.println(is.read());
		System.out.println(is.read());
		System.out.println(is.read());*/
		
		byte[] b = new byte[5];
		//int read(byte[] b)
		//throws IOException从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
//在某些输入可用之前，此方法将阻塞。
/*		is.read(b);
		System.out.println(Arrays.toString(b));*/
		
		
/*		is.read(b, 2, 3);
		System.out.println(Arrays.toString(b));*/
		
		int len = -1;
		while ((len = is.read(b,0,5)) != -1) {
			String s = new String(b,0,len);
			System.out.println(s);
		}
		//关闭资源
		is.close();
	}
}

五.复制文件内容FileInputStream

使用字节流复制文件
新建类FileInputStreamCopyDemo

public class FileInputStreamCopyDemo {
	public static void main(String[] args) {
		copyFile();

	}

	private static void copyFile() {
		try {
			//创建字符流对象
			InputStream in = new FileInputStream("D:/Java.java");
			OutputStream out = new FileOutputStream("D:/huangkun.txt");
			//创建存放字节数组
			byte[] buf = new byte[1024];
			//长度
			int len = -1;
			while ((len = in.read(buf, 0, 1024)) != -1) {
				//边读边写
				out.write(buf, 0, len);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

使用字符流复制文件
新建类FileReadDemo

public class FileReadDemo {
	public static void main(String[] args) {
		copy();
	}

	private static void copy() {
		Reader reader = null;
		Writer writer = null;
		try {
			reader = new FileReader("D:/Java.java");
			writer = new FileWriter("D:/huangkun.txt");
			int len = -1;
			char[] buff = new char[1024];
			while ((len = reader.read(buff)) != -1) {
				writer.write(buff, 0, len);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			closeIO(reader);
			closeIO(writer);
		}
	}

	private static void closeIO(Closeable closeObject) {
		try {
			closeObject.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

使用Files工具复制文件
创建类CopyFileDemo1

public class CopyFileDemo1 {
	public static void main(String[] args) {
		//copy1();
		copy2();
		
	}

	private static void copy2() {
		Path source = Paths.get(new File("D:/java.java").toURI());
		OutputStream out = null;
		try {
			out = new FileOutputStream("D:/huangkun.txt");
			Files.copy(source, out);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}

	private static void copy1() {
		Path source = Paths.get(new File("D:/java.java").toURI());
		Path target = Paths.get(new File("D:/huangkun.txt").toURI());
		try {
			Files.copy(source, target);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

六.内存流

目标输入输出位置为内存

ByteArrayOutputStream
ByteArrayInputStream
CharArrayWriter
CharArrayReader

内存字节流
新建类ByteArrayOutInputStreamDemo

//使用内存字节流把数据缓存到内存中,并取出来,大写的格式
public class ByteArrayOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		//创建字符串
		String msg = "huangkun";
		//创建内存流对象 ByteArrayInputStream
		InputStream in = new ByteArrayInputStream(msg.getBytes());
		OutputStream out = new ByteArrayOutputStream();
		//读出来的字节
		int len = 0;
		while ((len = in.read()) != -1) {
			//取出来,转换成大写的格式
			out.write(Character.toUpperCase(len));
		}
		String target = out.toString();
		System.out.println(target);
	}
}

内存字符流
新建类CharArrayReaderDemo

//内存字符流,,把字符串写入内存,并读出来,以大写的形式
public class CharArrayReaderDemo {
	public static void main(String[] args) {
		//定义字符串
		String msg = "huangkun";
		//把字符串转换成字符数组,创建内存字符流对象
		Reader in = new CharArrayReader(msg.toCharArray());
		Writer out = new CharArrayWriter();
		//字符的长度
		int len = 0;
		try {
			while ((len = in.read()) != -1) {
				//读出来,大写的形式
				out.write(Character.toUpperCase(len));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		//读出字符串
		String s = out.toString();
		System.out.println(s);
	}
}

七.转换流

新建类TransitionIODemo

//字节流转换字符流,复制文件
public class TransitionIODemo {
	public static void main(String[] args){
		Reader reader = null;
		Writer writer =null;
		try {
			//创建字节流对象
			InputStream in = new FileInputStream("D:/java.java");
			OutputStream out = new FileOutputStream("D:/huangkun.java");
			//创建字符流对象,并把字节流载入
			reader = new InputStreamReader(in);
			writer = new OutputStreamWriter(out);
			//创建长度
			int len = 0;
			//创建一个字符数组,存放字符
			char[] c = new char[1024];
			//边读边写
			while ((len = reader.read(c)) != -1) {
				writer.write(c,0,len);
			}
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			//关闭资源
			try {
				reader.close();
				writer.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

八.缓冲流

使用缓冲流拷贝文件
新建类BufferedOutputStreamDemo

public class BufferedOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		copyFile();
	}

	private static void copyFile() {
		BufferedReader br = null;
		BufferedWriter bw = null;
		try {
			br = new BufferedReader(new FileReader("D:/java.java"));
			bw = new BufferedWriter(new FileWriter("D:/huangkun.java"));
			String line = null;
			while ((line = br.readLine()) != null) {
				bw.write(line);
				bw.newLine();
			}
		} catch (IOException e) {
			//关闭流操作
			try {
				br.close();
				bw.close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
			e.printStackTrace();
		}

	}
}

九.打印流

新建类PrintStreamDemo

//打印流
public class PrintStreamDemo {
	public static void main(String[] args) {
		String name = "huangkun";
		int num = 12;
		float PI = 12f;
		char c = 'H';
		System.out.printf("名字: %s,年龄: %d,PI: %f,字符: %c",name,num,PI,c);
		System.out.println();
		System.out.printf("名字: %s,年龄: %s,PI: %s,字符: %s",name,num,PI,c);
	}
}

十.Scanner

新建类ScannerDemo

//使用正则表达式来解析基本类型和字符串的简单文本扫描器
public class ScannerDemo {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		while (s.hasNextLine()) {
			System.out.println("你输入的数据为: " + s.nextLine());
		}
	}
}

新建类UseDilimiterDemo

/*
 * 将此扫描器的分隔模式设置为指定模式
 * */
public class UseDelimiterDemo {
	public static void main(String[] args) {
		String msg = "10-23-43-34";
		Scanner s = new Scanner(msg);
		s.useDelimiter("-");//使用-分隔元素
		while (s.hasNext()) {
			System.out.print(s.next() + " ");
		}
	}
}

十一.重定向标准输出,输入流

//重定向标准输出输入流
public class SetInDemo {
	public static void main(String[] args) throws FileNotFoundException {
		System.setOut(new PrintStream("D:/java.java"));
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				//每次打印都会输出到文件中
				System.out.print(j + " * " + i + " = " + j * i + "\t");
			}
			System.out.println();
		}
		System.out.println("name:huangkun");
	}
}

十二.对象流

//定义一个类实现接口Serializable
class User implements Serializable {
	private String name;
	private int age;

	//有参构造器
	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	//set,get
	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;
	}

	//覆盖toString方法
	public String toString() {
		return "User [name =" + name + "," + "age =" + age + "]";
	}

}

public class ObjectInputStreamDemo {
	//对象流
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		String file = "D:/java.java";
		//创建ObjectOutputStream对象
		ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream(file));
		User u = new User("huangkun", 17);
		//写入对象
		objOut.writeObject(u);
		ObjectInputStream objIn = new ObjectInputStream(new FileInputStream(file));
		//使用Object存储读出来的数据
		Object obj = objIn.readObject();
		System.out.println(obj);

	}
}

huang_kuh

发布了82 篇原创文章 · 获赞 0 · 访问量 1328

私信关注