IO输入输出流

File parent = new File("D:\\aa");//String parent = "d:\\aa";
File child = new File(parent, "aa.txt");

public void testMethod10() {
		File file = new File("D:/aa");
		deleteFile(file);
	}

	private void deleteFile(File file) throws RuntimeException {
		if (file == null) {
			// System.out.println("file为null,不能删除");
			throw new RuntimeException("file为null,请指定具体的目录或文件");
		}
		if (file.isDirectory()) {
			// 指定的file为目录
			// 返回指定目录中的所有文件和目录
			File[] files = file.listFiles();
			// 遍历files,有可能是目录,也有可能是文件
			for (File f : files) {
				// 递归调用自己
				deleteFile(f);
			}
		}
		// 说明是文件,直接删了
		file.delete();
	}

public class TestFileStreamClass {
	@Test
	public void testMethod1()throws Exception {
        //创建了一个输出流的对象,此对象跟硬盘的某个文件关联,对文件只能做输出操作
        OutputStream os = new FileOutputStream(new File("D:/aa/fos.txt"));
        //把字符串转换成字节数组并写入os流对象中
        os.write("hello world!".getBytes());
        //清除缓冲,数据回写硬盘
        os.flush();
        //关闭流释放资源
        os.close();
    }
	/**
	 * 
	 * @throws IOException
	 */
	@Test
	public void testMethod2()throws IOException{
		//创建了一个输入流的对象,此对象跟硬盘的某个文件关联,对文件输入操作
		InputStream is = new FileInputStream("d:/aa/fos.txt");
		int d = -1;
		while((d=is.read())!=-1){
			System.out.println((char)d);
		}
		is.close();
	}
	/**
	 * int read(byte[] buf);
	 * 一次读取字节数据存储buf字节数组
	 * @throws IOException
	 */
	@Test
	public void testMethod3()throws IOException{
		//创建了一个输入流的对象,此对象跟硬盘的某个文件关联,对文件输入操作
		
		InputStream is = new FileInputStream("d:/aa/fos.txt");
		byte[] buf = new byte[3];
		int len = -1;
		while((len=is.read(buf))!=-1){
			System.out.println("len="+len+" "+new String(buf).substring(0,len));
		}
		is.close();
	}
	/**
	 * int read(byte[] buf,int offset,int len);
	 * 一次读取字节数据存储buf字节数组
	 * @throws IOException
	 */
	@Test
	public void testMethod4()throws IOException{
		//创建了一个输入流的对象,此对象跟硬盘的某个文件关联,对文件输入操作
		
		InputStream is = new FileInputStream("d:/aa/fos.txt");
		byte[] buf = new byte[3];
		int len = -1;
		while((len=is.read(buf,0,buf.length))!=-1){
			System.out.println("len="+len+" "+new String(buf).substring(0,len));
		}
		is.close();
	}
	/**
	 * 实现一个大文件的复制
	 * 注意单字节复制
	 * @throws IOException
	 */
	@Test
	public void testMethod5()throws IOException{
		System.out.println("开始复制文件...");
		InputStream is = new FileInputStream("d:/aa/tedu.zip");
		OutputStream os = new FileOutputStream("d:/aa/tedu1.zip");
		int count = 0;
		int d = -1;
		while((d=is.read())!=-1){
			os.write(d);
			if(count++==100){
				count=0;
				os.flush();
			}
		}
		is.close();
		//os.flush();
		os.close();
		System.out.println("文件复制结束!");
	}
	/**
	 * 多字节复制
	 * 借助减少循环次数
	 * @throws IOException
	 */
	@Test
	public void testMethod6()throws IOException{
		System.out.println("开始复制文件...");
		long begin = System.currentTimeMillis();
		InputStream is = new FileInputStream("d:/aa/tedu.zip");
		
		OutputStream os = new FileOutputStream("d:/aa/tedu2.zip");
		byte[] buf = new byte[1024*1024*10];
		int count = 0;
		int len = -1;
		while((len=is.read(buf))!=-1){
			os.write(buf,0,len);
		}
		is.close();
		os.flush();
		os.close();
		long end = System.currentTimeMillis();
		System.out.println("文件复制结束!"+(end-begin));
	}

}

public class TestBufferStreamClass {
	/**
	 * 缓冲输出流
	 * 减少跟硬盘的交互次数
	 */
	@Test
	public void testMethod1()throws IOException{
		//低级流,文件的字节流
		OutputStream os = new FileOutputStream("D:/aa/=bos.txt");
		//对低级流,做二次封装,把低级流转换成高级流
		BufferedOutputStream bos = new BufferedOutputStream(os);
		//用高级流的对象打点调用api方法,读写效率有提升
		bos.write("hello world".getBytes());
		//清空缓存,强制回写硬盘
		bos.flush();
		//关闭流资源
		bos.close();
		os.close();
	}
	/**
	 * 缓冲输入流
	 * 减少跟硬盘的交互次数
	 */
	@Test
	public void testMethod2()throws IOException{
		//低级输入流
		InputStream is = new FileInputStream("D:/aa/fos.txt");
		//高级缓冲输入流,对低级流的二次封装
		BufferedInputStream bis = new BufferedInputStream(is);
		int d = -1;
		while((d=bis.read())!=-1){
			System.out.println(d);
		}
		bis.close();
		is.close();
	}
	/**
	 * 用缓冲流的方式来复制文件
	 * 单字节
	 * 已经减少了跟硬盘的交互次数
	 * @throws IOException
	 */
	@Test
	public void testMethod3()throws IOException{
		System.out.println("开始复制文件...");
		long begin = System.currentTimeMillis();
		//构建输入低级流
		InputStream is = new FileInputStream("d:/aa/tedu.zip");
		//构建输入高级流
		BufferedInputStream bis = new BufferedInputStream(is);
		//构建输出低级流
		OutputStream os = new FileOutputStream("d:/aa/tedu4.zip");
		//构建输出高级流
		BufferedOutputStream bos = new BufferedOutputStream(os);
		//单字节复制数据
		int d = -1;
		while((d=bis.read())!=-1){
			bos.write(d);
		}
		bos.close();
		os.close();
		bis.close();
		is.close();
		System.out.println("复制文件结束!");
		long end = System.currentTimeMillis();
		System.out.println(end-begin);
	}
	/**
	 * 用缓冲流的方式来复制文件
	 * 多字节
	 * 减少了跟硬盘的交互次数
	 * 人为自己做了一个缓冲,减少循环数
	 * 
	 * @throws IOException
	 */
	@Test
	public void testMethod4()throws IOException{
		System.out.println("开始复制文件...");
		long begin = System.currentTimeMillis();
		//构建输入低级流
		InputStream is = new FileInputStream("d:/aa/tedu.zip");
		//构建输入高级流
		BufferedInputStream bis = new BufferedInputStream(is);
		//构建输出低级流
		OutputStream os = new FileOutputStream("d:/aa/tedu5.zip");
		//构建输出高级流
		BufferedOutputStream bos = new BufferedOutputStream(os);
		//多字节复制数据
		byte[] buf = new byte[1024*1024*4];
		int len = -1;
		while((len=bis.read(buf))!=-1){
			bos.write(buf,0,len);
		}
		bos.close();
		os.close();
		bis.close();
		is.close();
		System.out.println("复制文件结束!");
		long end = System.currentTimeMillis();
		System.out.println(end-begin);
	}

}

public class Student implements Serializable {

	private static final long serialVersionUID = 1L;
	private String name;//可以序列化
	private int age;//可以序列化
	private transient String stuNo;//不可以序列化
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getStuNo() {
		return stuNo;
	}
	public void setStuNo(String stuNo) {
		this.stuNo = stuNo;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", stuNo=" + stuNo + "]";
	}
	

}

public class TestObjectStream {
	@Test
	public void testMethod1()throws IOException{
		Student stu1 = new Student();
		stu1.setName("张三");
		stu1.setAge(20);
		stu1.setStuNo("S001");
		//构建低级流
		OutputStream os = new FileOutputStream("D:/aa/student.data");
		//构建高级流 对象输出流
		ObjectOutputStream oos = new ObjectOutputStream(os);
		oos.writeObject(stu1);
		oos.flush();
		oos.close();
		os.close();
	}
	/**
	 * 反序列化操作
	 */
	@Test
	public void testMethod2(){
		
		try {
			//构建低级输入流
			InputStream is = new FileInputStream("D:/aa/student.data");
			//构建对象的高级输入流
			ObjectInputStream ois = new ObjectInputStream(is);
			Student stu = (Student)ois.readObject();
			System.out.println(stu);
			ois.close();
			is.close();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class TestDataStreamClass {
    /**
     * 数据输出流
     */
    public void testMethod1()throws IOException {
        //构建低级流
        OutputStream os = new FileOutputStream("D:/aa/dos.txt") ;
        //封装低级流为数据高级流
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeInt(1000);
        dos.writeUTF("hello world");
        dos.flush();
        dos.close();
        os.close();
    }
    public void testMethod2()throws  IOException{
        InputStream is = new FileInputStream("D:/aa/dos.txt");
        DataInputStream dis = new DataInputStream(is);
        int value = dis.readInt();
        String str = dis.readUTF();
        System.out.println(value+" "+str);
        dis.close();
        is.close();
    }

 /**
     * 字符输出流
     * 将字节流转换为字符流
     */
    public void testMethod1()throws IOException {
        OutputStream os = new FileOutputStream("D:/aa/osw.txt");
        OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");
        osw.write("hello world,我们爱java");
        osw.flush();
        osw.close();
        os.close();
    }

    /**
     * 字符输入流
     * 单字符读取
     * @throws IOException
     */
    public void testMethod2()throws IOException{
        InputStream is = new FileInputStream("D:/aa/osw.txt");
        InputStreamReader isr = new InputStreamReader(is,"UTF-8");
        int c = -1;
        while ((c=isr.read())!=-1){
            System.out.println((char)c);
        }
        isr.close();
        is.close();
    }
    /**
     * 字符输入流
     * 单字符读取
     * @throws IOException
     */
    public void testMethod3()throws IOException{
        InputStream is = new FileInputStream("D:/aa/osw.txt");
        InputStreamReader isr = new InputStreamReader(is,"UTF-8");
        char[] chars = new char[3];
        int len = -1;
        while ((len=isr.read(chars))!=-1){
            System.out.println(new String(chars).substring(0,len));
        }
        isr.close();
        is.close();
    }

  /**
     * BufferedWriter
     * @throws IOException
     */
    public void testMethod4()throws IOException{
        OutputStream os = new FileOutputStream("D:/aa/bw.txt");
        Writer osw = new OutputStreamWriter(os,"utf-8");
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("我们爱java,爱的那么深,bull shit");
        bw.flush();
        bw.close();
        osw.close();
    }

    /**
     * BufferedReader
     * @throws IOException
     */
    public void testMethod5()throws IOException{
        InputStream is = new FileInputStream("D:/aa/bw.txt");
        Reader isr = new InputStreamReader(is,"utf-8");
        BufferedReader br = new BufferedReader(isr);
        char[] chars = new char[3];
        int len = -1;
        while((len=br.read(chars))!=-1){
            System.out.println(new String(chars).substring(0,len));
        }
        br.close();
        isr.close();
        is.close();
    }
    /**
     * BufferedReader
     * @throws IOException
     */
    public void testMethod6()throws IOException{
        InputStream is = new FileInputStream("D:/aa/bw.txt");
        Reader isr = new InputStreamReader(is,"utf-8");
        BufferedReader br = new BufferedReader(isr);
        String str = br.readLine();
        System.out.println(str);
        br.close();
        isr.close();
        is.close();
    }

 public void testMethod1()throws IOException {

        OutputStream os = new FileOutputStream("D:/aa/pw.txt");
        Writer osw = new OutputStreamWriter(os,"utf-8");
        PrintWriter pw = new PrintWriter(osw,true);
       // PrintWriter pw1 = new PrintWriter(os);
        pw.println("不是用write写出的,用println方法写出,能用write写出");
        pw.flush();
        os.close();
    }