java学习笔记016 泛型、流

###### 1.泛型 Generic since 1.5

标示元素类型的参数,泛型不能是基本数据类型
泛型不同的引用不能相互赋值
静态方法不能使用泛型，因为实例化类的时候要指定泛型，但是静态方法的加载在实例化之前
	1)集合中使用泛型
		eg:
		Iterator<String> iterator = set.iterator();
		ArrayList<String> list = new ArrayList<String>();
		ArrayList<String> list = new ArrayList<>();	//简化写法
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		Comparable<T>，Comparator<T>
	
	2)自定义范型结构
		泛型类、泛型接口
			//定义类的时候带了泛型，使用的时候最好指定泛型类型，不指定默认Object类型，但有所不同
			public class Hello<T>{
				T t;	//指定类的内部结构
			}
			public class HelloWorld extends Hello<Integer>{
				//创建子类HelloWorld的对象时不必再指定泛型了
			}
			public class HelloWorld<T> extends Hello<Integer>{
				//
			}
		泛型方法
			eg:
			<T> T[] toArray(T[] t);
			<T> List<T> method(T[] t){}
			泛型方法在调用时，指明泛型参数的类型
			泛型方法可以是静态的，这里的泛型参数是在调用方法时确定的，而不是类的实例化的时候调用
			static <T> List<T> method(T[] t){}
	
	3)泛型在继承方面的体现
		A extends B
		1	A 与 B	|	List<A> 与 List<B>
			//多态在数组方面的体现
			Object[] objs = null;
			String[] strs = null;
			objs = strs;
			//以下两个List不具有子父类关系
			List<Object> objs = null;
			List<String> strs = null;
			objs = strs;	//编译不通过
			
		2	A<C> 与 B<C> 具有子父类关系
			List<String> list1 = null;
			ArrayList<String> list2 = null;
			list1 = list2;
		
		3通配符 ?
			List<Object> objs = null;
			List<String> strs = null;
			List<?> list = null;
			list = objs;
			list = strs;
			注意：不能向List<?>中添加数据,除了null
			
		4)有限制的通配符
			通配符指定上限
				上限extends		限定此类或继承了此类的类或实现了此接口的类	
				List<? extends A>可以接收List<A>和List<A的子类或实现类>
				A a = list.get(index);
				不能添加数据
			通配符指定下限
				下限super		限定是此类或此类的父类
				List<? super A>可以接收List<A>和List<A的父类>
				Object obj = list.get(index);
				可以添加A和A的父类

###### 2.File类

java.io.File
	File类的一个对象，代表一个文件或一个文件目录(文件夹)
	1)常用构造器
		File(String pathname)
			相对路径：
				File file = new File("hello.txt");	//idea中用junit相对于当前module，用main()相对于当前project
			绝对路径：
				File file = new File("E://java//hello.txt");	//转义字符'//',表示/
				路径分隔符
					windows和dos：用'/'
					UNIX和URL:用'/'	'/'不用转义字符
					File类提供public static final String separator,根据操作系统动态提供路径分隔符
		
		File(String parent, String child)
			parent	路径
			child	要创建的文件或文件目录
		File(File parentFile, String child)
			在文件目录parent路径下创建child
			
	2)常用方法
		获取
			String	getAbsolutePath()	//绝对路径
			String	getPath()	//相对路径
			String	getName()
			String	getParent()
			long	length()
			long	lastModified()
			以下仅适用于文件目录
			String[] list	//获取指定目录下所有文件或文件目录的名称
			File[]	listFiles()	//获取指定目录下所有文件或文件目录的File类对象
		
			boolean	renameTo(File dest)	//把文件重命名为指定文件路径，要使返回true，this文件在硬盘中存在，dest在硬盘中不存在
		
		判断
			boolean	isDirectory()
			boolean	isFile()
			boolean	exists()
			boolean	canRead()
			boolean	canWrite()
			boolean	isHidden()
		
		创建与删除
			boolean	createNewFile()	//
			boolean	mkdir()	//若要创建目录的上层目录不存在，此方法返回false
			boolean	mkdirs()	//若要创建目录的上层目录不存在，此方法一并创建
			boolean	delete()	//要删除一个文件目录，该文件目录里面不得含有文件目录或文件
		
		文件的遍历(递归)
			//递归删除文件
			public void deleteFiles(File file){
				if(file.isDirectory){
					File files = file.listFiles();
					for(File f : files){
					if(f.isDirectory){
						deleteFiles(f);
					}else{
						f.delete();
					}
				}
				file.delete();
			}

###### 3.IO流

1)分类
	站在程序（内存）的角度定义输入、输出
	数据的单位：字节流（8位）、字符流（16位）
	流的角色：节点流、处理流

四个抽象基类

2）流的结构
抽象基类		节点流（或文件流）		缓冲流（处理流的一种）
InputStream	FileInputStream		BufferedInputStream
OutputStream	FileOutputStream	BufferedOutputStream
Reader		FileReader		BufferedReader
Writer		FileWriter		BufferedWriter

3)FileReader/FilwWriter
	eg:
		File file = new File("path");			//File类实例化
		FileReader reader = new FileReader(file);	//流实例化
		int data;
		while((data = reader.read()) != -1){		//读取操作
			System.out.println((char)data);
		}
		reader.close();					//关闭资源

	read()重载方法
		read(char[])	//返回每次读入数组中的元素的个数,读不到返回-1
		char[] a = new char[5];
		int len;
		while((len = reader.read(a)) != -1){		//读取操作
			for(int i=0; i < len; i++){
				System.out.print(a[i]);
			}
			//另一种方法，利用new String(char[], offset, count)
		}
	
	write()
		new FileWriter(File file, boolean append)	//append  true在原文件后面进行追加 false(默认)不进行追加（覆盖原文件内容）
		write(String)
		write(char[], offset, count)
	
	注意
		字符流处理文本文件，字符流不能处理图片格式文件
		字节流处理非文本文件

4)FileInputStream/FileOutputStream
	fileInputStream.read(byte[])	//返回读取到的字节数组元素个数
	
5)缓冲流
	处理流的一种，内部提供缓冲区，提升读写速度，处理流作用在节点流上
	eg:
		File file = new File(path);			//造文件对象
		FileInputStream fis = new FileInputStream(file);	//造节点流
		BufferedInputStream bis = new BufferedInputStream(fis);		//造缓冲流
		... bis.read(); ...
		bis.close();	//要求先关闭外层的流，关闭外层流的同时，内层流也会自动进行关闭
	
	flush()	//刷新缓冲区
	
6)转换流
	处理流的一种,提供字节流与字符流的转换，属于字符流体系
	InputStreamReader/OutputStreamWriter
	InputStreamReader	字节流转字符流
		InputStreamReader(FileInputStream fis, String charset)	//"utf-8","gbk",不写则为系统默认编码格式
	OutputStreamWriter	字符流转字节流

7)字符集
	ASCII		美国标准信息交换码		用一个字节的7位
	ISO8859-1	拉丁码表			用一个字节的8位
	GB2312					最多两个字节编码一个字符
	GBK					最多两个字节编码一个字符
	ANSI					通常指平台的默认编码
	Unicode		国际标准码		定义了字符的集合和唯一编号，每个字符都用两个字节，Unicode编码是对UTF-8,UTF-16等具体编码方案的统称
	UTF-8					1-4个字节编码一个字符

8)其他流
	1标准输入/输出流(字节流)
		InputStream			PrintStream
		标准输入流System.in		标准输出流System.out
		默认从键盘输入			默认从控制台输出
			System.setInputStrea(InputStream is)
			System.setOut(PrintStream ps)	//PrintStream是OutputStream的子类

		用System.in实现输入
			System.in --> 转换流InputStreamReader --> BufferedReader的readLine()
			eg:
			InputStreamReader isr = new InputStreamReader(System.in);
			BufferedReader reader = new BufferedReader(isr);
			String line = reader.readLine();
	
	2打印流PrintStream/PrintWriter
		
	3数据流DataInputStream/DataOutputStream
		可以读写基本数据类型和字符串
		DataInputStream(FileInputStream)
		DataOutputStream(FileOutputStream)
		读取的顺序要和写入的顺序一致
		eg:
			dos.writeUTF("STRING");
			dos.writeInt(12);
			dos.writeBoolean(false);

9)对象流
	ObjectInputStream/ObjectOutputStream
		序列化		ObjectOutputStream保存基本类型数据或对象的数据
		反序列化	ObjectInputStream读取...
		
	可序列化的要求：
			对象所属的类实现了java.io.Serializable接口
			类中提供static final long serialVersionUID
			类内部的所有属性也必须是可序列化的
	ps :		ObjectOutputStream不能序列化static和transient修饰的成员变量
	
	序列化
		eg:
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("filename.txt"));
		oos.write(new String("HelloWorld"));
		oos.flush();
		oos.close();
	
	反序列化
		eg:
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("filename.txt));
		Object obj = ois.readObject();
		String str = (String) obj;
		ois.close();
	
10)RandomAccessFile
	随机存取文件流
		java.io.RandomAccessFile直接继承Object类
		实现DataInput,DataOutput接口，既能作为输入流，又能作为输出流
	构造器
		RandomAccessFile(File file, String mode)	//mode可以为"r":只读，"rw":可读可写,"rwd":可读可写，同步更新文件内容,"rws":可读可写，同步更新文件内容和元数据
		RandomAccessFile(String name, String mode)
		eg:
			RandomAccessFile raf = new RandomAccessFile(new File("hello.world"), "rw");
	
	如果本文件不存在，该流自动创建文件；如果本文件已存在，该流在输出时从头开始写，覆盖所写文件内容，写多少覆盖多少
		long	getFilePointer()	//获取文件记录指针当前位置
		void	seek(long pos)	//定位文件记录指针到相应位置
	
	如何实现插入？
		eg:
		File file = new File("pathname.txt");
		RandomAccessFile raf = new RandomAccessFile(file, "rw");
		//指针移到要插入的索引位置
		raf.seek(3);
		StringBuilder builder = new StringBuilder((int) file.length);
		int len;
		byte[] bs = new byte[20];
		//复制要插入的索引位置以后的数据到StringBuilder中
		while((len = raf.read(bs) != -1){
			builder.append(new String(bs, 0, len));
		}
		//将指针移回要插入的索引位置
		raf.seek(3);
		//写入目标数据
		raf.write("xyz".getBytes());
		raf.write(builder.toString().getBytes());
		raf.close();
		
		/*
			以上的StringBuilder可以用以下类替代
			就相当于一个包装过的字节数组的容器
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			int len;
			byte[] bs = new byte[20];
			//复制要插入的索引位置以后的数据到StringBuilder中
			while((len = fis.read(bs) != -1){
				baos.write(bs, 0, len);
			}
			//baos.toString();
		*/
	11)NIO.2 since 1.7
		基于缓冲区，更加高效(之前还有个since 1.4的NIO)
		java.nio.
		Path接口
		Files类