Java文件IO线程setmap

Collection父接口
List(特点：有序的，可以重复)
ArrayList 数组 适合遍历查找
LinkedList 链表 适合添加删除
Vector 数组
Stack 数组（栈）先进后出
Set 特点：无序 不能重复
HashSet 哈希表（数组 链表 二叉树）
重复依据：执行hashCode()来计算存储位置 执行equals来比较结果
LinkedHashSet 哈希表 可以保证顺序 （输入顺序）
TreeSet 自平衡红黑二叉树
元素要实现Comparable接口 或者定制比较器Comparator
重复依据:Comparable接口的compareTo方法的返回时0，或比较器的返回为0
Map 存储键值对 一个键对应一个值 键不可重复 值可以重复 无序
HashMap 哈希表 执行hashCode()来计算存储位置 执行equals比较结果
Hashtable 哈希表 不能存储null键和null值，线程安全 jdk1.0
LinkedHashMap 哈希表 可以保证顺序
TreeMap 自平衡红黑树 key要实现Comparable接口 或者定制比较器Comparator
总结 ：
Hash开头的都是哈希表结构（如果不是基本数据类型，对象的都要用HashCode(）来计算存储位置，执行equals来比较结果）,Linded开头的都可以实现顺序，但是Tree开头的都意味着要排序，都要实现Comparable接口（compareTo来返回）或者自定义Comparator来比较。

File类
File file=new File(“路径”);
创建对象，文件或文件夹不一定存在，
判断文件是否存在 exists
把创建或文件夹创建出来 createNewFile() mkdir()单个 mkdirs()多个
删除 delete() deleteOnExit（）jvm删除
获取 绝对路径 规范路径 文件或文件夹名 最后修改时间
getAbsolutePath getCanonicalPath name lastModified
判断是文件还是文件夹 isDirectory isFile()是否文件 isHidden()隐藏否
遍历文件夹内容 list(）
判断文件的可执行canExecute 可读取canRead 可写入canWriter
递归遍历文件夹：
public static void listdir(File dir){
File[] file=new listFiles();
if(file!=null&file.length>0){如果文件不等于空或者文件长度大于0
for(File file1:file){增强for
if(file1.isDirectory()){file1是否是文件夹
deleFile(file1)是递归 listdir(file1);是的话递归
}else{
不是显示然后 sout(file1.toString)不是显示
}
}
sout(dir.toString+" "+dir.delete());然后删除
}
}

IO流：
按照方向：分为输入流input和输出流output
按照读取字节个数：字节流和字符流
按照功能分：字节流（复制读写数据） 处理流（封装）
流的使用：
字节输入流：InputStream------>FileInputStream
字节输出流：OutputStream---->FileOutputStream
字符输入流：Reader—>InputStreamReader----->FileReader
字符输出流：Writer—>OutputStreamWriter---->FileWriter
字节输入流用法:
创建字节输入流: FileInputStream fis=new FileInputStream(“路径”);
读取一次一个字节的： int date=-1
while((date=fis.read())!=-1){
System.out.println((char)data)
}
读取一次多个：byte[] buf=new byte[10244];
int len=-1;
count=0;
while((len=fis.read(buf))!=-1){
count++
System.out.println((char)buf[count]);
}
字节输出流用法：
创建输出流：FileOutputStream fos=new FileOutputStream(“路径文件名”);加true可写多个
写入：fos.write();单个写入
多个写入：String content=“abc”;
fos.write(content.getBytes());转换数组写入
字节输入输出复制:
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
字符输入流用法：
创建对象：FileReader reader=new FileReader(“路径文件名”);
读取一个：System.out.println((char)reader.read());
读取多个：int data=-1;
while(data=reader.read()!=-1){
System.out.println((char)data);
}
字符输出流：
创建对象：FileWriter fw=new FileWriater(“目标路径名”);
写入for(int i=0;i<10;i++){
fw.write(“内容”);
fw.flush();刷新
}
字符输入输出复制：
char[] buf=new char[1024];
int len=-1;
while((len=reader.read(buf))!=-1){
fw.writer(buf,0,len);
}
总结：一次多个都需要创建数组 字节byte[10244] 字符char[1024]
字节流可以复制一切文件，字符流只能复制文本文件

转换流：
a:实现字节流到字符流的转换
b:解决中文乱码的问题 gb2312 GBK GB18030 unicode utf-8
InputStreamReader:字节字符转换输入流，将字节转换为字符输入流
将外部设备中的二进制数据读取到内存转成字符，指定编码，字节流
OutputStreamWriter:字符转输出流，将内存中的字符转成字节输出流
把内存中的字符使用编码转成二进制，保存到外部设备
InputStreamReader使用：
创建转换流：
FileInputStream fis=new FileInputStream(“路径文件名”);
InputStreamReader irs=new InputStreamReader(fis,“gbk(格式)”);
读取文件:
char[] buf=new char[1024];
int len=-1;
while((len=irs.read(buf))!=-1){
String str=new String(buf,0,len);
System.out.println(str);
}
OutputStreamWriter使用:
创建转换流：
FileOutputStream fos=new FileOutputStream(“路径文件名”);
OutputStreamWriter osw=new OutputStreamWriter(fos,“gdk”);
写入：
for(int i=0;i<10;i++){
osw.writr(“内容”);
}
osw.flush(); 刷新 ，否则可能显示不出来

转换流：
BufferedInputStream 字节输入缓冲流 byte[]
BufferedOutputStream 字节输出缓冲流
BufferedRread 字符输入缓冲流 char[]
BufferedWriter 字符输出缓冲流
ByteArrayInputStream 字节数组输入缓冲流
ByteArrayOutputStream 字节数组输出缓冲流
字节缓冲流：
BufferedInputStream使用方法：
创建对象：fileInputStream fis=new FileInputStream(“路径文件名”);
BufferedInputStream bis=new BufferedInputStream(fis);
读取：byte [] buf=new byte[10244];
int len=-1;
while((len=bis.read(buf))!=-1){
String str=new String(buf,0,len);
System.out.println(str);
}
BufferedOutputStream使用方法：
创建对象：FileOutputStream fos=new FileOutputStream(“目标文件名”);
BuuferedOutputStream bos=new BufferedOutputStrea(fos);
写入: for(int i=0;i<10;i++){
bos.write(“内容”);
bos.flush();
}
使用缓冲流复制：
创建对象:FileInputStream fis=new FileInputStream(“路径目标”);
BufferedInputStream bis=new BufferedInputStream(fis);
FileOutputStream fos=new FileOutputStream(“目标文件名”);
BufferedOutputStream bos=new BufferedOutputStream(fos);
开始复制：byte[] buf = new byte[10244];
int len=-1;
while((len=bis.read(buf))!=-1){
bos.write(buf,0,len);
bos.flush();
}

字符缓冲流：
BufferedReader使用方法：
创建对象: FileReader fr=new FileReader(“路径目标”);
BufferedReader reader=new BufferedReader(fr);
读取： byte[] buf=new byte[1024];
int len=-1;
while((len=reader.read(buf))!=-1){
String str=new String(buf,0,len);
System.out.println(str);
}
读取2:
String rea= reader.readLine();
System.out.println(rea);//读取一行

	String result="";
	while((result=reader.readLine())!=null){
		System.out.println(result);
		}

BufferedWriter使用方法：
创建对象：FileWriter fw=new FileWriter(“文件名”);
BufferedWriter bw=new BufferedWriter(fw);
写入:for(int i=0;i<10;i++){
bw.writr(“内容”);
bw.flush();
}

内存流：输入和输出都是从文件中来的，当然也可以把输入输出的文职放置到内存上、
ByteArrayInputStream:把内容写道内存中，是Inputstream的子类
ByteArrayOutputStream:把内存中的数据输出，是OutputStream的子类
举例：
String str=“helloworld”;
//内存输入流，与文件流不同，不设置文件路径，
ByteArrayInputStream bis=new ByteArrayInputStream(str.getBytes());
//内存输出流，与文件流不同，不设置文件路径
ByteArrayOutputStream bos=new ByteArrayOutputStream();

读取写入：
	int temp=0;
	while((temp=bis.read())!=-1){
		char c=(char)temp;//把读取的数组转为char
		bos.write(Character.toLower(c));//把char类型的c改变大小写写入
		}		
	//循环结束后，所有的数据都在bos中，取出内容，转换
	String  s=bos.toString();

---

标准输入输出流
java 的标准输入输出分别是通过System.in 和 System.out实现
PrintStream：输入
PrintWriter:输出
PrintStram和PrintWriter用法：
//假设现在有一个a.txt 内容为“hello”
创建 : PrintStream ps=new PrintStream(“a.txt”);//创建文件
PrintWriter pw=new PrintWriter(“a.txt”);//写入到文件
PrintStream print=new PrintStream(new FileOutputStream(info.txt));
打印：pw.write(“内容”);
刷新: pw.flush();
重定向：System.setOut(print);//重新定向，定向后的目标文件改变 System.out.println(“1”);
//内容会写到a.txt文件中

对象流：
流中流动的数据是对象
将一个对象写入到本地文件中，被称为对象的序列化
ObjectInputStream:对象输出流
将一个本地文件中的对象读取出来，被称为对象的反序列化
ObjectOutputStream:对象输入流
注意：序列化对象的类型必须实现Serializable接口，否则不能序列化 ，如果多个对象序列化到本地，可以借助集合（将多个对象添加到集合中，将集合的对象写入到本地文件中，再次读出，获取到的仍然是集合对象，遍历集合）
对象中那些字段不可以序列化：
transient 修饰的字段
静态成员不可序列化

序列化版本类ID：可以通过serialVersionUID来代表一个类，序列化后如果有改动可以通过这个属性来确定是否是同一个类

	try{//执行的代码，其中可能有异常，一旦发现异常，立即跳到catch执行，}
	catch{//除非try里边执行代码发生了异常，否则这里的代码不会执行}
	finally{//不管什么情况都睡执行，包括try catch里边用了return 一定会执行}

序列化举例：
实例化一个对象：Person person=new Person(“张三”,10,“b”);
实例化一个对象输出流的对象:
ObjectOutputStream output=null;