JavaIO的常用方法

使用io的目的是想要读写文件内部的内容，读写的方案就是流，既创建管道，让数据以流动的形式，先入先出的方式进行传输；

数据从数据源流向目的地；

java提供了IO包供用户使用；

流的分类

流向分: (以程序为中心)

输入流

输出流

操作单元分:

字节流:任何数据都可以传输

字符流: 文本

功能分:

节点流: 操作基本功能的,实现读入写出的,数据从数据源头到目的地的

功能流: 增强功能,提高性能,操作与节点流之上的

节点流:

1.字节流 :任意类型的数据都能读写

字节输入流

InputStream

字节输出流

OutputSream

字节输入流的方法：

JavaIO的常用方法

字节输出流的方法：

JavaIO的常用方法

字节输入流 InputStream例：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class IODemo01 {
	public static void main(String[] args) throws IOException {
		//1.建立联系		
		File file=new File("D:/haha.txt");
		//2.选择流 
		//FileInputStream is=new FileInputStream(file);
		FileInputStream is=new FileInputStream("D:/haha.txt");
		//3.读 
		//read() 读取一个字节数据 返回读取到的字节数|没读到的-1
		int num=is.read();
		System.out.println((char)num);
		int num2=is.read();
		System.out.println((char)num2);
		int num3=is.read();
		System.out.println((char)num3);		
		System.out.println(is.read());
		//4.关闭
		is.close();
	}
}

字节输出流 OutputSream例：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class IODemo04 {
	public static void main(String[] args) throws IOException {
		//注意:目标文件如果不存在,系统会自动为你创建,但是目录不会
		//1.选择流  boolean append ->true追加  ,false->不追加覆盖
		OutputStream os=new FileOutputStream("D:/lalala.txt",true);
		//2.写出
		byte[] str="不吃饭修仙哈哈哈".getBytes();
//		os.write(str);
		os.write(str,0,3);
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
	}
}

使用字节流实现输入输出的时候，我们就可以实现文件的拷贝，将文件转换为字节的形式然后以字节的形式读取出来，实现文件的还原

字节流文件拷贝：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;



public class CopyUtils {
	public static void main(String[] args) {
		copyFile("D:/haha.txt","D:/hehe.txt");
	}
	 
	//文件拷贝方法的重载用来接收字符串形式的文件绝对路径
	public static void copyFile(String src,String dest){
		copyFile(new File(src),new File(dest));
	}
	
        //文件的拷贝  返回值:没有      参数:数据源路径  目的地路径
	public static void copyFile(File src,File dest){
		//1.选择流
		InputStream is = null;
		OutputStream os= null;
		try {
			is = new FileInputStream(src);
			os= new FileOutputStream(dest);
			//2.读写
			byte[] car= new byte[1024];
			int len = -1; //读入到数组中的字节个数
			while((len=is.read(car))!=-1){
				os.write(car, 0, len);
			}
			//3.刷出
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			//4.后打开的先关闭
			try {
				if(os!=null){
					os.close();
				}
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}		
	}
}

2.字符流 :只度写纯文本

字符输入流： Reader FileReader

字符输出流： Writer FileWriter

例：

public class CharIO01 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		Reader rd=new FileReader("D:/haha.txt");
		Writer rt=new FileWriter("D:/cc.txt");
		//2.读写
		char[] car=new char[1024];
		int len=-1; //存储数据的个数
		
		while((len=rd.read(car))!=-1){
			rt.write(car, 0, len);
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
		rd.close();
	}
}

功能流:作用与节点流

3.缓冲流:增加功能,提高性能,提高读写效率

字节缓冲输入流：

BufferedInputStream

字节缓冲输出流：

BufferedOutputStream

字符缓冲输入流：

BufferedReader

字符缓冲输出流：

BufferedWriter

字节缓冲输入流：

BufferedInputStream

方法：

JavaIO的常用方法

字节缓冲输出流：BufferedOutputStream

方法：

JavaIO的常用方法

例：

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.io.InputStream;
import java.io.OutputStream;

public class BufferedDemo01 {
	public static void main(String[] args) throws IOException {
		//1.流
		InputStream is = new BufferedInputStream(new FileInputStream("D:/haha.txt"));
		OutputStream os=new BufferedOutputStream( new FileOutputStream("D:/dd.txt"));
		//2.读写
		byte[] car = new byte[1024];
		int len=-1;
		while(-1!=(len=is.read(car))){
			os.write(car,0,len);
		}
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		is.close();
	}

}

字符缓冲输入流：BufferedReader

方法：

JavaIO的常用方法

字符缓冲输出流：BufferedWriter

方法：

JavaIO的常用方法

例：

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

public class BufferedDemo02 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		BufferedReader rd=new BufferedReader(new FileReader("D:/haha.txt"));
		BufferedWriter rt=new BufferedWriter(new FileWriter("D:/aaa.txt"));
		//2.读入
		String msg=null;
		while((msg = rd.readLine())!=null){
			rt.write(msg);
			rt.newLine(); //换行
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
		rd.close();
	}
}

4.转换流:字节转字符

字节转换字符输入流：InputStreamReader

字节转换字符输出流：OutputStreamWriter

字节转换字符输入流：InputStreamReader

方法：

JavaIO的常用方法

字节转换字符输出流：OutputStreamWriter

方法：

JavaIO的常用方法

例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;


public class ChangeDemo02 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		BufferedReader rd=new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream("D:/haha.txt"))));
		BufferedWriter rt=new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("D:/bbb.txt"))));
		String msg=null;
		//2.读入写出
		while((msg=rd.readLine())!=null){
			rt.write(msg);
			rt.newLine();
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
	}
}

5.Data流:基本数据类型|String+数据：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型

DataInputStream

DataOutputStream

实例：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 基本数据类型流:字节流的功能流
 * 	读写带有基本数据类型|字符串类型的数据
 *  DataInputStream 
 *  	新增方法: ReadXxx()
 *  DataOutputStream
 *  	新增方法: writeXxx()
 *  	不能发生多态
 */
public class DataDemo03 {
	public static void main(String[] args) throws IOException {
		write("D:/eee.txt");
		read("D:/eee.txt");
	}
	//写入
	public static void read(String src) throws IOException{
		//1.输入流
		DataInputStream in=new DataInputStream(new FileInputStream(src));
		//2.读入  读入和写出的顺序要保持一致
		boolean b=in.readBoolean();
		int i=in.readInt();
		String s=in.readUTF(); 
		System.out.println(b+"-->"+i+"-->"+s);
		//3.关闭
		in.close();
	}
	
	//写出
	public static void write(String dest) throws IOException{
		//1.输出流
		DataOutputStream out=new DataOutputStream(new FileOutputStream(dest));
		//2.准备数据
		boolean flag=false;
		int i=100;
		String s="哈哈";
		//3.写出
		out.writeBoolean(flag);
		out.writeInt(i);
		out.writeUTF(s);
		//4.刷出
		out.flush();
		//5.关闭
		out.close();
	}
}

6.对象流:任意类型,包括对象+数据：一个ObjectInputStream反序列化的原始数据和对象之前使用一个ObjectOutputStream写的

ObjectInputStream

ObjectOutputStream

对象流:数据+数据类型

序列化和反序列化:序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程

序列化输出流 : ObjectOutputStream

反序列化输入流: ObjectInputStream

先序列化后反序列化

不是所有的类都能序列化实现java.io.Serializable接口

不是所有的属性都需要序列化 transient

静态的内容不能序列化

如果父类有实现序列化,子类没有,子类中所有的内容都能序列化

如果父类中没有实现序列化,子类有实现序列化,子类只能序列化自己的内容

实例：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;

public class ObjectDemo04 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		write();
		read();
	}
	//序列化输出
		public static void read() throws FileNotFoundException, IOException, ClassNotFoundException{
			//1.流
			ObjectInputStream is=new ObjectInputStream(new FileInputStream("D:/object.txt"));
			//2.读入写出读入的顺序保持一致
			Object p=is.readObject();
			System.out.println(p);
			if(p instanceof Person){
				Person p1=(Person)p;
				System.out.println(p1);
			}
			System.out.println(Arrays.toString((int[])is.readObject()));
			//3.关闭
			is.close();
		}
	//序列化输出
	public static void write() throws FileNotFoundException, IOException{
		//1.流
		ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:/object.txt"));
		//2.写出
		Person p=new Person("lisi",20);
		int[] arr=new int[]{1,2,3,4,5};
		//写出读入的顺序保持一致
		out.writeObject(p);
		out.writeObject(arr);
		//3.刷出
		out.flush();
		//4.关闭
		out.close();
		
		p.setAge(100);
		p.setName("王五");
	}
}

class Person implements Serializable{
	private String name;
//	private transient int age;
	private static int age;
	
	public Person() {
		// TODO Auto-generated constructor stub
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

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

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

JavaIO的常用方法

继续阅读

java笔记（三）：IO流InputStreamOutputStreamReaderWriter

Lesson_for_java_day16--java中的异常和IO流(File类、字节流、字符流、指定编码格式)

黑马程序员——java基础之IO流IO流

java网络爬虫爬取邮箱地址

字节流(InputStream)输入中文汉字到控制台出现乱码的问题解析

file类常用的一些方法

NIO流，面向缓冲区流，一篇文章解决NIO流基础

IO流之打印流PrintStream和PrintWriter

基于java Swing测TCP Socket 实例

IO流 System.in BufferedReader的readLine()方法 toUpperCase()方法 equalsIgnoreCase("exit")

JAVA递归实现输入任意目录，列出文件以及文件夹。

第二十一章 IO流1

IO之File类

学生信息管理系统（IO流）

对象序列化代码

关于IO流的笔试面试题