JavaSe——IO流_Part1

A.递归

l  递归

•    方法定义中调用方法本身的现象

l  递归注意实现

•    要有出口，否则就是死递归

•    次数不能太多，否则就内存溢出

•    构造方法不能递归使用

案例1：阶乘

package com.core.io.demo;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		// 阶乘
		System.out.println("输入的数字：");
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();

		int result = jc(num);
		System.out.println(result);
	}

	private static int jc(int num) {
		if (num == 1) {
			return 1;
		} else {
			return num * jc(--num);
		}
	}
}

案例2：不死神兔

package com.core.io.demo;

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		// 不死神兔 1,1,2,3,5,8
		// 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,
		for (int i = 1; i < 20; i++) {
			int num = rabbit(i);
			System.out.print(num + ",");
		}
	}

	private static int rabbit(int num) {
		if (num == 2 || num == 1) {
			return 1;
		} else {
			return rabbit(num - 1) + rabbit(num - 2);
		}
	}

}

案例3：递归输出指定目录下所有的java文件的绝对路径案例

package com.core.io.demo;

import java.io.File;

public class Test2 {
	public static void main(String[] args) {
		// 递归输出指定目录下所有的java文件的绝对路径案例
		// E:\javaSeworkspace\JavaSeBasic\src
		File file = new File("E:\\javaSeworkspace\\JavaSeBasic");
		getAllFile(file);
	}

	private static void getAllFile(File file) {
		File[] files = file.listFiles();
		for (File f : files) {
			if(f.isDirectory()){
				getAllFile(f);
			}else{
				if(f.getName().endsWith(".java")){
					System.out.println(f.getAbsolutePath()+"---"+f.getName());
				}
			}
		}
	}

}

案例4：递归删除带内容的目录案例

package com.core.io.demo;

import java.io.File;

public class Test3 {
	public static void main(String[] args) {
		// 递归删除带内容的目录案例
		// E:\temp\JavaSeBasic
		File file = new File("E:\\temp\\JavaSeBasic");
		getAllFile(file);
	}

	private static void getAllFile(File file) {
		File[] files = file.listFiles();
		for (File f : files) {
			if(f.isDirectory()){
				getAllFile(f);
			}else{
//				if(f.getName().endsWith(".java")){
//					System.out.println(f.getAbsolutePath()+"---"+f.getName());
//				}
				System.out.println("删除文件："+f.getName());
			}
		}
		System.out.println("删除文件夹："+file.getName());
	}

}

B.IO流

l  IO流用来处理设备之间的数据传输

•    上传文件和下载文件

l  Java对数据的操作是通过流的方式

l  Java用于操作流的对象都在IO包中

l  按照数据流向

•    输入流 读入数据

•    输出流 写出数据

l  按照数据类型

•    字节流

•    字符流

•    什么情况下使用哪种流呢?

•    如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。

•    如果你什么都不知道，就用字节流

 

l  字节流的抽象基类：

•    InputStream ，OutputStream。

l  字符流的抽象基类：

•    Reader ， Writer。

l  注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

•    如：InputStream的子类FileInputStream。

•    如：Reader的子类FileReader。

案例：写数据到一个文件

package com.core.io.demo1;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
	public static void main(String[] args) throws IOException {
		// 往一个文件写入数据hello,IO.Java！
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 创建字节流输出对象 做了几件事：
		/*
		 * A.调用系统功能创建文件 
		 * B.创建fos对象 
		 * C.把fos对象指向这个文件
		 */

		// 写数据
		fos.write("hello,IO.Java!".getBytes());
		fos.close();
		// 关资源
		/*
		 * A.让流对象变成垃圾，这样就可以被垃圾回收机制回收了
		 *  B.通知系统去释放跟该文件相关的资源想·
		 */
	}

}

C.FileOutputStream的三个write()方法

l  public void write(int b)

l  public void write(byte[] b)

l  public void write(byte[] b,int off,int len)

package com.core.io.demo1;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test2 {
	public static void main(String[] args) throws IOException {
		//  public void write(int b)
		//  public void write(byte[] b)
		//  public void write(byte[] b,int off,int len)

		FileOutputStream fos = new FileOutputStream("fos2.txt");
		//public void write(int b)
		fos.write(97);
		fos.write(98);
//		public void write(byte[] b)
		byte[] bs = {97,98,99,100,101,102};
		fos.write(bs);
		
		fos.write(bs, 2, 2);//c,d
		fos.close();
		
		//文件内容：ababcdefcd
	}
}

D.FileOutputStream换行和追加写入

package com.core.io.demo1;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test3 {
	public static void main(String[] args) throws IOException {
		// Mac:\r
		// Linux:\n
		// Windows:\r\n
		//追加写入
		FileOutputStream fos = new FileOutputStream("fos3.txt",true);
		
		//换行
		for (int i = 0; i < 20; i++) {
			fos.write(("hello io "+i).getBytes());
			fos.write("\r\n".getBytes());
		}
		fos.close();
	}
}

E.FileOutputStream写出数据加入异常处理

package com.core.io.demo1;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test4 {
	// FileOutputStream写出数据加入异常处理
	public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("fos4.txt", true);
			fos.write("FileOutputStream写出数据加入异常处理".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}finally{
					fos = null;
				}
			}
		}
	}
}

F.FileInputStream读取数据

package com.core.io.demo2;

import java.io.FileInputStream;
import java.io.IOException;

public class Test {

	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("fos3.txt");
		int by = 0;
		while ((by = fis.read()) != -1) {
			System.out.print((char) by);
		}
		fis.close();
		// 注意：当文件中有汉字则出现了问题(乱码)。现在不行。因为每个字节都转成了char、
	}

}

G.字节流复制文本文件案例——一次一个字节的复制

package com.core.io.demo2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test2 {
	// 文件复制
	public static void main(String[] args) throws IOException {
		String s1 = "abcde";
		System.out.println(Arrays.toString(s1.getBytes()));
		// [97, 98, 99, 100, 101]
		String s2 = "我爱中国";
		System.out.println(Arrays.toString(s2.getBytes()));
		// [-50, -46, -80, -82, -42, -48, -71, -6]

		FileInputStream fis = new FileInputStream("a.java");
		FileOutputStream fos = new FileOutputStream("b.java");
		
		int by =0;
		while((by = fis.read())!=-1){
			fos.write(by);
		}
		
		fis.close();
		fos.close();
	}

}

H.FileInputStream读取数据一次一个字节数组

package com.core.io.demo2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test3 {
	// 文件复制-一次复制一个字节数组
	public static void main(String[] args) throws IOException {

		FileInputStream fis = new FileInputStream("a.java");
		FileOutputStream fos = new FileOutputStream("c.java");
		
		int len = 0;
		byte[] bys = new byte[1024];
		while((len = fis.read(bys))!=-1){
			// String str = new String(bys, 0, len);
			// System.out.println(str);
			fos.write(bys, 0, len);
		}
		
		fis.close();
		fos.close();
	}

}

I .BufferedOutputStream写出数据 && BufferedInputStream读取数据

l  字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流

l  字节缓冲输出流

•    BufferedOutputStream

l  字节缓冲输入流

•    BufferedInputStream

package com.core.io.demo2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test4 {
	// 文件复制-使用高效缓存流
	public static void main(String[] args) throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"a.java"));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("d.java"));
		int len = 0;
		byte[] bys = new byte[1024];
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bis.close();
		bos.close();
	}

}

K.字节流四种方式复制MP4并测试效率

package com.core.io.demo2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

//字节流一次读取一个字节耗时：12264
//字节流一次读取一个字节数组耗时：16
//高效字节流一次读取一个字节：43
//高效字节流一次读取一个字节数组：5

public class Test5 {
	// 文件复制-字节流四种方式复制MP4并测试效率
	public static void main(String[] args) throws IOException {
		method_1();
		method_2();
		method_3();
		method_4();
	}

	/**
	 * 高效字节流一次读取一个字节数组
	 * 
	 * @throws IOException
	 */
	private static void method_4() throws IOException {
		long begin = System.currentTimeMillis();
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"d:\\a.avi"));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("e:\\m4.avi"));
		int len = 0;
		byte[] bys = new byte[1024];
		while((len = bis.read(bys))!=-1){
			bos.write(bys, 0, len);
		}
		
		bis.close();
		bos.close();
		long end = System.currentTimeMillis();
		System.out.println("高效字节流一次读取一个字节数组：" + (end - begin));
	}

	/**
	 * 高效字节流一次读取一个字节
	 * 
	 * @throws IOException
	 */
	private static void method_3() throws IOException {
		long begin = System.currentTimeMillis();
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"d:\\a.avi"));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("e:\\m3.avi"));
		int by = 0;
		while ((by = bis.read()) != -1) {
			bos.write(by);
		}

		bis.close();
		bos.close();
		long end = System.currentTimeMillis();
		System.out.println("高效字节流一次读取一个字节：" + (end - begin));
	}

	/**
	 * 字节流一次读取一个字节数组
	 * 
	 * @throws IOException
	 */
	private static void method_2() throws IOException {
		long begin = System.currentTimeMillis();
		FileInputStream fis = new FileInputStream("d:\\a.avi");
		FileOutputStream fos = new FileOutputStream("e:\\m2.avi");

		int len = 0;
		byte[] bys = new byte[1024];
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}
		fis.close();
		fos.close();
		long end = System.currentTimeMillis();
		System.out.println("字节流一次读取一个字节数组耗时：" + (end - begin));
	}

	/**
	 * 字节流一次读取一个字节
	 * 
	 * @throws IOException
	 */
	private static void method_1() throws IOException {
		long begin = System.currentTimeMillis();
		FileInputStream fis = new FileInputStream("d:\\a.avi");
		FileOutputStream fos = new FileOutputStream("e:\\m1.avi");
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}
		fis.close();
		fos.close();
		long end = System.currentTimeMillis();
		System.out.println("字节流一次读取一个字节耗时：" + (end - begin));
	}

}