I/O流

1. IO: input和output两个单词的缩写, input 是输入, output是输出.
	输入输出的参照物: 内存
	站在内存的角度, 数据从其他设备进入内存, 就是输入. 数据从内存进入其他设备就是输出.
2. I/O就是就是java提供的用于设备与设备之间进行数据传输的类型.
3. java中操作设备与设备之间数据传输的对象,都定义在了java.io包下. 这些类的对象都属于流对象.

字节流

字节流是可以直接操作字节的流对象,根据流向分为字节输入流(InputStream)和字节输出流(OutputStream).

缓冲字节输入流

InputStream 为抽象类,不能实例化,是 FileInputStream 和 BufferedInputStream 的父类.
BufferedInputStream 叫做缓冲字节输入流,读取效率比普通字节输入流 FileInputStream 高,
所以我们大多使用缓冲字节输入流来进行读取数据.
需要用到的方法:
	read:
		read();
			每次读取一个字节,返回读取到的字节内容,如果读到末尾,返回-1.
		read(byte[] b); --常用
			每次读取b数组长度个字节并储存在数组中,返回值为读取到的字节个数,如果读到末尾返回-1.
			一般b数组长度为1024的偶数倍.在缓冲流中,b数组起缓冲作用.
		read(byte[] b,int setoff,int length);
			不常用,暂时不理解.
	close();
		关流.
读取步骤:
	1.创建要读取文件的File类对象.
		File file = new File("路径");
	2.创建FileInputStream对象
		FileInputStream fis = new FileInputStream(file);
	3.创建BufferedInputStream对象
		BufferedInputStream bis = new BufferedInputStream(fis);
	前三步课可以写成一句:
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("路径")));
	4.read(byte[] b);
		先创建一个数组作为参数,然后读取,读取时数组中储存的就是读取到的字节.
	5.close();

package com.youjiuye.prictice;

import java.io.BufferedInputStream;

public class 缓冲字节输入流 {
	/*
	 1.创建File对象
	 2.创建FileInputStream对象
	 3.创建BufferedInputStream
	 4.read
	 5.close
	 */
	public static void main(String[] args) throws IOException {
		/*File file = new File("1.txt");
		FileInputStream fileInputStream = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(fileInputStream);*/
		//创建缓冲输入流对象,直接写成一句代码
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("1.txt")));
		//创建一个缓存用的数组
		byte[] arr = new byte[1024*8];
		//len表示每次读取到字符的个数.
		int len;
		//当bis.read();返回值为-1时表示读取结束.
		while((len = bis.read(arr)) != -1) {
			System.out.println(new String(arr,0,len));
		}
		//记得关流
		bis.close();
	}

}

缓冲字节输出流

OutputStream 为抽象类,不能实例化,是 FileOutputStream 和 BufferedOutputStream 的父类.
BufferedOutputStream 叫做缓冲字节输出流,写出效率比普通字节输出流 FileOutputStream 高,
所以我们大多使用缓冲字节输出流来进行写出数据.
需要用到的方法:
	writa:
		write();
		每次写出一个字节到指定文件,返回值为写出的字节.
		write(byte[] b);
		写入b数组中的字节.b数组成都通常为1024的整数倍.
		write(byte[] b,int setoff,int len); --常用
		将数组b中的字节从setoff开始到第len个字节写出到指定文件.
		(write方法其实可以有两个参数,第二个参数如果是true则不删除文件内原来的数据,接着存.
		默认为false,删除存.)
	close:
		关流.
写出步骤:
	1.创建要写到文件的File类对像.
	File file = new File("路径");
	2.创建FileOutputStream对象
	FileOutputStream fos = new FileOutputStream(file);
	3.创建BufferedOutputStream对象
	BufferOutputStream bos = new BufferedOutputStream(fos);
	用一个语句完成:
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("路径"));
	4.write(byte[] b,int setoff,int len);
		保证都多少写多少.
	5.close;

package com.youjiuye.prictice;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class 缓冲字节输出流 {
	/*1.创建要拷贝到的文件file对象
	  2.创建FileOutputStream();
	  3.创建BufferOutputStream();
	  4.write
	  5.close
	*/
	public static void main(String[] args) throws IOException {
		/*File file = new File("2.txt");
		FileOutputStream fos = new FileOutputStream(file);
		BufferedOutputStream bos = new BufferedOutputStream(fos);*/
		//在一个语句中完成BufferedOutputStream对象的创建
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(
					new File("2.txt"),true));
		//字符串转为byte数组
		byte[] b = "123aaa晚上吃什么".getBytes();
		//写一个数组中的全部内容
		bos.write(b);
		//关流
		bos.close();
	}

}

拷贝

package com.youjiuye.prictice;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class 缓冲字节流拷贝 {

	public static void main(String[] args) throws IOException {
		long start = System.currentTimeMillis();
		//创建BufferedInputStream和BufferedOutputStream对象
		BufferedInputStream bis = new BufferedInputStream(
				new FileInputStream(
						new File("C:\\Users\\Administrator\\Desktop\\cs1\\测试视频.wmv")));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(
						new File("C:\\Users\\Administrator\\Desktop\\cs2\\copy1.wmv")));
		
		//创建缓存数组
		byte[] b = new byte[1024 * 8];
		
		//创建每次读取字符个数对象
		int len;
		
		//读取多少写出多少
		while((len = bis.read(b)) != -1) {
			bos.write(b, 0, len);
		}
		
		//先开后关,后开先关
		bos.close();
		bis.close();
		
		long end = System.currentTimeMillis();
		System.out.println("time:" + (end - start));
	}

}

如果不用缓冲流,速度感人!!!

字符流

字符输入流和字符输出流的顶层父类分别为Reader和Writer, 他的两个子类普通字符流和缓冲字符输出流如下图:

缓冲字符输入流的使用方法:
	1.创建要读取文件的File类对象.
		File file = new File("路径");
	2.创建普通字符流对象.
		FileReader fr = new FileReader(file);
	3.创建缓冲字符流对象:
		BufferedReader br = new BufferedReader(fr);
		前三步可以写在一个语句中
	4. br.read();
	5.br.close

缓冲字符输出流用法:
	1.创建要写出到文件的File类对象
	2.创建普通字符输出流对象
	3.创建缓存字符输出流对象
	4.bw.write();
	5.bw.close();

练习:

/*文本1:
	123
	asd
	zxc
copy:
	zxc
	asd
	123*/
package com.youjiuye.prictice;

import java.io.BufferedInputStream;

public class 反向拷贝 {

	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("C:\\Users\\Administrator\\Desktop\\cs1\\文本1.txt");
		FileWriter fw = new FileWriter("C:\\Users\\Administrator\\Desktop\\cs2\\copy.txt");
		BufferedReader buffr = new BufferedReader(fr);
		BufferedWriter buffw = new BufferedWriter(fw);
		
		ArrayList<String> list = new ArrayList<>();
		String line ;
		//读取一行
		while((line = buffr.readLine()) != null) {
			System.out.println(line);
			list.add(line);
		}
		buffr.close();
		//工具类反转方法
		Collections.reverse(list);
		for (String inString : list) {
			buffw.write(inString);
			//换行
			buffw.newLine();
		}
		buffw.close();
		
	}
}

字符流的拷贝

在这里插入代码片

properties

Properites是Hashtable的子类,所以我们Map接口接口学习所有方法,
这个类也能使用.

package com.youjiuye.study;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Properties_修改配置文件 {

	public static void main(String[] args) throws IOException, IOException {
		//创建Properyies集合对象，用来缓存
		Properties p = new Properties();
		//读取
		p.load(new BufferedInputStream(new FileInputStream("zx.properties")));
		System.out.println(p);
		//修改集合缓存的数据
		p.setProperty("age", "24");
		//写出到指定文件
		p.store(new BufferedOutputStream(new FileOutputStream("zx.properties")), "age 修改");
	}

}