集合,IO总结

集合
	集合定义:集合就是存储对象的容器
	集合分类:
		(1)Collection
			|--List
				元素有序,可以重复
				|--ArrayList
					怎么存就怎么取
					底层是数组,查询快,增删慢,线程不安全
				|--LinkedList
					怎么存就怎么取
					底层是链表,查询慢,增删快,线程不安全
				|--Vector
					底层是数组,线程安全
			|--Set	
				元素无序,不可以重复
				|--HashSet
					底层是Hash表
					可以重写hashcode和equals保证元素唯一,如果再添加重复元素,
						public boolean equals(Object obj){
							if(obj==null){
								return true;
							}
							if(!(obj instanceof Person)){
								return false;
							}
							Person p=(Person)obj;
							return name.equals(p.name)&& age==p.age;
						}
					|--LinkedHashSet
						数据严格按照插入的顺序存放
						删除之后会去掉那个位置，新增的数据将在集合的末尾
				|--TreeSet
					底层是二叉树,会按照字母和数字自然排序
					(1)让类自身具备比较性,可以实现Comparable接口,重写compareTo方法
						public int compareTo(Person p){
							int num = this.age - p.age;
							return num==0?this.name.compareTo(p.name):num;
						}
					(2)自定义比较器实现Comparator接口,优先级高于Comparable
						class MyCom implements Comparator<Person>{
							public int compare(Person p1,Person p2){
								int num = p1.getName().compareTo(p2.getName());
								return num==0?p1.getAge()-p2.getAge():num;
							}
						}

		(2)Map
			存的是键值对
			|--HashMap
				底层采用Hash表
				线程不安全
				有两种取出方式
				(1)先得到键,再用键取值,keySet()
					Set<String> set=hm.keySet();
					for(String s:set){
						Person p=hm.get(s);
						System.out.println(s+"..."+p.getName()+"..."+p.getAge());
					}
				(2)得到Map.Entry类型的键值对,再取出键和值,entrySet()
					Set<Map.Entry<String,Person>> set=hm.entrySet();
					Iterator<Map.Entry<String,Person>> it=set.iterator();
					while(it.hasNext()){
						Map.Entry<String, Person> me=it.next();
						String s=me.getKey();
						Person p=me.getValue();
						System.out.println(s+"..."+p.getName()+"..."+p.getAge());
					}

				|--LinkedHashMap
					LinkedHashMap的遍历速度只和实际数据有关
			|--TreeMap
				底层二叉树,线程不安全
				会按照字母和数字自然排序

			|--HashTable
				底层是hash表,线程安全

IO流
	分类:
		(1)数据类型不同
		|--字节流
		|--字符流
		(2)流向不同
		|--输入流
		|--输出流
	流的体系结构
		|--字节流
			|--InputStream
				|--FileInputStream
				|--BufferedInputStream(高效)
			|--OutputStream
				|--FileOutputStream
				|--BufferedInputStream(高效)
		|--字符流
			|--Writer  特殊方法,newLine():跨平台的换行符
				|--FileWriter
				|--BufferedWriter(高效)

			|--Reader  特殊方法,readLine():可以一次读一行
				|--FileReader
				|--BufferedReader(高效)
		|--转换流
			OutputStreamWriter
			InputStreamReader
*********字符流-字符流,复制txt文档
			(1)txt-txt第一种,用字节复制txt文件
			FileReader fr=new FileReader("a.txt");
			FileWriter fw=new FileWriter("b.txt");
			
			int ch=0,count=0;
			while((ch=fr.read())!=-1){
				fw.write(ch);
				if(count++%1024==0){
					fw.flush();
				}
			}
			fr.close();
			fw.close();
		(2)txt-txt第二种,用字节数组复制txt文件
			FileReader fr=new FileReader("a.txt");
			FileWriter fw=new FileWriter("b.txt");
			int len=0;
			char[] chs=new char[1024];
			while((len=fr.read(chs))!=-1){
				fw.write(chs, 0, len);
				fw.flush();
			}
			fw.close();
			fr.close();
		(3)BufferedWriter(高效)
			BufferedReader br=new BufferedReader(new FileReader("a.txt"));
			BufferedWriter bw=new BufferedWriter(new FileWriter("b.txt"));
			String line=null;
			while((line=br.readLine())!=null){
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			
			br.close();
			bw.close();
**********字节流-字节流,复制txt文件
		(1)一个字节一个字节地复制
			FileInputStream fis=new FileInputStream("a.txt");
			FileOutputStream fos=new FileOutputStream("b.txt");
			
			int by=0,count=0;
			while((by=fis.read())!=-1){
				fos.write(by);
				if(count++%1024==0){
					fos.flush();
				}
			}
			fis.close();
			fos.close();
		(2)用字节数组复制
			FileInputStream fis=new FileInputStream("a.txt");
			FileOutputStream fos=new FileOutputStream("b.txt");
			int len=0;
			byte[] bys=new byte[1024];
			while((len=fis.read(bys))!=-1){
				fos.write(bys, 0, len);
				fos.flush();
			}
			fos.close();
			fis.close();
	
********转换流案例
	A:文本文件--控制台输出(System.out)
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		String line = null;
		while((line=br.readLine())!=null)
		{
			bw.write(line)
			//一句一句地传输是不会自动换行的
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
	B:键盘录入(System.in)--文本文件
		数据源：
			键盘录入 -- System.in -- InputStream -- InputStreamReader -- BufferedReader
		目的地：
			文本文件 -- Writer -- FileWriter -- BufferedWriter

		代码：
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

			String line = null;
			while((line=br.readLine())!=null)
			{
				if("over".equals(line))
				{
					break;
				}
				bw.write(line);
				bw.newLine();
				bw.flush();
			}

			bw.close();
			br.close();
			

	C:键盘录入(System.in)--控制台输出(System.out)
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
				
			String line = null;
			while((line=br.readLine())!=null)
			{
				if("over".equals(line))
				{
					break;
				}

				bw.write(line);
				bw.newLine();
				bw.flush();
			}

			bw.close();
			br.close();
				
	打印流
		|--PrintWriter
			可以打印任何数据
		********特殊方法println(),true可以自动刷新
			它可以直接往文件中写入数据
			注意：请问哪些流对象可以直接操作文件呢？
			观其构造方法，如果同时有File和String的参数。应该是可以的。
		案例:复制文本文件(掌握)
			BufferedReader br = new BufferedReader(new FileReader("a.txt"));
			PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
			//true表示开启自动刷新

			String line = null;
			while((line=br.readLine())!=null)
			{
				pw.println(line);
			}

			pw.close();
			br.close();
		案例:文件内容打印到控制台
			BufferedReader br=new BufferedReader(new FileReader("a.txt"));
			PrintWriter pw=new PrintWriter(System.out);
			
			String len=null;
			while((len=br.readLine())!=null){
				pw.println(len);
			}
			pw.close();
			br.close();
		案例:键盘输入打印到控制台
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			PrintWriter pw=new PrintWriter(System.out);
			
			String len=null;
			while((len=br.readLine())!=null){
				if("over".equals(len)){
					break;
				}
				pw.println(len);
				pw.flush();
			}
			
			pw.close();
			br.close();


Properties
	(1)是Map的体系，但是，它可以和IO结合使用。
	(2)特殊方法：(理解)
		list:把集合中的数据保存到文件中。使用打印流。
		load:把文件中的数据加载到集合中，使用任意流。
		store:把集合中的数据保存到文件中。使用任意流。
	案例：(理解)查找prop.txt中有没有键为lisi的，如果有，则修改其实为35
		// 创建Properties集合对象
		Properties prop = new Properties();

		// 把prop.txt文件中的数据加载到集合中
		FileReader fr = new FileReader("prop.txt");
		prop.load(fr);
		fr.close();
		
		System.out.println(prop);
		
		//遍历集合，获取到每一个键，并进行判断。
		Set<Object> set = prop.keySet();
		for(Object obj  : set){
			//obj是不是就是键值？是
			if("lisi".equals(obj)){
				prop.put(obj, String.valueOf(50));
				break;
			}
		}
		
		//最后把集合中的数据重新保存到文件中。
		FileWriter fw = new FileWriter("prop.txt");
		prop.store(fw, null);
		fw.close();

	案例:我们可以把一个文本中的键值对放入Properties中,再把集合中的数据写入一个文本文件
		Properties prop=new Properties();
		PrintWriter pw=new PrintWriter("b.txt");
		FileReader fr=new FileReader("a.txt");
		prop.load(fr);
		prop.list(pw);
		
		pw.close();
		fr.close();

序列化流(对象流或串行化流)
		 * ObjectOutputStream：把对象按照流的方式写入文件
		 	void writeObject(Object obj)
		 * ObjectInputStream：把文件中的流数据还原成一个对象
		  	Object readObject()
	案例: 用对象流写入三个对象，并读取
	      Exception in thread "main" java.io.EOFException：意外到达文件的结尾
	      异常处理的时候，千万不要隐藏异常
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("a.txt"));
		ArrayList<Person> array=new ArrayList<Person>();
		
		array.add(new Person("zhangsan1",14));
		array.add(new Person("zhangsan3",13));
		array.add(new Person("zhangsan2",12));
		
		oos.writeObject(array);
		oos.close();
		
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt"));
		Object obj=ois.readObject();
		ArrayList<Object> al=(ArrayList)obj;
		for (Object o : al) {
			Person p=(Person)o;
			System.out.println(p.getName()+"..."+p.getAge());
		}
		ois.close();