IO流

IO流

IO流:设备与设备之间的数据传输.

IO流的分类:

按流的方向分:

输入流:读数据的

输出流:写数据的

按数据类型分:

字节流:

字节输入流:InputStream

字节输出流:OutputStream

字符流:

字符输入流:Reader

字符输出流:Writer

OutputStream:该类是抽象类.

FileOutputStream是它的子类.构造方法:

public FileOutputStream(string name)

开发步骤:1>创建文件输出流对象.2>写数据.3>关闭资源.

相关代码:

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos=new FileOutputStream("b.txt");
		fos.write("hello,IO,I'm coming".getBytes());
		fos.close();
	}
}

输出流中写数据的方法:

public abstract void write(int b):将指定的字节写入到输出流中.

public void write(byte[] b):将指定的字节数组写入到输出流中.

public void write(byte[] b,int off,int len):将字节数组的一部分写入到输入流中.

换行符:每个系统对应的IO换行符不一样.

windows:\r\n

Linux:\n

Mac:\r
InputStream:是个抽象类.

FileInputStream是它的子类:构造方法:

public FileInputStream(String name)

开发步骤:1>创建文件输入流对象.2>读数据3>释放资源.

输入流中读数据的方法:

public int read():一次读取一个字节.

public int read(byte[] b):一次读取一个字节数组.返回的是实际读取的字节数.

相关代码:

import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream ips=new FileInputStream("C:\\Java\\MapDemo.java");
		byte[] b=new byte[1024];
		int len=0;
		while((len=ips.read(b))!=-1){
			System.out.print(new String(b,0,len));
		}
	}
}

例题:将MapDemo.java文件内容copy到当前目录下的a.txt.

相关代码:

import java.io.FileInputStream;
import java.io.FileOutputStream;

import java.io.IOException;

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream ips=new FileInputStream("C:\\Java\\MapDemo.java");
		FileOutputStream ops=new FileOutputStream("a.txt");
		byte[] b=new byte[1024];
		int len=0;
		while((len=ips.read(b))!=-1){
			ops.write(b,0,len);
		}
		ips.close();
		ops.close();
	}
}

字节缓冲输入流:BufferedInputStream

构造方法:BufferedInputStream(InputStream in):指定默认缓冲区大小创建字节缓冲输入流对象.

字节缓冲输出流:BufferedOutputStream

构造方法:BufferedOutputStream(OutputStream out):指定默认缓冲区大小创建字节缓冲输出流对象.

注意:缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所有缓冲流不能直接对文件操作.

flush()和close()的区别:

flush():刷新缓冲区的流,强迫将缓冲字节都写入该流中,刷新之后可以写数据的.

close():关闭流对象所指向的这个资源文件,一旦关闭,写不入数据.

相关代码:

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

public class BufferedInputStreamDemo {
	public static void main(String[] args) throws IOException {
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("C:\\Java\\MapDemo.java"));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("b.txt"));
		byte[] b=new byte[1024];
		int len=0;
		while((len=bis.read(b))!=-1){
			bos.write(b,0,len);
			bos.flush();
		}
		bis.close();
		bos.close();
	}
}

字符输入流:Reader:抽象类.

InputStreamReader:子类.构造方法:

public InputStreamReader(InputStream in,charest ch):字节输入流+编码模式(默认GBK).

字符输出流:Wreater:抽象类.

OutputStreamWriter:子类.构造方法:

public OutputStreamWriter(OutputStream out,charest ch):字节输出流+编码模式(默认GBK).

相关代码:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\Java\\MapDemo.java"),"GBK");
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("c.txt"),"GBK");
		char[] ch=new char[1024];
		int len=0;
		while((len=isr.read(ch))!=-1){
			osw.write(ch,0,len);
			osw.flush();
		}
		isr.close();
		osw.close();
	}
}

便捷类:FileReader.构造方法:

public FileReader(String filename)

FileWriter.构造方法:

public FileWriter(String filename)

相关代码:

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr=new FileReader("C:\\Java\\MapDemo.java");
		FileWriter fw=new FileWriter("d.txt");
		char[] ch=new char[1024];
		int len=0;
		while((len=fr.read(ch))!=-1){
			fw.write(ch, 0, len);
			fw.flush();
		}
		fr.close();
		fw.close();
	}
}

字符缓冲输入流:BufferedReader.构造函数:

public BufferedReader(Reader in):创建默认缓冲区大小的一个字符缓冲输入流.

特有功能:

public String readLine():一次读取一行.

字符缓冲输出流:BufferedWriter:构造函数:

public BufferedWriter(writer in)"创建默认缓冲区大小的一个字符缓冲输出流.

特有功能:

public void newLine():写入一个换行符. 

相关代码:

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

public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new FileReader("C:\\Java\\MapDemo.java"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt"));
		//一次读取一行
		String line=null;
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		//复制
		copy(br, bw);
	}

	private static void copy(BufferedReader br, BufferedWriter bw)
			throws IOException {
		char[] ch=new char[1024];
		int len=0;
		while((len=br.read(ch))!=-1){
			bw.write(ch,0,len);
			bw.flush();
			bw.newLine();
		}
		br.close();
		bw.close();
	}
}

DataInputStream和DataOutputStream都属于数据流:可以针对Java基本数据类型的数据进行读写.

构造方法:public DataInputStream(InputStream in)和pubic DataOutputStream(OutputStream out)

相关代码:

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

public class DataInputStreamDemo {
	public static void main(String[] args) throws IOException {
//		write();
		//读数据
		read();
		
	}

	private static void read() throws FileNotFoundException, IOException {
		DataInputStream dis=new DataInputStream(new FileInputStream("dos.txt"));
		byte readByte = dis.readByte();
		int readInt = dis.readInt();
		short readShort = dis.readShort();
		long readLong = dis.readLong();
		char readChar = dis.readChar();
		boolean readBoolean = dis.readBoolean();
		float readFloat = dis.readFloat();
		double readDouble = dis.readDouble();
		dis.close();
		System.out.println(readByte);
		System.out.println(readInt);
		System.out.println(readShort);
		System.out.println(readLong);
		System.out.println(readChar);
		System.out.println(readBoolean);
		System.out.println(readFloat);
		System.out.println(readDouble);
	}

	private static void write() throws  IOException {
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
		//写数据
		dos.writeByte(100) ;
		dos.writeInt(1000) ;
		dos.writeShort(120) ;
		dos.writeLong(1000000L);
		dos.writeChar('A') ;
		dos.writeBoolean(true) ;
		dos.writeFloat(11.11F) ; 
		dos.writeDouble(12.12) ;
		dos.close();
	}
}

ByteArrayInputStream和ByteArrayOutputStream:内存操作流,针对内存的数据进行操作,程序一结束,这些内存的数据就会消失.

特点:针对小文件进行操作(聊天室项目中使用它进行发送文件)
ByteArrayInputStream:内存操作输入流.构造函数:

public ByteArrayInputStream(byte[] buf):参数是一个字节数组(缓冲数组)

ByteArrayOutputStream:内存操作输出流:构造函数:

public ByteArrayOutputStream():创建默认的缓冲区大小的内存缓冲输出流(单位是字节.)

成员方法:

public Byte[] toByteArray():创建一个新分配的Byte数组(将内存数据操作流对象转换成数组对象)

void reset():重置内存数据操作流.

注意:此流对象可以不用关闭.

相关代码:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayInputStreamDemo {
	public static void main(String[] args) throws IOException {
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		baos.write(("hello").getBytes());
		baos.write(("Java").getBytes());
		//将内存操作输出流对象转换为字节数组.
		byte[] byteArray = baos.toByteArray();
		ByteArrayInputStream bais=new ByteArrayInputStream(byteArray);
		//一次读一个字节
		int len=0;
		while((len=bais.read())!=-1){
			System.out.print((char)len);
		}
	}
}

结果为:

helloJava

打印流:

字节打印流:PrintStream

字符打印流:PrintWriter

打印流特点:

1>在复制文件时,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)

2>打印流可以有自动刷新功能.

public PrintWriter(Writer out,boolean autoFlush):第二个参数指定为true,则自动刷新.

3>打印流可以直接针对文本文件进行操作.

只要构造方法的参数有File类或者是String类型,都可以针对文本文件进行操作

PrintWriter:构造方法:public PrintWriter(String filename).

写数据时,使用println():换行.

相关代码:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterDemo {
	public static void main(String[] args) throws IOException {
		//封装数据源.
		BufferedReader br=new BufferedReader(new FileReader("a.txt"));
		//封装目的地
		PrintWriter pw=new PrintWriter(new FileWriter("pw.txt"),true);
		String line=null;
		while((line=br.readLine())!=null){
			pw.println(line);
		}
		br.close();
		pw.close();
	}
}	

标准输入流和输出流:System中有两个字段:

in-->InputStream is=System.in;BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

相关代码:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SystemInDemo {
	public static void main(String[] args) {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入一个字符串:");
		String line = null;
		try {
			line = br.readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("您输入的字符串为:"+line);
	}
}

out-->OutputStream ps=System.out;BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));

相关代码:

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class SystemOutDemo {
	public static void main(String[] args) {
		BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
		try {
			bw.write("立华奏");
			bw.newLine();
			bw.write("小薰");
			bw.newLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			if(bw!=null){
				try {
					bw.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入.不是实际意义上的流,因为它来自Object类.

常用的构造方法:

public RandomAccessFile(String name,String mode):参数一:指定文件路径,参数二:指定的一种模式:"rw"(可读可写).

相关代码:

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {
	public static void main(String[] args)  {
//		write();
		reader();
		
	}

	private static void reader() {
		RandomAccessFile raf=null;
		try {
			raf=new RandomAccessFile("raf.txt", "rw");
			byte b=raf.readByte();
			char c=raf.readChar();
			String s=raf.readUTF();
			System.out.println(b);
			System.out.println(c);
			System.out.println(s);
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(raf!=null){
				try {
					raf.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
		}
	}

	private static void write() {
		RandomAccessFile raf=null;
		try {
			raf=new RandomAccessFile("raf.txt", "rw");
			raf.writeByte(100);
			raf.writeChar('a');
			raf.writeUTF("立华奏");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			if(raf!=null){
				try {
					raf.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联.合并流在复制文件的时候,只能操作数据源,不能操作目的地.

构造方法:public SequenceInputStream(InputStream s1,InputStream s2)

相关代码:

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.SequenceInputStream;

public class SequenceInputStreamDemo {
	public static void main(String[] args) {
		//分别封装这个两个文件
		InputStream s1=null;
		InputStream s2=null;
		try {
			s1 = new FileInputStream("a.txt");
			s2 = new FileInputStream("b.txt");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		//创建合并流对象
		SequenceInputStream sis=new SequenceInputStream(s1, s2);
		//封装目的地
		BufferedOutputStream bos=null;
		try {
			bos = new BufferedOutputStream(new FileOutputStream("sis.txt"));
			byte[] b=new byte[1024];
			int len=0;
			while((len=sis.read(b))!=-1){
				bos.write(b,0,len);
				bos.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(sis!=null){
				try {
					sis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bos!=null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

另一种构造方法:复制多个文件:

public SequenceInputStream(Enumeration<? extends InputStream> e)

运用Vector集合的特有功能:public Enumeration<E> elements()

相关代码:

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.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceInputStreamDemo2 {
	public static void main(String[] args) {
		//创建一个Vector集合
		Vector<InputStream> v=new Vector<InputStream>();
		//封装三个文件
		try {
			InputStream is1=new FileInputStream("a.txt");
			InputStream is2=new FileInputStream("b.txt");
			InputStream is3=new FileInputStream("c.txt");
			v.add(is1);
			v.add(is2);
			v.add(is3);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		Enumeration<InputStream> en=v.elements();
		SequenceInputStream sis=new SequenceInputStream(en);
		BufferedOutputStream bos=null;
		try {
			bos=new BufferedOutputStream(new FileOutputStream("sis2.txt"));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		byte[] b=new byte[1024];
		int len=0;
		try {
			while((len=sis.read(b))!=-1){
				bos.write(b,0,len);
				bos.flush();	
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bos!=null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(sis!=null){
				try {
					sis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
		}
		
	}
}

ObjectInputStream和ObjectOutputStream

ObjectOutputStream:序列化流:将对象像流的方式或者网络传输中的数据写数据.对象--->流数据

成员方法:

public final void writeObjecy(Object obj):将obj对象写入当前的序列化中.

ObjectInputStream:反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原对象.

成员方法:

public final Object readObject():从当前反序列化流中读取一个对象.

Serializeable:序列化接口.类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化,如果自定义一个类没有实现这

接口,就不能使用序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口.

注意事项:

比如一个类中有很多成员变量,并不想让一些成员变量被序列化,Java提供了一个关键字:transient:不用被序列化的时候用它修饰

序列化和反序列化考点:

1)将对象--->流数据或者流数据--->对象,该对象所在的类要实现一个标记接口:serializable 多线程有一个关键字:同步机制(synchronized)

2)序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决

3)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;

public class ObjectStreamDemo {
	public static void main(String[] args) {
//		write();
		//创建一个反序列化流对象
		reader();	
	}

	private static void reader() {
		ObjectInputStream ois=null;

			try {
				ois=new ObjectInputStream(new FileInputStream("oos.txt"));
				Object readObject = ois.readObject();
				System.out.println(readObject);
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}finally{
				if(ois!=null){
					try {
						ois.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
	}

	private static void write() {
		//创建一个对象
		Person p=new Person("立华奏",20);
		//创建一个序列化流对象
		ObjectOutputStream oos=null;
		try {
			oos=new ObjectOutputStream(new FileOutputStream("oos.txt"));
			oos.writeObject(p);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(oos!=null){
				try {
					oos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

结果为:

Person [name=立华奏, age=0]

Properties:属性集合类,该类继承自Hashtable<K,V>,该类属于Map集合

Properties 类表示了一个持久的属性集。

Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串(一般情况:它用作配置文件去使用,MySQL或者Oracle中用它做配置文件)

构造方法:public Properties():创建一个空属性列表

属性集合类:Properties有自己的遍历和添加元素的功能

给属性列表中添加元素:

public Object setProperty(String key,String value)

public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型

public String getProperty(String key)用指定的键在此属性列表中搜索属性值

Properties 可保存在流中或从流中加载.

将文件中的数据加载到属性集合中:public void load(Reader reader)

将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)第二个参数:comments:对当前属性列表的描述.

相关代码:

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo {
	public static void main(String[] args) {
//		mystore();
		myload();
	}

	private static void myload() {
		Properties prop=new Properties();
		//创建字符输入流对象
		FileReader fr=null;
		try {
			fr=new FileReader("name.txt");
			//调用方法
			prop.load(fr);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fr!=null){
				try {
					fr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println(prop);
	}

	private static void mystore() {
		//创建属性集合类对象
		Properties prop=new Properties();
		prop.setProperty("立华奏", "20");
		prop.setProperty("小薰", "20");
		//创建字符输出流
		FileWriter fw=null;
		try {
			fw=new FileWriter("name.txt");
			prop.store(fw, "name contents");
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fw!=null){
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

结果为:

{立华奏=20, 小薰=20}