IO

import java.awt.List;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.io.StringReader;
import java.util.Iterator;
import java.util.RandomAccess;
import java.util.Scanner;
import java.util.zip.InflaterInputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;

/**2017-02-23
 * javaIO流 使用了一种装饰设计模式 
 * 将IO流分成底层节点流和上层处理流
 * --底层节点流用于和底层的物理存储直接管理
 */


/**2017-02-23
 * File类
 * 操作文件和目录都可以使用该类来完成
 * 但是不能访问文件内容本身
 *   
 */

/** 2017-02-23
 *  
 */
public class javaio {
	/**2017-02-23 10:38
	 * 文件过滤 
	 */
	private static void filenamefilter() {
		/*
		File file = new File(".");
		String[] list = file.list((dir,name) -> name.endsWith(".java")||new File(name).isDirectory());
		System.out.println(file.getPath());
		System.out.println(file.getAbsolutePath());

		if (file.isDirectory()) {
			System.out.println(file.getName()+ "  是一个" + "Directory");
		}else {
			System.out.println("No Directory");
		}
		
		for (String string : list) {
			System.out.println(string);
		}
		
		*/
	}
	
	
	
	
	public static void main(String[] args) throws IOException {
//		file1();
		
//		filenamefilter();
		
		/**
		 * stream 流的分类
		 * 输入/输出 流
		 * 
		 * 划分输入输出流是从程序运行所在内存的角度来考虑的
		 * 
		 * 输入流		基类   InputStream  	Reader 
		 * 输出流		基类	OutStream		Writer 
		 * 
		 * 字节流		操作的数据单元是8位字节	InputStream	OutputStream
		 * 字符流		16位					Reader		Writer
		 * 
		 * 节点流		从/向一个特定的IO设备 读写数据	也被称为低级流		Low Level Stream
		 * 处理流		对于一个已存在的流进行连接或封装，通过封装后的流来实现数据的读写功能
		 * 
		 * 
		 * 处理流来包装节点流是一种典型的装饰设计模式
		 * 通过使用处理流棒状不同的节点流
		 * 可以消除不同节点流的差异
		 * 也可以提供更加方便的方法来完成输入输出功能
		 * 处理流也被称为包装流
		 * 
		 */
		
		/**2017-02-23 
		 * 流的概念模型
		 * 把所有设备里的有序数据抽象成流模型
		 * 40多个类都是从
		 * --InputStream/Reader  	输入流的基类，字节/字符输入流
		 * --OutputStream/Writer	输出流的基类，字节/字符输出流
		 */
		
		/**
		 * inputStream 和Reader  
		 * 所有输入流的抽象基类，本身并不能创建实例类执行输入
		 * 但他们将成为所有输入流的模板
		 */
		
//		f1();
//		f2();
//		f3();
		
//		f4();
	  
//		f5();
		
	/**
	 * 
	 * 输入、输出流体系
	 * 分类			字节输入流					字节输出流				字符输入流				字符输出流
	 * 抽象基类		InputStream				OutStream			Reader				Writer				
	 * 访问文件		FileInputStream			FileOutStream		FileReader			FileReader			节点流
	 * 访问数组		ByteArrayInputStream	ByteArrayOutStream	CharArrayReader		CharArrayWriter		节点流
	 * 访问管道		PipedInputStream		PipedOutputStream	PipedReader			PipedWriter			节点流
	 * 访问字符串													StringReader		StringWriter		节点流
	 * 缓冲流			BufferedInputStream		BufferedOutStream	BufferReader		BufferWriter
	 * 转换流														InputStreamReader	OutStreamWriter
	 * 对象流			ObjectInputStream		ObjectOutStream		
	 * 抽象基类		FilterInputStream		FilterOutStream		FilterReader		FilterWriter
	 * 打印流									PrintStream								PrintWriter
	 * 推回输入流		PushbackInputStream							PushbackReader		
	 * 特殊流			DataInputStream			DataOutputStream
	 * 
	 * 字节流的功能比字符流的功能强大，计算机里都是二进制
	 * 字节流可以处理所有的二进制
	 * 
	 * 输入输出的内容都是文本内容，则使用字符流
	 * 
	 * 以数组为物理节点的节点流，
	 * 字节流以节点数组为节点，
	 * 字符流以字符数组为节点
	 * 
	 * 以数组为物理节点的节点流除了在创建节点流对象时需要传入一个字节数组或字符数组
	 * 
	 * 字符流还可以使用字符创作为物理节点，用于实现从字符串读取内容
	 */
		/*
		String string = "生命阶段不同，迎来送往，境遇起伏，阶层跌宕，财富多寡，有太多随机因素隐藏在人们脚下的路途之中。";
		char[] cs = new char[9];
		
		StringReader stringReader = new StringReader(string);
		int len = 0 ;
		
		while ((len = stringReader.read(cs))> 0) {
			System.out.println( new String(cs,0,len));
		}
		
		*/
		/**
		 * 字节流转换成字符流
		 * 字节流比字符流的使用范围更广
		 * 字符流比字节流使用方便
		 */
		
		
		/**
		 * 推回输入流
		 * PushbackInputStream
		 * PushbackOutputStream
		 * 
		 * unread	将内容推回到推回缓冲区里，允许重复读取刚刚的内容
		 * 系统会将制定的内容推回到该缓冲区里，
		 * 而推回输入流每次调用read方法时总是先从推回缓冲区读取
		 * 只有完全读取了推回缓冲区的内容后
		 * 但没有装满read所需的数组时才会从原输入流中读取
		 */
		
		/**
		 * 重定向标准输入输出
		 * setErr  	错误输出流 
		 * setIn	标准输入流
		 * setOut	标准输出流
		 * 
		 */
		System.out.println();
		FileInputStream fileInputStream = new FileInputStream(new File("C:\\a.txt"));
		System.setIn(fileInputStream);  //重定向为文件的内容，将文件的内容输出出来
		Scanner scanner = new Scanner(System.in);
		scanner.useDelimiter("\n");   // 下面一行吧回车 作为分隔符
		while (scanner.hasNext()) {
			System.out.println(scanner.next());
		}
		fileInputStream.close();
		System.exit(0);
		/**
		 * java虚拟机读写其他进程的数据
		 * Runtime exec 可以运行平台上的其他程序
		 * 该方法产生一个process对象
		 * process对象带便由该java程序启动的子进程
		 * 
		 * getErrorStream  	获取子进程的错误流
		 * getInputStream 	获取子进程的输入流
		 * getOutputStream	获取子进程的输出流
		 * 
		 * 
		 * 站在java程序的角度来看
		 * 
		 * 子进程读取java程序的数据，就是把java程序冲的数据输出到子进程中，应使用输出流
		 */
		/*
		Process process =  Runtime.getRuntime().exec("cmd.exe");
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
		
		String buff = null;
		while ((buff = bufferedReader.readLine())!=null) {
//			System.out.println(buff);
		}
		
		System.out.println("/*-");
		*/
		/**
		 * RandomAccessFile
		 * 文件内容访问类
		 * 支持随机访问的方式，程序可以直接跳转到文件的任意地方来读取数据
		 * 
		 * 可以自由定位文件记录指针
		 * 
		 * 只能读写文件，不能读写其他IO节点
		 * 
		 * getFilePointer  返回文件记录指针的当前文职
		 * seek 将文件记录指针定位到pos位置
		 * 
		 * RandomAccess 
		 * 应该是任意访问，而不是随机访问
		 * RAM是可以自由访问任意存储点的存储器
		 * RandomAccessFile 的含义是可以自由访问文件的任意地方
		 * 不是随机访问，而是任务一访问
		 * 
		 * 
		 * RandAccessFile 有两个构造器
		 * 
		 */
		/*
		
		File temp = File.createTempFile("temp", null);
		temp.deleteOnExit();// 退出时删除该文件
		RandomAccessFile randomAccess = new RandomAccessFile(temp,"rw");
		
		FileOutputStream fileOutputStream = new FileOutputStream(temp);
		FileInputStream fileInputStream2 = new FileInputStream(temp);
		randomAccess.seek(300);   //转到300行
		
		byte[] bs = new  byte[11];
		int len2 = 0 ; 
		while ((len2 = randomAccess.read(bs))>0) {
			fileOutputStream.write(bs, 0, len2);
		}
		*/
		
		/**
		 * 多线程断点下载的网络下载工具就可以通过RandomAccessFile类来实现
		 * 下载时会建立两个文件
		 * 一个是与被下载文件大小相同的空文件，一个是记录文件指针的位置文件
		 */
		
//		System.out.println("/*-");
		
		
		/**
		 * 对象序列化的含义和意义  
		 * 对象序列化的目标是将对象保存到磁盘中
		 * 或允许在网络中直接传输对象
		 * 
		 * 对象序列化机制允许把内存中的java对象转换成平台无关的二进制流
		 * 从而允许把这种二进制流持久地保存在磁盘上
		 * 通过网络将这种二进制流传输到另一个网络节点
		 * 
		 * 其他程序获得这种二进制流
		 * 都可以将这种二进制流恢复成原来的java对象
		 * 
		 * 序列化机制允许将实现序列化的java对象转换成字节序列
		 * 这些字节序列可以保存在磁盘上，或在网络中传输，以备以后重新恢复
		 * 
		 * 序列化可以使得对象可以脱离程序的运行而独立存在
		 * 
		 * 对象的序列化Serialize 指将一个java对象写入IO流中  
		 * 与此对应的是反序列化Deserialize 从IO流中恢复java对象
		 * 
		 * 让某个对象支持序列化机制，必须让它的类是可序列化的 serializable
		 * 让某个类是可序列化的需要实现
		 * serializable
		 * Externalizable
		 * 
		 * 
		 * 
		 * 实现Serializable 该接口是一个标记接口，实现该接口无须实现任何方法，只是表名该类的实例是可序列化的
		 * 
		 * 所有可能在网络上传输的对象的类都应该是可序列化的，否则程序将会出现异常
		 * RMI  Remote Method Invoke  远程方法调用
		 * 过程中的参数和返回值，所有需要保存到磁盘的对象的类都必须是可序列化
		 * web 中的Httpsession  servletContext 属性的java对象
		 * 
		 * 
		 */
		
		/**
		 * 使用对象流实现序列化
		 * 
		 * 使用serializable  来实现序列化  
		 * 无须实现任何方法
		 * 一旦实现serializable接口，该类就是可序列化
		 * 
		 * 序列化
		 * --创建一个ObjectOutStream  
		 * --调用ObjectOutStream 的writeObject 输出可序列化对象
		 */
		
		
		//public class Student implements Serializable {
		
		//创建一个流对象
			//序列化
		/*
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("a.txt"));
			Student s1 = new Student("laji");
			objectOutputStream.writeObject(s1);
			objectOutputStream.flush();
			objectOutputStream.close();
			*/
			
			/**
			 * 反序列化
			 * --创建一个ObjectInputStream，建立在其他节点流的基础上 
			 * --调用objectinputstream的read方法
			 */
		
		/*
			try (
					ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("a.txt"))
					)
			{
				Student s2 = (Student) objectInputStream.readObject();
				System.out.println(s2.getName());
				
			} catch (ClassNotFoundException e) {
				
				e.printStackTrace();
			}
			*/
			/**
			 * 反序列化仅仅是读取Java对象的数据而不是java类
			 * 采用反序列化恢复java对象是
			 * 必须提供该java对象所属类的class文件
			 * 没有class文件会   引发  ClassNotFoundException
			 * 反序列化读取java对象是
			 * 并没有调用构造器
			 * 
			 * 反序列化机制无须通过构造器来初始化对象
			 * 
			 * 当有多个对象时，
			 * 反序列化机制恢复对象时必须按实际写入的顺序读取
			 * 
			 * 当一个可序列化类有多个父类时
			 * 这些父类要么有无参构造器   要么是可序列化的
			 * 否则反序列化抛出InvalidClassException
			 * 
			 * 如果父类时不可序列化的，只有无参构造器
			 * 则该父类中定义的成员变量值不会序列化到二进制流中
			 * 
			 */
			
			/**
			 * 对象引用的序列化
			 * 
			 * 子类可序列化，父类才可以序列化
			 * 子类不可序列化，则父类都是不可序列化的
			 * 
			 */
			/**
			 * 序列化算法
			 * 所有保存到磁盘中的对象都有一个序列化编号
			 * 当程序试图序列化一个对象时，程序将先检查该对象是否已经被序列化过，只有该对象在本次程序运行时没被序列化过，系统才会将该对象转换成字节序列并输出
			 * 如果某个对象已经序列化过，程序将只是直接输出一个序列化编号，而不是再次重新序列化该对象
			 * 
			 * 
			 * 序列化可变对象时，对象发生变化时，再次调用writeObject方法时   输出的是变化前的对象
			 * 
			 */
			
			/**
			 * 自定义序列化
			 * 
			 * 当对某个对象进行序列化时，系统会自动把该对象的所有实例变量一次进行序列化
			 * 如果某个实例变量引用到另一个对象，则被引用的对象也会被序列化
			 * 如果被引用的对象的实例变量也引用了其他对象，则被引用的对象也会被序列化
			 * 这种称为递归序列化
			 * 
			 * transient  修饰 实例变量  
			 * 在序列化时无须理会该实例变量
			 * 
			 */
			
			
			
			/**
			 * 另一种自定义序列化机制 
			 * 
			 *  这种序列化方式完全由程序员决定存储和恢复对象数据
			 *  该类必须实现Externalizable接口
			 *  --readExternal	需要序列化的类实现readExternal方法来实现反序列化。
			 *  	调用的是DataInput，是ObjectInput的父接口的方法来恢复基本类型的实例变量值
			 *  	调用ObjectInput的readObject方法来恢复引用类型的实例变量值
			 *  --writeExternal		需要序列化的类实现writerExternal 方法来保存对象的状态
			 *  	该方法调用DataOutput，它是ObjectOutput的父接口的方法，保存基本类型的实例变量值
			 *  	调用ObjectOutput的writeObject方法保存引用类型的实例变量值
			 *  
			 *  采用实现Externalizable接口方式的序列化与前面介绍的自定义序列化非常相似
			 *  只是Externalizable接口强制自定义序列化
			 * 
			 */
			
		
	}




	/** 2017-02-23
	 *  
	 */
	private static void f5() throws FileNotFoundException, IOException {
		/**
		 * 处理流的用法
		 * 处理流可以隐藏底层设备上节点流的差异
		 * 使用处理流来包装节点流
		 * 
		 * 只要流的构造器参数不是一个物理节点，而是已经存在的流，那么这种流一定是处理流
		 * 所有的节点流都是直接以物理IO节点作为构造参数的
		 * 使用处理流包装了底层节点流以后，关闭输入、输出流资源时，只要关闭最上层的处理流即可
		 * 关闭最上层的处理流时，系统会自动关闭被该处理流包装的节点流。
		 */
		/*
		FileOutputStream  fileOutputStream = new FileOutputStream("C:\\a.txt");
		PrintStream printStream = new PrintStream(fileOutputStream);
		printStream.println("print");
		printStream.flush();
		printStream.close();
		fileOutputStream.close();
		System.out.println(1);
		*/
	}

		


	/** 2017-02-23
	 *  
	 */
	private static void f4() throws IOException {
//		FileWriter fileWriter  = new FileWriter(new File("C:\\a.txt"));
		
//		fileWriter.write("锦瑟");
		/*
		fileWriter.write("此情可待成追忆，只是当时已惘然");
		fileWriter.append("此情可待成追忆，只是当时已惘然");
		fileWriter.flush();
		System.out.println("ok");
		*/
	}




	/** 2017-02-23
	 *   将内容输出到一个文件 
	 */
	private static void f3() throws FileNotFoundException, IOException {
		/*
		FileInputStream fileInputStream = new FileInputStream( "C:\\Users\\Administrator\\workspace\\java17\\src\\javaio.java");
		
		FileOutputStream fileOutputStream = new FileOutputStream("C:\\a.txt");
			byte[] bs = new byte[1024];
			int len = 0;
			while ((len =  fileInputStream.read(bs)) > 0) {
//				System.out.println(new String(bs,0,len));
				fileOutputStream.write(bs,0,len);
			}
			
//			fileOutputStream.flush(); 
			System.out.println("ok");
			*/
	}

	 /** 2017-02-23
	 *  使用字符数组读取文件
	 * @throws IOException 
	 */
	static void f2() throws IOException {
		/*
		FileReader fileReader = new FileReader( "C:\\Users\\Administrator\\workspace\\java17\\src\\javaio.java");
		char [] cs = new char [32];
		int len = 0;
		while((len = fileReader.read(cs)) > 0) {
			System.out.print(new String(cs,0,len));
		}
		*/

	}


	/** 2017-02-23
	 *   使用字节数组读取文件内容
	 */
	private static void f1() throws FileNotFoundException, IOException {
		/*
		FileInputStream fileInputStream = new FileInputStream( new File("C:\\Users\\Administrator\\workspace\\java17\\src\\javaio.java"));
		
		byte[]  bs = new byte[1024];
		int len = 0 ;
		while((len = fileInputStream.read(bs))>0) {
			System.out.println(new String(bs,0,len));
		}
		fileInputStream.close(); //关闭
		*/
	}

	/** 2017-02-23
	 *  
	 */
	private static void file1() {
		/*
		File file = new File("C:");
		
		file.getName();
		file.getPath();
		file.getAbsolutePath() ; //觉对路径
		file.getParent(); // 父目录
		file.renameTo(file); // 重命名
		
		file.exists(); // 是否存在
		file.canWrite();
		file.canRead();
		file.isFile();
		file.isDirectory();
		file.isAbsolute();
		
		
		file.length();
		file.lastModified();
		
		
//		file.createNewFile();
//		file.delete();
//		file.createTempFile(prefix, suffix)   
//		file.deleteOnExit();
		
//		file.mkdir(); 创建目录
		
//		file.list()
		
		  String[] list = file.list();
		
		  for (String string : list) {
			System.out.println(string);
		  }
		  
//		file.listFiles();
		File[] listRoots = file.listRoots();
		
		for (File file2 : listRoots) {
			System.out.println(file2);
		}
		
		*/
	}
	
}

class Persion implements Externalizable{  //实现Externalizable接口 需要重写 writeExteranl  readExteranl 方法
	
	private String name ;
	private int age;
	public Persion(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(new StringBuffer(name).reverse());
	}
	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		this.name = ((StringBuffer)in.readObject()).reverse().toString();
		this.age = in.readInt();
	}
	/**
	 * 程序需要序列化实现Externalizable 接口的对象，一样调用ObjectOutputStream的writeObject方法输出该对象即可
	 * 反序列化该对象，调用objectinputstream 的readObject方法
	 * 
	 * 实现Serializable						实现Externalizable
	 * 系统自动存储必要信息						程序员决定存储那些信息
	 * Java内建支持，易实现，只需要实现该接口即可		仅仅提供两个空方法，实现该接口必须为两个空方法提供实现
	 * 性能略差								性能略好
	 */
		/**
		 * 对象的类名、实例变量（包括基本类型、数组、对其他对象的引用）都会被序列化
		 * 方法、类变量（static修饰的成员变量）、transient实例变量也成为瞬态实例变量都不会序列化
		 * 
		 * 
		 * 实现Serializable 接口的类如果需要让某个实例变量不被序列化，则可在该实例变量前加transient 修饰符
		 * 
		 * 保证序列化对象的实例变量类型也是可序列化的，否则需要使用transient关键字来修饰该实例变，要不然，该类是不可序列化的
		 * 
		 * 反序列化对象时必须有序列化对象的class文件
		 * 
		 * 当通过文件、网络来读取序列化后的对象时，必须按实际写入的顺序读取
		 * 
		 * 
		 * serialver.exe工具 来获得该类的 serialVersionUID类变得值
		 * 
		 */
			/**
			 * 如果类的修改确实会导致该类反序列化失败，则应该为该类的serialVersionUID类变量重新分配值
			 * 
			 * 如果修改类时仅仅修改了方法，则反序列化不收任何影响，类定义无须修改serialVersionUID类变量的值。
			 * 
			 * 如果修改类时仅仅修改了静态变量或瞬间变量，则反序列化不收任何影响，类定义无须修改serialversionuid类变量的值
			 * 
			 * 如果修改类时修改了非瞬态的实例变量，则可能导致序列化版本不兼容
			 * 
			 * 如果对象流中的对象和新类中包含同名的实例变量，而实例变量类型不同，则反序列化失败，类定义应该更新serialversionuid类变量的值
			 * 
			 * 
			 * 
			 * 
			 */
}