java中的输入输出流2

1.IO流的划分与区别【字节流与字符流】？

IO流用来读写文件的内容

流--数据的流动轨迹。

按照数据的流动方向

输入流---将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】

输出流---将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】

2.按照每一次读写数据的大小

字节流---每一次读写一个字节【8位2进制】的数据量的流【字节流】

由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据【文本，视频，音频，图片】

字符流---每一次读写一个字符【16位2进制】的数据量的流【字符流】

不能读写任何类型的数据，只能读写文本类型的数据。

IO流的综合划分

2.常用的字节输入与字节输出流类

1.字节输出流---顶级类OutputStream

public abstract class OutputStream-----不能new

1.1public class FileOutputStream extends OutputStream

构造方法

FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。

FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。

FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。

FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流

package com.wangxing.fileoutput;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class FileOutputStreamDemo1 {
	public static void main(String args[]) throws Exception{
		//字节输出流--OutPutStream[抽象类]
		//FileOutputStream 构造方法
		//1.FileOutputStream(File file);通过File对象创建一个不可追加的字节输出流
		//File file----File类型的输出路径
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt";
		File file1=new File(path1);
		FileOutputStream out1=new FileOutputStream(file1);
		//FileOutputStream out11=new FileOutputStream(new File("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"));
		//OutputStream out111=new FileOutputStream(file1);
		
		//2.FileOutputStream(String name);通过 String对象创建一个不可追加的字节输出流
		//String name--String类型的输出路径
		String path2="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile2.txt";
		FileOutputStream out2=new FileOutputStream(path2);
		//FileOutputStream out22=new FileOutputStream("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt");
		//OutputStream out222=new FileOutputStream(path2);
		
		//3.FileOutputStream(File file,boolean append);通过File对象创建一个是否追加的字节输出流
		//File file---File类型的输出路径
		//boolean append---是否追加【true追加/false不追加】
		String path3="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile3.txt";
		File file2=new File(path3);
		FileOutputStream out3=new FileOutputStream(file2,true);
		//FileOutputStream out33=new FileOutputStream(new File("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile3.txt"),false);
		//OutputStream out333=new FileOutputStream(file2,false);
		
		//4.FileOutputStream(String name,boolean append);通过String对象创建一个是否追加的字节输出流
		//String name---String类型的输出路径
		//boolean append---是否追加【true追加/false不追加】
		String path4="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile4.txt";
		FileOutputStream out4=new FileOutputStream(path4,true);
		//FileOutputStream out44=new FileOutputStream("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile3.txt",true);
		//OutputStream out444=new FileOutputStream(path4,false);
	}
}

实例方法

void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
void	write(int b) 将指定的字节写入此文件输出流。
void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源。

package com.wangxing.fileoutput;

import java.io.File;
import java.io.FileOutputStream;


public class FileOutputStreamDemo2 {
	public static void main(String args[]) throws Exception{
		//FileOutputStream 实例方法
		//void write(byte[] b);将b.length个字节从指定的字节数组中写入此文件输出流
//		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt";
//		FileOutputStream out1=new FileOutputStream(path1,true);
//		String info1="hello";
//		byte[] bytearray1=info1.getBytes();
//		out1.write(bytearray1);
//		out1.close();
		
		//void write(byte[] b,int off,int len);从指定字节数组中指定位置off开始的len个字节写入此文件输出流
//		String path2="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile2.txt";
//		FileOutputStream out2=new FileOutputStream(path2,true);
//		String info2="helloworld";
//		byte[]bytearray2=info2.getBytes();
//		out2.write(bytearray2,5,5);
//		out2.close();
		
		//void write(int b); 将指定的字节写入此文件输出流
		String path3="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile3.txt";
		FileOutputStream out3=new FileOutputStream(path3,true);
		String info3="helloworld";
		byte[] bytearray3=info3.getBytes();
		for(byte name:bytearray3){
			out3.write(name);
		}
		out3.close();
	}
}

2.字节输入流---顶级类InputStream

public abstract class InputStream---不能new

2.1public class FileInputStream extends InputStream

FileInputStream(File file) 通过File对象创建一个字节输入流

FileInputStream(String name) 通过String对象创建一个字节输入流

package com.wangxing.fileinput;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileInputStreamDemo1 {
	public static void main(String args[])throws Exception{
		//字节输入流----InputStream[抽象类]
		//FileInputStream 构造方法
		//FileInputStream(File file);通过File对象创建一个字节输入流
		//File file---File类型的输入路径
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt";
		File file1=new File(path1);
		FileInputStream in1=new FileInputStream(file1);
		FileInputStream in2=new FileInputStream(new File("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt"));
		InputStream in3=new FileInputStream(file1);
		
		//FileInputStream(String name);通过String对象类创建一个字节输入流
		//String name----String类型的输入路径
		String path2="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile2.txt";
		FileInputStream in4=new FileInputStream(path2);
		FileInputStream in5=new FileInputStream("E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile2.txt");
		InputStream in6=new FileInputStream(path2);
	}
}

实例方法

int

read()

从该输入流读取一个字节的数据。

返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1

int

read(byte[] b)

从该输入流读取最多 b.length个字节的数据为字节数组。

返回值:读取的总字节数，如果到达文件末尾返回-1

void

close() 关闭此文件输入流并释放与流相关联的任何系统资源。

package com.wangxing.fileinput;

import java.io.File;
import java.io.FileInputStream;

public class FileInputStreamDemo2 {
	public static void main(String args[])throws Exception{
		//FileInputStream 实例方法
		//int read(byte b[]);
		//从该输入流读取最多b.length个字节的数据为字节数组
		//返回值：读取的总字节数，如果到达文件末尾返回-1；
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile1.txt";
		File file1=new File(path1);
		FileInputStream in1=new FileInputStream(file1);
		byte bytearray1[]=new byte[(int)(file1.length())];
		in1.read(bytearray1);
		in1.close();
		String str1=new String(bytearray1);
		System.out.println(str1);
		
		//int read();
		//从该输入流读取一个字节的数据
		//返回值：读取的具体字节数据的int型，如果到达文件末尾返回-1
		String path2="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile2.txt";
		File file2=new File(path2);
		FileInputStream in2=new FileInputStream(file2);
		//in2.read();从该输入流读取一个字节的数据
		byte[]bytearray2=new byte[(int)(file2.length())];//用于保存读取来得数据
		int len=0;
		int index=0;
		while((len=in2.read())!=-1){
			bytearray2[index]=(byte)len;
			index++;
		}
		in2.close();
		String str2=new String(bytearray2);
		System.out.println(str2);
		
		//int read(byte[] b,int off,int len);
		//从该输入流读取最多len个字节的数据为字节数组
		String path3="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myfile3.txt";
		File file3=new File(path3);
		FileInputStream in3=new FileInputStream(file3);
		byte bytearray3[]=new byte[(int)(file3.length())];
		in3.read(bytearray3,0,5);
		in3.close();
		String str3=new String(bytearray3);
		System.out.println(str3);
		
	}
}

上面的字节输入输出流只能读写字节数组，不能直接控制基本数据类型的数据的读写

1.2 public class DataOutputStream extends FilterOutputStream implements DataOutput

数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流

构造方法

DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。

实例方法：

void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
void	writeByte(int v) 将 byte作为1字节值写入底层输出流。
void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。
void	writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节。
void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
void	writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
void	writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。
void	flush() 刷新此数据输出流。
void	close() 关闭此输出流并释放与此流相关联的任何系统资源。

package com.wangxing.datainput;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class DataOutputStreamDemo1 {
	public static void main(String args[])throws Exception{
		//DataOutputStream 可以直接写出基本类型数据，无序转换成字节数组
		//将被写出的基本类型的数据转换为2进制形式写出，保存在文件中的数据是乱码
		//DataOutputStream 构造方法
		//DataOutputStream(OutputStream out);创建一个新的数据输出流，以将数据写入指定的底层输出流
		//OutputStream out---底层输出流[FileOutputStream]
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"mydata1.txt";
		File file1=new File(path1);
		//FileOutputStream out1=new FileOutputStream(file1,true);//OutputStream的子类对象
		OutputStream out11=new FileOutputStream(file1,true);//OutputStream的上转型对象
		//OutputStream的子类对象/OutputStream的上转型对象----底层输出流
		DataOutputStream dataout1=new DataOutputStream(out11);//高级输出流
		
		//DataOutputStream  实例方法
		/*
		 * void writeBoolean(boolean v);将boolean写入底层输出流作为1个字节值
		 * void writeByte(int v);将byte作为一个字节写入底层输出流
		 * void writeChar(int v);将char写入底层输出流作为两个字节，高字节的优先
		 * void writeDouble(double v);双参数传递给转换 long使用doubledoubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。 
		 * void	writeFloat(float v); 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节。 
		 * void writeInt(int v);将int写入底层输出流作为四个字节，高位字节
		 * void writeLong(long v);将long写入底层输出流,为八个字节，高字节为首
		 * void writeShort(short v);将short写入底层输出流作为两个字节，高字节优先
		 * void writeUTF(String str);使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。 
		 * void flush();刷新此数据输出流
		 * void close();关闭此输出流并释放与此流相关的任何系统资源
		 */
		dataout1.writeInt(1001);//int 89 4
		dataout1.writeChar('\t');//char \t 2
		dataout1.writeBoolean(true);//boolean true 1
		dataout1.writeChar('\t');//char \t 2
		dataout1.writeDouble(12.5);//double 12.5 8
		dataout1.writeChar('\t');//char \t 2
		dataout1.writeUTF("zhangsan");//String [utf-8] zhangsan 8
		dataout1.flush();
		dataout1.close();
		out11.close();
		
		
	}
}

2.2 public class DataInputStream extends FilterInputStream implements DataInput

构造方法

DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。

实例方法

boolean	readBoolean()
byte	readByte()
char	readChar()
double	readDouble()
float	readFloat()
int		readInt()
long		readLong()
short		readShort()
String		readUTF()
void		close()

package com.wangxing.dataoutput;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class DataInputStreamDemo1 {
	public static void main(String args[])throws Exception{
		//DataInputStream 可以直接读取基本类型的数据，无需转换为byte数组
		//DataInputStream 构造方法
		//DataInputStream(InputStream in);创建一个新的数据输入流，以将从底层输入中读取数据
		//InputStream in---底层输入流[FileInputStream]
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"mydata1.txt";
		File file1=new File(path1);
		//FileInputStream in1=new FileInputStream(file1);//InputStream子类对象
		InputStream in11=new FileInputStream(file1);//InputStream上转型对象
		//InputStream子类对象/InputStream上转型对象-----底层输入流
		DataInputStream datain1=new DataInputStream(in11);//高级输入流
		//DataInputStream  实例方法
		/*
		 * boolean	readBoolean();
		   byte	readByte();
		   char	readChar();
		   double readDouble();
		   float readFloat();
		   int readInt();
		   long	readLong();
		   short readShort();
		   String readUTF();
		   void	close();
		*/
		int intval=datain1.readInt();
		char char1=datain1.readChar();
		boolean booval=datain1.readBoolean();
		char char2=datain1.readChar();
		double douval=datain1.readDouble();
		char char3=datain1.readChar();
		String strval=datain1.readUTF();
		int intval1=datain1.readInt();
		datain1.close();
		in11.close();
		System.out.println(intval+" "+booval+" "+douval+" "+strval+" "+intval1);
		
	}
}

3.什么是序列化？如何实现序列化？

因为我们做操作的java对象可能需要在多台计算机之间传递。

序列化-----将一个java对象转换成2进制流数据过程。

反序列化---2进制流数据转换成一个java对象的过程。

如何实现序列化？

1.为被序列化的java对象的生成类实现一个序列化接口【Serializable】

public interface Serializable

特殊----该接口中一个方法都没有。

类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化。可序列化类的所有子类型都是可序列化的。

2.通过java提供ObjectOutputStream类的writeObject(Object obj)

ObjectOutputStream的构造方法

ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。

实例方法

void	writeObject(Object obj) 将指定的对象写入ObjectOutputStream。

package objectinoutput;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo1 {
	public static void main(String args[])throws Exception{
		//ObjectOutputStream 构造方法
		//ObjectOutputStream(OutputStream out);创建一个写入指定的OutputStream的ObjectOutputStream对象
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myStudent.txt";
		File file1=new File(path1);
		FileOutputStream out1=new FileOutputStream(file1);
		//OutputStream out11=new FileOutputStream(file1);
		ObjectOutputStream objout1=new ObjectOutputStream(out1);
		
		//ObjectOutputStream 实例方法
		//void writeObject(Object obj);将制定的对象写入ObjectOutputStream
		Student student=new Student();
		objout1.writeObject(student);
		objout1.flush();
		objout1.close();
		out1.close();
	}
}

将上面序列化到记事本文件中的java对象，反序列化回来成一个可使用的java对象。此时就需要ObjectInputStream类的Object readObject()方法读取对象。

ObjectInputStream类

构造方法

ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。

实例方法

Object

readObject() 从ObjectInputStream读取一个对象。

package objectinoutput;

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;


public class ObjectInputStreamDemo1 {
	public static void main(String args[])throws Exception{
		//ObjectInputStream 构造方法
		//ObjectInputStream(InputStream in);创建从指定的InputStream读取的ObjectInputStream对象。
		String path1="E:"+File.separator+"WX"+File.separator+"JavaSE"+File.separator+"InOnput"+File.separator+"myStudent.txt";
		File file1=new File(path1);
		FileInputStream in1=new FileInputStream(file1);
		//InputStream in11=new FileInputStream(file1);
		ObjectInputStream objectIn1=new ObjectInputStream(in1);
		
		//ObjectInputStream 实例方法
		//Object readObject(); 从ObjectInputStream读取一个对象
		Object obj=objectIn1.readObject();
		Student student=(Student)obj;
		objectIn1.close();
		in1.close();
		student.testStudent();
		
	}
}

java中的输入输出流2

java中的输入输出流2

猜你喜欢