IO—stream

java.io包里定义了多个流类型来实现输入输出功能

按数据流的方向不同可以分为输入流和输出流

按数据单位的不用可以分为字节流和字符流（2个字节）

按功能不同分为节点流（直接接在文件）和处理流（管道相互套着）

所有的流类型都继承了下面四种抽象流类型

字节流：InputStream, OutputStream

字符流：Reader, Writer

一、节点流类型

File： FileReader，FileWriter; FIleIuputStream, FileOutputStream

Memory Array: CharArrayReader, CharArrayWriter; ByteArrayInputStream, ByteArrayOutputStream

Memory String: StringReader, StringWriter

Pipe: PipedReader, PipedWriter; PipedInputStream,  PipedOutputStream

1.FileInputStream-读取txt内的文件

package ioTest;
import java.io.*;;
public class TestFileCopy {
	public static void main(String[] args){
		int b = 0;
		FileInputStream in = null;
		try{
		in = new FileInputStream("F://11.txt");
		}catch( FileNotFoundException e ){
			System.out.println("未找到指定文件");
			System.exit(-1);
		}
		
		try{
			long num = 0;
			while( (b = in.read()) != -1 ){//注意字节流是一个个字节的输出的
				System.out.print((char)b);//注意强制转化为char型
				num++;//计数，一个个的取出
			}
			in.close();//注意用完的流要关闭
			System.out.println();
			System.out.println("共读取了"+num+"个字节");			
		}catch(IOException e1){
			System.out.println("文件读取错误");
			System.exit(-1);
		}
}
}

2.FileOutputStream—复制文件

package ioTest;
import java.io.*;;
public class TestFileCopy {
	public static void main(String[] args){
		int b = 0;
		FileInputStream in = null;
		FileOutputStream out =null;
		
		try{
		in = new FileInputStream("F://11.txt");
		out = new FileOutputStream("F://HW.txt");
		while( (b=in.read()) != -1 ){
			out.write(b);//挨个复制到新建的TXT中
		}
		in.close();
		out.close();
		}catch( FileNotFoundException e ){
			System.out.println("未找到指定文件");
			System.exit(-1);
		}catch(IOException e1){
			System.out.println("文件读取错误");
			System.exit(-1);		
}
		System.out.print("已经复制成功");
	}
}

3.FileWriter && FileReader

用法跟上面相同，只是以字符的形式输入输出。即两个字节，可以显示中文

二、处理流

包到别的流上的流

1.缓冲流—Buffered

缓冲流要套接在相应的节点流上，提供缓冲读写数据的功能

构造方法：

BufferedReader()

BufferedWriter()

BufferedInputStream()

BufferedoutputStream()

常用方法

readline: 读取一行上的字符串

缓冲流读写数据举例——随机数的写入写出

package ioTest;
import java.io.*;
public class BUfferStream {
	public static void main(String[] args){
		try{
			BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\11.txt"));//buffered构造方法必须指向一个writer类
			BufferedReader br = new BufferedReader(new FileReader("F:\\11.txt"));
			String s = null;
			for(int i=0; i<100; i++){
				s = String.valueOf(Math.random());//生成随机数，并且转化为String类型
				bw.write(s);
				bw.newLine();//每写入一个随机数添加一个回车
			}
			bw.flush();
			while((s = br.readLine()) != null){
				System.out.println(s);//按行读出文件内的内容
			}
			br.close();
			bw.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

三、转换流

把字节转换为字符输入输出

InputStreamReader必须和InputStream套接

OutputStreamWriter必须和OutpurStream套接

1.用转化流打印文件编码

package ioTest;
import java.io.*;
public class TestTransform {
	public static void main(String[] args){
		try{
		OutputStreamWriter osw = new OutputStreamWriter( new FileOutputStream("F:\\12.txt") );//传入的参数必须是OutputStream类的
		osw.write("fdsajhfsjfhkjsdhfkdjsahd");
		System.out.println(osw.getEncoding());//获取osw的编码
		osw.close();
		osw = new OutputStreamWriter( 
				new FileOutputStream("F:\\12.txt", true),//true参数的意思是在源文件的后面继续写入，否则会覆盖原来文件
					"ISO8859_1" );//"IS08859_1"参数是指定编码来写入
		osw.write("121212");
		System.out.println(osw.getEncoding());
		osw.close();
		}catch(IOException e){
			e.getStackTrace();
		}
	}
}

2.键盘输入变大写

System.in用法是从键盘读入，属于InputStream类

package ioTest;
import java.io.*;
public class TestTransform {
	public static void main(String[] args){//System.in是读取键盘输入的
		InputStreamReader isr = new InputStreamReader(System.in);//System.in本身是一个InputStream型的
		BufferedReader br = new BufferedReader(isr);//再包一层Buffered是为了调用readLine
		String s = null;
		try{
			s = br.readLine();
			while(s != null ){
				if(s.equalsIgnoreCase("exit"))	break;//exit忽略大小写退出
					System.out.println(s.toUpperCase());//变大写
				s = br.readLine();
			}
			br.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

四、数据流

DataInputStream和DataOutputStream

分别继承自InputStream和OutputStream

是处理流，需要套接在InputStream和OutputStream的节点流上

数据流提供了写入基础数据类型的方法（double， char）等

特别注意，数据的输出时，注意先入先出的原则

ByteArray 和 Data 的使用

package ioTest;
import java.io.*;
public class TestDateStream {
	public static void main(String[] args){
		ByteArrayOutputStream baos = new ByteArrayOutputStream();//字节数组
		DataOutputStream dos = new DataOutputStream(baos);
		try{
			dos.writeDouble(Math.random());
			dos.writeBoolean(true);
			ByteArrayInputStream bais = new ByteArrayInputStream( baos.toByteArray() );//字节数组输入流构造方法参数必须时个字节数组
			System.out.println( bais.available());//显示字节数组中有多少字节可以读出
			DataInputStream dis = new DataInputStream(bais);//套上一层数据的输入流
			System.out.println(dis.readDouble());//特别注意，输出的时候先写入的先读，按照顺序
			System.out.println(dis.readBoolean());//队列，先入先出的原则
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

五、Print流

PrintWriter和PrintStream都是输出流，字符和字节输出

不会抛异常，并且会自动flush

1.Print向指定文件输出内容

用System.setOut指定输出路径

package ioTest;
import java.io.*;
public class Test1 {
	public static void main(String[] args){
		PrintStream ps = null;
		try{
			FileOutputStream fos = new FileOutputStream( "F:\\JavaRubbish\\text.txt" );
			ps = new PrintStream(fos);
		}catch(IOException e){
			e.printStackTrace();
		}
		if(ps != null){
			System.setOut(ps);//把默认输出到DOS改为输入到PS指向的文件
		}
		int num = 0;
		for(char c = 0; c <= 60000; c++){
			System.out.print(c+ " ");
			if(num >=100){
				System.out.println();
				num = 0;
			}
		}
	}
}

2.在DOS下输出文件内容

package ioTest;
import java.io.*;
public class Test2 {
	public static void main(String[] args){
		String filename = args[0];
		if(filename != null)	{ list(filename, System.out); }
	}
	
	public static void list(String f, PrintStream fs){//System.out属于PrintStream类
		try{
			BufferedReader br = new BufferedReader( new FileReader(f) );
			String s = null;
			while( (s = br.readLine()) != null ){
				fs.println(s);//在DOS下打印指定文件内容
			}
			br.close();
		}catch(IOException e){
			fs.println("ERROR");
		}
	}
}

3.输出日志

package ioTest;
import java.io.*;
import java.util.*;
public class Test3 {
	public static void main(String[] args){
		String s = null;
		BufferedReader br = new BufferedReader(
							new InputStreamReader(System.in));//System.in属于InputStream类
		try{
			FileWriter fw = new FileWriter("F:\\JavaRubbish", true);//添加true确保在后面连续输入
			PrintWriter log = new PrintWriter(fw);
			while( (s=br.readLine()) != null){
				if(s.equalsIgnoreCase("exit"))	{break;}//输入exit退出程序
				System.out.println(s.toUpperCase());//现在黑框中输出
				log.println("------");
				log.println(s.toUpperCase());
				log.flush();
			}
			log.println("===" + new Date() + "===");//调用util里面的Date管理时间的方法
			log.flush();
			log.close();
}catch(IOException e){
			e.printStackTrace();
		}
	}
}

六、Object流

直接将Objective（某一个类）写入或者读出

关键字： transien——透明化，被修饰的变量在序列化的时候不考虑

接口： serialable——一个标记性的接口，没有任何参数，只是告诉编译器这个类是可以序列化的

externaliable——自己定义如何实现序列化

1.输入输出类

package ioTest;
import java.io.*;
public class ObjectText {
	public static void main(String[] args){
		try{
			T t = new T();
			t.k = 8;
		FileOutputStream fos = new FileOutputStream("F:\\JavaRubbish\\testObject.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);//写入t这个类
		oos.writeObject(t);
		oos.flush();
		oos.close();
		
		FileInputStream fis = new FileInputStream("F:\\JavaRubbish\\testObject.txt");
		ObjectInputStream ois = new ObjectInputStream(fis);//输出t这个类
		T tReaded = (T) ois.readObject();//强制转化类型。存贮在tReaded内
		System.out.println(tReaded.i +" "+ tReaded.j+" " + tReaded.d + " " + tReaded.k);//注意k的输出时0，因为被透明化了
		}catch (IOException e){
			e.printStackTrace();
		}catch(ClassNotFoundException e1){
			System.out.println("没有找到类");
		}
	}
}

class T implements Serializable //必须实现这个接口才能序列化
{
	int i = 10;
	int j = 9;
	double d = 2.3;
	transient int k = 15;//k是透明化的，在序列化是不可见
}