java 的IO流--文件流---缓冲流---转换流--打印流---数据流---数组流---对象流--序列化

集合相关辨析题

集合和数组的比较
数组：
1.长度不可变
2.数组中可以存放基本数据类和引用数据类型
3.数组是有序的,不唯一
4.数据结构不同
5，数组中能调用的api不多
Vector 和ArrayList的联系和区别
1.实现原理相同，功能相同，都是长度 可变的数组结构，很多情况下可以互用
区别：
1.Vector 是早期JDK接口，Arraylist 是代替Vector的新接口
2.Vector 线程安全，效率底下Arraylist 重速度轻安全，线程非安全
3.扩容Vector 默认增长1倍Arraylist 增长50%
4.遍历方式
HashMap 和Hashtable的联系和区别
1.hashtable不允许null值，HashMap允许null值
2.hashtable继承Dictionary, HashMap实现了Map
3.hashtable 线程安全，hashMap线程不安全

IO流概述

数据源：datasource

流的分类：

流的方向：
输入流：数据源到程序（InputStream、Reader读进来）
输出流：程序到目的地（OutPutStream、Writer写出去）
处理数据单元：
字节流：按照字节读取数据（InputStream、OutPutStream）
字符流：按照字符读取数据（Reader、Writer）
功能不同
节点流：可以从数据源或者目的地读写数据
处理流（包装流），不直接连接到数据源或者目的地，是其他流进行封装，目的主要是简化操作和提高性能
节点流处于IO操作第一线，所有操作必须通过他们进行，
处理流可以其他流进行处理（提高效率）

字节流（读写）（任意格式文件）

public static void main(String[] args) {
		
		try {
			InputStream is=new FileInputStream("D:/配置文件/test.txt");
			OutputStream os=new FileOutputStream("D:/配置文件/demo.txt");
			//准备一个字节数组，用于作为中转站
			byte[] b =new byte[1024];
			//默认每次读取的长度为文件大小的字节数，文件大小字节数超多1024，则每次默认1024
			int len ;
			//开始读取
			len= is.read(b);
			while(len!=-1){
				System.out.println("----------------------"+len);
				//将读取到的信息写入目的地读一点写一点
				os.write(b,0,len);
				//继续去读
				len=is.read(b);
				os.flush();
			}
			//关闭资源，先开后关
			os.close();
			is.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

字符流（读写）（只能用于操作字符文件 txt、 java等）

/*
 * 字节流：
 * FileInputStream
 * FileOutputStream
 * 字符流：
 * FileReader
 * FileWriter
 */
public class TestCopy {

	public static void main(String[] args) throws IOException {
		Reader reader=new FileReader("D:/配置文件/test.txt");
		int c;
		while((c=reader.read())!=-1){
			System.out.print((char)c);
		}
		reader.close();
	}
}

实现文件夹的复制

*
 * 实现文件夹复制：
 * 1.如果是文件，要进行文件复制
 * 2.如果是文件夹，在目标位置进行创建同名的文件夹
 * 3.子文件继续复制，子文件夹继续创建
 * 
 * 字节流：FileInputStream ,FileOutputStream
 * 递归方案
 */
public class TestFloderCopy {

	public static void main(String[] args) {
		copyDir(new File("D:/配置文件/test.txt"),new File("D:/"));
	}
	/*
	 * 实现文件夹的拷贝
	 */
	private static void copyDir(File src,File dest){
		if(src==null){
			System.out.println("未找到此文件")
			return;
		}
		if(src.isFile()){
			copyFile(src,dest);
		}else if(src.isDirectory()){
			//是文件夹，需要在dest下创建同名文件夹
			File dir=new File(dest,src.getName());
			//创建目录
			dir.mkdir();
			//获取src 下所有的子文件信息
			File[] files = src.listFiles();
			for (File file : files) {
				copyDir(file, dir);
			}
		}
	}
	/*
	 * 实现文件的拷贝
	 * srcFile目标文件
	 * destDir
	 */
	private static void copyFile(File srcFile, File destDir) {
		InputStream input=null;
		OutputStream outPut=null;
		//创建输入输出流
		try {
			 //input=new FileInputStream(srcFile.getAbsolutePath());
			// outPut=new FileOutputStream(new File(destDir,srcFile.getName()));
			//使用缓冲流包装一下
			input=new BufferedInputSteam(new FileInputStream(srcFile.getAbsolutePath()));
			outPut=new BufferedOutputSteam(new FileOutputStream(new File(destDir,srcFile.getName())));
			
			byte[] b=new byte[1024];
			//记录每次中转的长度
			int len;
			while((len=input.read())!=-1){
				outPut.write(b, 0, len);
				outPut.flush();
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			if(outPut!=null){
				try {
					outPut.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(input!=null){
				try {
					input.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		}
	}
}

缓冲字节流

**
 * 缓冲流：
 * 字节流：BufferedInputSteam,BufferedoutputSteam,
 * 字符流：BufferedReader,BufferedWriter
 * reader.readline()//读一行
 * writer.write()//写
 * writer.newLine()//读下一行//换行操作
 * 
 * @author lenovo
 *
 */
public class TestBuffered {

	public static void main(String[] args) throws IOException {
		BufferedInputStream input=new BufferedInputStream(new FileInputStream("D:/"));//默认8192
		BufferedOutputStream output=new BufferedOutputStream(new FileOutputStream(""));
		copy1(input, output);
		copy2(input, output);
	}
	/*
	 * 准备中转站
	 * 字节数组
	 */
	private static void copy2(BufferedInputStream input,
			BufferedOutputStream output) throws IOException {
		//中转站
		byte[] b=new byte[1024];
		//每次读取长度
		int len;
		while((len=input.read())!=-1){
			output.write(b, 0, len);
		}
		output.close();
		input.close();
		
	}
	/*
	 * 每次操作一个字节
	 */

	private static void copy1(BufferedInputStream input,
			BufferedOutputStream output) throws IOException {
		int b;
		while((b=input.read())!=-1){
			output.write(b);
		}
		output.close();
		input.close();
	}

}

转换流

*
 * 从键盘连续输入字符串，将输入的字符串写到一个文件中，直到输入exit为止
 * 
 * 1.不能使用Scanner如何操作
 * System.in:InputStream, 输入流
 * System.out:PrintStream 输出流
 * 
 * 2.字节流能不能转换成字符流？
 * 通过转换流可以实现
 * InputStreamReader:将字节输入流转换为字符输入流
 * BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
 * OutPutStreamWriter：将字节输出流转换成字符输出流
 * 
 * 4.转换流在创建对象时，可以指定编码格式：GBK，gbk2312,ISO-8859-1,utf-8
 */
public class Test {

	public static void main(String[] args) throws IOException {
		//创建扫描器
		//Scanner sc=new Scanner(System.in);
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入一串字符；exit退出输入");
		BufferedWriter writer=new BufferedWriter(new FileWriter("D:/test.txt"));
		String info;
		while(!(info=reader.readLine()).equals("exit")){
			writer.write(info);
			writer.newLine();
			writer.flush();
		}
		writer.close();
		reader.close();
		
	}

}

打印流

printStream ，PrintReader
只有输出流，没有输入流
可以非常方便的将任意数据类型转换成String写到目的地

/*
 * printStream ，PrintWriter
	只有输出流，没有输入流
	可以非常方便的将任意数据类型转换成String写到目的地
 */
public class TestPrintStream {
	public static void main(String[] args) throws IOException {
		//testPs();
		testPw();
	}
	/*
	 * 测试字符打印流---文本文件的复制
	 */
	private static void testPw() throws IOException {
		//输入流
		BufferedReader br=new BufferedReader(new FileReader("D:/print.txt"));
		//输出流
		//printWriter,第二个参数是一个boolean，表示自动刷新
		PrintWriter pw =new PrintWriter(new BufferedWriter(new FileWriter("E:/print.txt")),true);
		
		String line;
		while((line=br.readLine())!=null){
			pw.println(line);
		}
		pw.close();
		br.close();
	}
	/*
	 * 测试字节打印流
	 */
	private static void testPs() throws FileNotFoundException {
		PrintStream ps=new PrintStream(new File("D:/print.txt"));
		ps.println(123);
		ps.println('a');
		ps.println(true);
		ps.println(new Date());
		ps.close();
	}
}

数据流(打印流会将数据全部转换成字符串，不能保留数据类型)

对象流（数据不能保存自己定义的对象数据类型）

保存的对象在使用对象流存储时要实现序列化接口
先存储，后读
读的顺序要与存的一致
读和数据流不同不需要创建对象

/*打印流
 * PrintStream 和PrintWriter
 * 可以将任何数据转换成字符串写到文件中，
 * 1.数据类型无法保存
 * 2.只有输出流没有输入流
 * 
 * 数据流：DataInputStream ,DataOutputStream:用来直接读写基本数据类型和String类型
 * 对象流：ObjectInputStream,ObjectOutputStream：用来直接读写任何数据类型
 * 
 * 只有字节流，没有字符流
 * 只能先写，然后再读
 * 
 */
public class TestDataStream {

	public static void main(String[] args) throws IOException {
		//writeData();
		readData();
	}
	/*
	 * 使用数据流将文件中数据读出来
	 */
	private static void readData() throws IOException {
		FileInputStream fis = new FileInputStream("D:/data.txt");
		BufferedInputStream bis = new BufferedInputStream(fis);
		DataInputStream dis = new DataInputStream(bis);
		//读要按写的顺序读
		System.out.println(dis.readBoolean());
		System.out.println(dis.readChar());
		System.out.println(dis.readDouble());
		System.out.println(dis.readUTF());
		dis.close();
	}
	/*
	 * 使用数据流将基本数据类型和字符串写入一个文件中
	 */
	private static void writeData() throws IOException {
		//文件输出流对文件进行写的操作:节点流
		FileOutputStream output=new FileOutputStream("D:/data.txt");
		//处理流：提高效率
		BufferedOutputStream bos=new BufferedOutputStream(output);
		//处理流：简化操作
		DataOutputStream dos = new DataOutputStream(bos);
		
		dos.writeBoolean(false);
		dos.writeChar('a');
		dos.writeDouble(3.15);
		dos.writeUTF("你好数据流");
		dos.close();
		
	}

}

序列化（对象流存储对象数据，写时，因为内存中不能永久化保存，会报序列化错误，所以要对存储对象进行序列化标记Serializable,）

标记接口没有实际内容，表示只要实现化这个接口的类就能进行序列化操作
SerializableUID:用于表示本地对象和获取对象是不是同一个类型
transient：临时的，不参与序列化

数组流(为了将其他数据类型转换成字节数组)

字节数组流：ByteArrayInputStream,ByteArrayOutputStream
字符数组流：CharArrayReader,CharArrayWriter
字符串流：StringReader, StringWriter
String —>byte[]:str.getBytes();
其他类型没有特定的方法转换为字节数组可以使用数组流转换

节点：