传智播客-Java学习笔记day20
2017-07-31 17:11
435 查看
1.递归概述和注意事项
递归：方法定义中调用方法本身的现象
方法的嵌套调用，这不是递归。
Math.max(Math.max(a,b),c);
public void show(int n) {
if(n <= 0) {
System.exit(0);
}
System.out.println(n);
show(--n);
}
注意事项：
A:递归一定要有出口，否则就是死递归
B:递归的次数不能太多，否则就内存溢出
C:构造方法不能递归使用
举例：
A:从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
...
庙挂了,或者山崩了
2.递归求阶乘的代码实现及内存图解
需求：请用代码实现求5的阶乘。
下面的知识要知道：
5! = 1*2*3*4*5
5! = 5*4!
有几种方案实现呢?
A:循环实现
B:递归实现
a:做递归要写一个方法
b:出口条件
c:规律
public static void main(String[] args) {
int jc = 1;
for (int x = 2; x <= 5; x++) {
jc *= x;
}
System.out.println("5的阶乘是：" + jc);
System.out.println("5的阶乘是："+jieCheng(5));
}
/*
* 做递归要写一个方法:
* 返回值类型：int
* 参数列表：int n
* 出口条件:
* if(n == 1) {return 1;}
* 规律:
* if(n != 1) {return n*方法名(n-1);}
*/
public static int jieCheng(int n){
if(n==1){
return 1;
}else {
return n*jieCheng(n-1);
}
}
递归求阶乘的代码实现及内存图解
debug
3.兔子-斐波那契
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
递归实现
假如相邻的两个月的兔子对数是a,b
* 第一个相邻的数据：a=1,b=1
* 第二个相邻的数据：a=1,b=2
* 第三个相邻的数据：a=2,b=3
* 第四个相邻的数据：a=3,b=5
* 看到了：下一次的a是以前的b，下一次是以前的a+b
/*
* 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每一个月是前两个月之和
*/
public static int fib(int n) {
if (n == 1 || n == 2) { //出口条件
return 1;
} else {
return fib(n - 1) + fib(n - 2);//规律
}
}
写递归考虑两步：1.出口条件(if……)
2.寻找规律
4.一个递归案例(File)--递归输出指定目录下所有的java文件的绝对路径案例
import java.io.File;
/*
* 需求：请大家把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。
*
* 分析：
* A:封装目录
* B:获取该目录下所有的文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：继续判断是否以.java结尾
* 是：就输出该文件的绝对路径
* 否：不搭理它
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("E:\\JavaSE");
// 递归功能实现
getAllJavaFilePaths(srcFolder);
}
private static void getAllJavaFilePaths(File srcFolder) {
// 获取该目录下所有的文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
getAllJavaFilePaths(file);
} else {
// 继续判断是否以.java结尾
if (file.getName().endsWith(".java")) {
// 就输出该文件的绝对路径
System.out.println(file.getAbsolutePath());
}
}
}
}
}
注意：注意file的isDirectory()方法和getAbsolutePath()方法
===========================
本人据此模仿了一个
import java.io.File;
/*
* 获取G:\\迅雷下载分区中所有以.java为后缀的文件
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装文件目录
File srcFolder = new File("G:\\迅雷下载分区");
getJavaFilePaths(srcFolder);
}
private static void getJavaFilePaths(File srcFolder) {
// 获取file数组
File[] fileArray = srcFolder.listFiles();
// 遍历file对象
for (File f : fileArray) {
// 判断是否为文件夹
if (f.isDirectory()) {
getJavaFilePaths(f);
} else {
if (f.getName().endsWith(".java")) {
System.out.println(new File(srcFolder, f.getName()));
// System.out.println(f.getAbsolutePath());
}
}
}
}
}
==============================
运行示例
5. 递归案例---递归删除带内容的目录
import java.io.File;
/*
* 需求：递归删除带内容的目录
*
* 目录我已经给定：demo
*
* 分析：
* A:封装目录
* B:获取该目录下的所有文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：就删除
*/
public class FileDeleteDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("demo");
// 递归实现
deleteFolder(srcFolder);
}
private static void deleteFolder(File srcFolder) {
// 获取该目录下的所有文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
deleteFolder(file);
} else {
System.out.println(file.getName() + "---" + file.delete());
}
System.out.println(srcFolder.getName() + "---" + srcFolder.delete());//没有这一句，删不了文件夹
}
}
}
6.IO流概述及分类
IO流的分类
如何判断使用字节流还是字符流呢？
用记事本打开判断，能读懂就可以用字符流，读不懂就可以用字节流
打开一个图片文件
打开一个java文件
7.IO流基类概述
IO流的分类：
* 流向：
* 输入流 读取数据
* 输出流 写出数据
* 数据类型：
* 字节流
* 字节输入流 读取数据 InputStream
* 字节输出流 写出数据 OutputStream
* 字符流
* 字符输入流 读取数据 Reader
* 字符输出流 写出数据 Writer
*
* 注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
InputStream:此抽象类是表示字节输入流的所有类的超类。
OutputStream:此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
Reader:用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
Writer:写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
8.FileOutputStream的构造方法
FileOutputStream的构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
几个注意问题：
需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
* A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
* B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
* XxxOutputStream
* XxxInputStream
* XxxReader
* XxxWriter
留意以下代码
创建字节输出流对象
//FileOutputStream(File file)
File file = new File("fos.txt");
FileOutputStream fos = new FileOutputStream(file);
//FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");//这一句等价于上面的两句
原因如下
FileOutputStream(String name)这个构造方法虽然传的是字符串，但是底层实现实际上帮你封装了文件目录
因此这个构造方法可以实现
File file = new File("fos.txt");
FileOutputStream fos = new FileOutputStream(file);
这两行的功能
接着
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
* 创建字节输出流对象了做了几件事情：
* A:调用系统功能去创建文件(即使这个文件不存在，也会创建一个新的)
* B:创建fos对象
* C:把fos对象指向这个文件
*/
//写数据
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());//getBytes()是String类的一个方法，返回值是byte[ ]
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
/*
* 为什么一定要close()呢?
* A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
* B:通知系统去释放跟该文件相关的资源//这句话非常重要
*/
//java.io.IOException: Stream Closed//流关闭了就不可以读写数据了
//fos.write("java".getBytes());
总结：字节输出流操作步骤：
A:创建字节输出流对象
B:写数据
C:释放资源
9.FileOutputStream的三个write()方法
public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// OutputStream os = new FileOutputStream("fos2.txt"); // 多态
FileOutputStream fos = new FileOutputStream("fos2.txt");
// 调用write()方法
//fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a
// fos.write(57);//输出9
// fos.write(55);//输出7
//public void write(byte[] b):写一个字节数组
byte[] bys={97,98,99,100,101};//输出abcde
fos.write(bys);
//public void write(byte[] b,int off,int len):写一个字节数组的一部分
fos.write(bys,1,3);//输出bcd
//释放资源
fos.close();
}
10.FileOutputStream写出数据实现换行和追加写入
如何实现数据的换行?
代码
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("fos3.txt");
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\n".getBytes());
}
// 释放资源
fos.close();
}
如果没有这一句 fos.write("\n".getBytes()); 就不能换行
为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
如何实现呢?写入换行符号即可呗。
fos.write("\n".getBytes()); 加上这一句
运行如下
用notepad++打开
用windows自带的记事本打开
刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
因为不同的系统针对不同的换行符号识别是不一样的?
windows:\r\n
linux:\n
Mac:\r
而一些常见的个高级记事本，是可以识别任意换行符号的。
因此，在windows下，只能改写
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\r\n".getBytes());
}
再次用windows记事本打开
OK
然而还有一个问题，以上的每次运行程序(无论运行多少次)，只会重新写进10行hello(也就是永远只有10行hello)，而不会在后面追加数据。
来看看API
查看第2个
如何实现数据的追加写入?
用构造方法带第二个参数是true的情况即可
FileOutputStream fos = new FileOutputStream("fos3.txt", true);
运行效果如下(运行两次)
11.FileOutputStream写出数据加入异常处理
代码不再用throws来处理，如果用try……catch处理的话
效果如下
很明显，代码太累赘，不好看
改进一下
一起做异常处理
try {
FileOutputStream fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
fos.close();位置不太对，因此再改进(还进行了几处修改)
// 改进版
// 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
FileOutputStream fos = null;
try {
// fos = new FileOutputStream("z:\\fos4.txt");//这是测试代码，为了验证空指针异常
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果fos不是null，才需要close()
if (fos != null) {
// 为了保证close()一定会执行，就放到这里了
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
解析一下
加finally 是为了保证fos.close()的正常执行；
FileOutputStream fos = null 这语句是为了初始化，否则finally语句的fos对象识别不了。
if (fos != null) {}这个if语句是为了防止创建文件不成功而抛出空指针异常
最终代码就是(try……catch有嵌套，第二个try……catch还嵌套有if语句)
public static void main(String[] args) {
// 改进版
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
写了这么多，最后输出的是：java
12.FileInputStream读取数据
字节输入流操作步骤：
A:创建字节输入流对象
B:调用read()方法读取数据，并把数据显示在控制台
C:释放资源
读取数据的方式：
A:int read():一次读取一个字节
B:int read(byte[] b):一次读取一个字节数组
=======================================
// 调用read()方法读取数据，并把数据显示在控制台
// // 第一次读取
// int by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
//
// // 第二次读取
// by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
========================================
当文件数据读完的时候，返回值统一变为-1
也就是说，如果你读取的数据是-1，就说明已经读取到文件的末尾了。
// 用循环改进
// int by = fis.read();
// while (by != -1) {
// System.out.print((char) by);
// by = fis.read();
// }
=================分割线=======================
// 最终版代码
int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
// 释放资源
fis.close();
=============分割线===========================
上面的代码解析一下，用print而不用println的原因是避免人为的引入换行符
13.字节流复制文本文件案例1
举例：
数据源：从哪里来
a.txt -- 读取数据 -- FileInputStream
目的地：到哪里去
b.txt -- 写数据 -- FileOutputStream
注意：读文件的话，那个文件一定要存在
把数据写入文件的话，那个文件可以不存在(自动创建)
也就是说，a.txt一定要先前存在，而b.txt不一定先前存在，可以在运行时期再创建
这一次复制中文没有出现任何问题，为什么呢?
上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
上一次 int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。它会自己做转换。
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("b.txt");
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源(先关谁都行)
fos.close();
fis.close();
}
补充：计算机是如何识别什么时候该把两个字节转换为一个中文呢?
一个小demo
import java.util.Arrays;
/*
* 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
* 在计算机中中文的存储分两个字节：
* 第一个字节肯定是负数。
* 第二个字节常见的是负数，可能有正数。但是没影响。
*/
public class StringDemo {
public static void main(String[] args) {
// String s = "abcde";
// // [97, 98, 99, 100, 101]
String s = "我爱你中国";
// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
}
}
也就是说，我爱你中国--------
"我"对应[-50,-46],
"爱"对应[-80,-82]
"你"对应[-60,-29]，
"中"对应[-42,-28]
"国"对应[-71,-6]
也就是说，如果是中文的话，第一个字节都是负数，第二个有可能是正的有可能是负的，但不影响，反正第一个是负的就拼接两个字节
14.字节流复制文本文件案例2
需求：把c盘下的a.txt的内容复制到d盘下的b.txt中
数据源：
c:\\a.txt -- 读取数据-- FileInputStream
目的地：
d:\\b.txt -- 写出数据 -- FileOutputStream
=================================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("c:\\a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("d:\\b.txt");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
=================================================
15.字节流复制图片案例
需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
数据源：
e:\\林青霞.jpg --读取数据--FileInputStream
目的地：
mn.jpg--写出数据--FileOutputStream
=====================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
// 封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
==========================================
16.字节流复制视频案例1(复制速度非常，非常的慢，一个一个字节复制)
需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
数据源：
e:\\哥有老婆.mp4--读取数据--FileInputStream
目的地：
copy.mp4--写出数据--FileOutputStream
=========================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
// 封装目的地
FileOutputStream fos = new FileOutputStream("copy.mp4");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
======================================
17.FileInputStream读取数据一次一个字节数组
一次读取一个字节数组：int read(byte[] b)
下图
FileInputStream的read方法
再附上：InputStream的read方法
创建字节输入流对象
FileInputStream fis = new FileInputStream("fis2.txt");
fis2.txt里面的内容(注意java后面没有换行符了)
// 读取数据
再进行第3,次第4次的读取
发现有如下的疑问
原因
(上图(\nj)b……的b去掉，为多余)
为防止上面的问题，可以采取如下方法
输出
因此，最终版代码
==================分割线==================
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
// 最终版代码
// 数组的长度一般是1024或者1024的整数倍
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));//print不要写成println
}
// 释放资源
fis.close();
===============分割线========================
注意：一定要用new String(bys,0,length); 而不能用new String(bys)!
byte[] bys = new byte[1024]; 这个数组默认的值都为0
len的值为实际读取的字节数(如果是-1意味着到结尾了)
18.FileInputStream读取数据的两种方式比较图解
一次读取一个字节数组---每次可以读取多个数据，提高了操作效率
19.BufferedOutputStream写出数据
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类(高效类)
写数据：BufferedOutputStream
读数据：BufferedInputStream
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
// 写数据
bos.write("hello".getBytes());
// 释放资源,注意，并不需要fos.close( );
bos.close();
}
======================================
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
20.BufferedInputStream读取数据
注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"bos.txt"));
// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 释放资源
bis.close();
}
21.字节流四种方式复制MP4并测试效率
需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
字节流四种方式复制文件
基本字节流一次读写一个字节
基本字节流一次读写一个字节数组
高效字节流一次读写一个字节
高效字节流一次读写一个字节数组
=================分割线==========================
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
//中间4个方法一个一个测试并注释掉其它的方法
// method1("e:\\哥有老婆.mp4", "copy1.mp4");
// method2("e:\\哥有老婆.mp4", "copy2.mp4");
// method3("e:\\哥有老婆.mp4", "copy3.mp4");
method4("e:\\哥有老婆.mp4", "copy4.mp4");
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
// 高效字节流一次读写一个字节数组：
public static void method4(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
// 高效字节流一次读写一个字节：
public static void method3(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}
// 基本字节流一次读写一个字节数组
public static void method2(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}
// 基本字节流一次读写一个字节
public static void method1(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
====================分割线==================
字节流四种方式复制文件运行结果：
* 基本字节流一次读写一个字节： 共耗时：117235毫秒
* 基本字节流一次读写一个字节数组： 共耗时：156毫秒
* 高效字节流一次读写一个字节： 共耗时：1141毫秒
* 高效字节流一次读写一个字节数组： 共耗时：47毫秒
22.仿照上一个案例
本人模仿了一个
下面是用于测试的文件f4v(9.14M)
代码如下
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：把f:\\测试视频.f4v复制到当前项目目录下的copy.f4v中
*
* 字节流四种方式复制文件：
* 基本字节流一次读写一个字节
* 基本字节流一次读写一个字节数组
* 高效字节流一次读写一个字节
* 高效字节流一次读写一个字节数组
*/
public class CopyF4VDemo {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
//method1("f:\\测试视频.f4v", "copy1.f4v");
//method2("f:\\测试视频.f4v", "copy2.f4v");
//method3("f:\\测试视频.f4v", "copy3.f4v");
method4("f:\\测试视频.f4v", "copy4.f4v");
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
public static void method4(String srcStirng, String desString) throws IOException {
// 高效字节流一次读写一个字节数组：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcStirng));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
int len = 0;
byte[] bys = new byte[1024];
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bis.close();
bos.close();
}
public static void method3(String srcStirng, String desString) throws IOException {
// 高效字节流一次读写一个字节：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcStirng));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bis.close();
bos.close();
}
public static void method2(String srcStirng, String desString) throws IOException {
// 基本字节流一次读写一个字节数组：
FileInputStream fis = new FileInputStream(srcStirng);
FileOutputStream fos = new FileOutputStream(desString);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fis.close();
fos.close();
}
public static void method1(String srcStirng, String desString) throws IOException {
// 基本字节流一次读写一个字节：
FileInputStream fis = new FileInputStream(srcStirng);
FileOutputStream fos = new FileOutputStream(desString);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fis.close();
fos.close();
}
}
=====================================
运行截图(逐个运行)
项目路径下(E:\eclipse\workspace\day20_IO)有新复制的文件
总结：
字节流四种方式复制文件：
基本字节流一次读写一个字节： 共耗时：27348毫秒
基本字节流一次读写一个字节数组：共耗时：121毫秒
高效字节流一次读写一个字节： 共耗时：361毫秒
高效字节流一次读写一个字节数组： 共耗时：14毫秒
day20笔记补充
IO流分类
字节流：
InputStream
FileInputStream
BufferedInputStream
OutputStream
FileOutputStream
BufferedOutputStream
字符流：
Reader
FileReader
BufferedReader
Writer
FileWriter
BufferedWriter
递归：方法定义中调用方法本身的现象
方法的嵌套调用，这不是递归。
Math.max(Math.max(a,b),c);
public void show(int n) {
if(n <= 0) {
System.exit(0);
}
System.out.println(n);
show(--n);
}
注意事项：
A:递归一定要有出口，否则就是死递归
B:递归的次数不能太多，否则就内存溢出
C:构造方法不能递归使用
举例：
A:从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
从前有座山，山里有座庙，庙里有个老和尚和小和尚，老和尚在给小和尚讲故事，故事是：
...
庙挂了,或者山崩了
2.递归求阶乘的代码实现及内存图解
需求：请用代码实现求5的阶乘。
下面的知识要知道：
5! = 1*2*3*4*5
5! = 5*4!
有几种方案实现呢?
A:循环实现
B:递归实现
a:做递归要写一个方法
b:出口条件
c:规律
public static void main(String[] args) {
int jc = 1;
for (int x = 2; x <= 5; x++) {
jc *= x;
}
System.out.println("5的阶乘是：" + jc);
System.out.println("5的阶乘是："+jieCheng(5));
}
/*
* 做递归要写一个方法:
* 返回值类型：int
* 参数列表：int n
* 出口条件:
* if(n == 1) {return 1;}
* 规律:
* if(n != 1) {return n*方法名(n-1);}
*/
public static int jieCheng(int n){
if(n==1){
return 1;
}else {
return n*jieCheng(n-1);
}
}
递归求阶乘的代码实现及内存图解
debug
3.兔子-斐波那契
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
递归实现
假如相邻的两个月的兔子对数是a,b
* 第一个相邻的数据：a=1,b=1
* 第二个相邻的数据：a=1,b=2
* 第三个相邻的数据：a=2,b=3
* 第四个相邻的数据：a=3,b=5
* 看到了：下一次的a是以前的b，下一次是以前的a+b
/*
* 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每一个月是前两个月之和
*/
public static int fib(int n) {
if (n == 1 || n == 2) { //出口条件
return 1;
} else {
return fib(n - 1) + fib(n - 2);//规律
}
}
写递归考虑两步：1.出口条件(if……)
2.寻找规律
4.一个递归案例(File)--递归输出指定目录下所有的java文件的绝对路径案例
import java.io.File;
/*
* 需求：请大家把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。
*
* 分析：
* A:封装目录
* B:获取该目录下所有的文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：继续判断是否以.java结尾
* 是：就输出该文件的绝对路径
* 否：不搭理它
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("E:\\JavaSE");
// 递归功能实现
getAllJavaFilePaths(srcFolder);
}
private static void getAllJavaFilePaths(File srcFolder) {
// 获取该目录下所有的文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
getAllJavaFilePaths(file);
} else {
// 继续判断是否以.java结尾
if (file.getName().endsWith(".java")) {
// 就输出该文件的绝对路径
System.out.println(file.getAbsolutePath());
}
}
}
}
}
注意：注意file的isDirectory()方法和getAbsolutePath()方法
===========================
本人据此模仿了一个
import java.io.File;
/*
* 获取G:\\迅雷下载分区中所有以.java为后缀的文件
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装文件目录
File srcFolder = new File("G:\\迅雷下载分区");
getJavaFilePaths(srcFolder);
}
private static void getJavaFilePaths(File srcFolder) {
// 获取file数组
File[] fileArray = srcFolder.listFiles();
// 遍历file对象
for (File f : fileArray) {
// 判断是否为文件夹
if (f.isDirectory()) {
getJavaFilePaths(f);
} else {
if (f.getName().endsWith(".java")) {
System.out.println(new File(srcFolder, f.getName()));
// System.out.println(f.getAbsolutePath());
}
}
}
}
}
==============================
运行示例
5. 递归案例---递归删除带内容的目录
import java.io.File;
/*
* 需求：递归删除带内容的目录
*
* 目录我已经给定：demo
*
* 分析：
* A:封装目录
* B:获取该目录下的所有文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：就删除
*/
public class FileDeleteDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("demo");
// 递归实现
deleteFolder(srcFolder);
}
private static void deleteFolder(File srcFolder) {
// 获取该目录下的所有文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
deleteFolder(file);
} else {
System.out.println(file.getName() + "---" + file.delete());
}
System.out.println(srcFolder.getName() + "---" + srcFolder.delete());//没有这一句，删不了文件夹
}
}
}
6.IO流概述及分类
IO流的分类
如何判断使用字节流还是字符流呢？
用记事本打开判断，能读懂就可以用字符流，读不懂就可以用字节流
打开一个图片文件
打开一个java文件
7.IO流基类概述
IO流的分类：
* 流向：
* 输入流 读取数据
* 输出流 写出数据
* 数据类型：
* 字节流
* 字节输入流 读取数据 InputStream
* 字节输出流 写出数据 OutputStream
* 字符流
* 字符输入流 读取数据 Reader
* 字符输出流 写出数据 Writer
*
* 注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
InputStream:此抽象类是表示字节输入流的所有类的超类。
OutputStream:此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
Reader:用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
Writer:写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
8.FileOutputStream的构造方法
FileOutputStream的构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
几个注意问题：
需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
* A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
* B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
* XxxOutputStream
* XxxInputStream
* XxxReader
* XxxWriter
留意以下代码
创建字节输出流对象
//FileOutputStream(File file)
File file = new File("fos.txt");
FileOutputStream fos = new FileOutputStream(file);
//FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");//这一句等价于上面的两句
原因如下
FileOutputStream(String name)这个构造方法虽然传的是字符串，但是底层实现实际上帮你封装了文件目录
因此这个构造方法可以实现
File file = new File("fos.txt");
FileOutputStream fos = new FileOutputStream(file);
这两行的功能
接着
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
* 创建字节输出流对象了做了几件事情：
* A:调用系统功能去创建文件(即使这个文件不存在，也会创建一个新的)
* B:创建fos对象
* C:把fos对象指向这个文件
*/
//写数据
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());//getBytes()是String类的一个方法，返回值是byte[ ]
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
/*
* 为什么一定要close()呢?
* A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
* B:通知系统去释放跟该文件相关的资源//这句话非常重要
*/
//java.io.IOException: Stream Closed//流关闭了就不可以读写数据了
//fos.write("java".getBytes());
总结：字节输出流操作步骤：
A:创建字节输出流对象
B:写数据
C:释放资源
9.FileOutputStream的三个write()方法
public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// OutputStream os = new FileOutputStream("fos2.txt"); // 多态
FileOutputStream fos = new FileOutputStream("fos2.txt");
// 调用write()方法
//fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a
// fos.write(57);//输出9
// fos.write(55);//输出7
//public void write(byte[] b):写一个字节数组
byte[] bys={97,98,99,100,101};//输出abcde
fos.write(bys);
//public void write(byte[] b,int off,int len):写一个字节数组的一部分
fos.write(bys,1,3);//输出bcd
//释放资源
fos.close();
}
10.FileOutputStream写出数据实现换行和追加写入
如何实现数据的换行?
代码
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("fos3.txt");
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\n".getBytes());
}
// 释放资源
fos.close();
}
如果没有这一句 fos.write("\n".getBytes()); 就不能换行
为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
如何实现呢?写入换行符号即可呗。
fos.write("\n".getBytes()); 加上这一句
运行如下
用notepad++打开
用windows自带的记事本打开
刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
因为不同的系统针对不同的换行符号识别是不一样的?
windows:\r\n
linux:\n
Mac:\r
而一些常见的个高级记事本，是可以识别任意换行符号的。
因此，在windows下，只能改写
// 写数据
for (int x = 0; x < 10; x++) {
fos.write(("hello" + x).getBytes());
fos.write("\r\n".getBytes());
}
再次用windows记事本打开
OK
然而还有一个问题，以上的每次运行程序(无论运行多少次)，只会重新写进10行hello(也就是永远只有10行hello)，而不会在后面追加数据。
来看看API
查看第2个
如何实现数据的追加写入?
用构造方法带第二个参数是true的情况即可
FileOutputStream fos = new FileOutputStream("fos3.txt", true);
运行效果如下(运行两次)
11.FileOutputStream写出数据加入异常处理
代码不再用throws来处理，如果用try……catch处理的话
效果如下
很明显，代码太累赘，不好看
改进一下
一起做异常处理
try {
FileOutputStream fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
fos.close();位置不太对，因此再改进(还进行了几处修改)
// 改进版
// 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
FileOutputStream fos = null;
try {
// fos = new FileOutputStream("z:\\fos4.txt");//这是测试代码，为了验证空指针异常
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果fos不是null，才需要close()
if (fos != null) {
// 为了保证close()一定会执行，就放到这里了
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
解析一下
加finally 是为了保证fos.close()的正常执行；
FileOutputStream fos = null 这语句是为了初始化，否则finally语句的fos对象识别不了。
if (fos != null) {}这个if语句是为了防止创建文件不成功而抛出空指针异常
最终代码就是(try……catch有嵌套，第二个try……catch还嵌套有if语句)
public static void main(String[] args) {
// 改进版
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
写了这么多，最后输出的是：java
12.FileInputStream读取数据
字节输入流操作步骤：
A:创建字节输入流对象
B:调用read()方法读取数据，并把数据显示在控制台
C:释放资源
读取数据的方式：
A:int read():一次读取一个字节
B:int read(byte[] b):一次读取一个字节数组
=======================================
// 调用read()方法读取数据，并把数据显示在控制台
// // 第一次读取
// int by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
//
// // 第二次读取
// by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
========================================
当文件数据读完的时候，返回值统一变为-1
也就是说，如果你读取的数据是-1，就说明已经读取到文件的末尾了。
// 用循环改进
// int by = fis.read();
// while (by != -1) {
// System.out.print((char) by);
// by = fis.read();
// }
=================分割线=======================
// 最终版代码
int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
// 释放资源
fis.close();
=============分割线===========================
上面的代码解析一下，用print而不用println的原因是避免人为的引入换行符
13.字节流复制文本文件案例1
举例：
数据源：从哪里来
a.txt -- 读取数据 -- FileInputStream
目的地：到哪里去
b.txt -- 写数据 -- FileOutputStream
注意：读文件的话，那个文件一定要存在
把数据写入文件的话，那个文件可以不存在(自动创建)
也就是说，a.txt一定要先前存在，而b.txt不一定先前存在，可以在运行时期再创建
这一次复制中文没有出现任何问题，为什么呢?
上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
上一次 int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。它会自己做转换。
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("b.txt");
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源(先关谁都行)
fos.close();
fis.close();
}
补充：计算机是如何识别什么时候该把两个字节转换为一个中文呢?
一个小demo
import java.util.Arrays;
/*
* 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
* 在计算机中中文的存储分两个字节：
* 第一个字节肯定是负数。
* 第二个字节常见的是负数，可能有正数。但是没影响。
*/
public class StringDemo {
public static void main(String[] args) {
// String s = "abcde";
// // [97, 98, 99, 100, 101]
String s = "我爱你中国";
// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
}
}
也就是说，我爱你中国--------
"我"对应[-50,-46],
"爱"对应[-80,-82]
"你"对应[-60,-29]，
"中"对应[-42,-28]
"国"对应[-71,-6]
也就是说，如果是中文的话，第一个字节都是负数，第二个有可能是正的有可能是负的，但不影响，反正第一个是负的就拼接两个字节
14.字节流复制文本文件案例2
需求：把c盘下的a.txt的内容复制到d盘下的b.txt中
数据源：
c:\\a.txt -- 读取数据-- FileInputStream
目的地：
d:\\b.txt -- 写出数据 -- FileOutputStream
=================================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("c:\\a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("d:\\b.txt");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
=================================================
15.字节流复制图片案例
需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
数据源：
e:\\林青霞.jpg --读取数据--FileInputStream
目的地：
mn.jpg--写出数据--FileOutputStream
=====================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
// 封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
==========================================
16.字节流复制视频案例1(复制速度非常，非常的慢，一个一个字节复制)
需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
数据源：
e:\\哥有老婆.mp4--读取数据--FileInputStream
目的地：
copy.mp4--写出数据--FileOutputStream
=========================================
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
// 封装目的地
FileOutputStream fos = new FileOutputStream("copy.mp4");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
======================================
17.FileInputStream读取数据一次一个字节数组
一次读取一个字节数组：int read(byte[] b)
下图
FileInputStream的read方法
再附上：InputStream的read方法
创建字节输入流对象
FileInputStream fis = new FileInputStream("fis2.txt");
fis2.txt里面的内容(注意java后面没有换行符了)
// 读取数据
再进行第3,次第4次的读取
发现有如下的疑问
原因
(上图(\nj)b……的b去掉，为多余)
为防止上面的问题，可以采取如下方法
输出
因此，最终版代码
==================分割线==================
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
// 最终版代码
// 数组的长度一般是1024或者1024的整数倍
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));//print不要写成println
}
// 释放资源
fis.close();
===============分割线========================
注意：一定要用new String(bys,0,length); 而不能用new String(bys)!
byte[] bys = new byte[1024]; 这个数组默认的值都为0
len的值为实际读取的字节数(如果是-1意味着到结尾了)
18.FileInputStream读取数据的两种方式比较图解
一次读取一个字节数组---每次可以读取多个数据，提高了操作效率
19.BufferedOutputStream写出数据
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类(高效类)
写数据：BufferedOutputStream
读数据：BufferedInputStream
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
// 写数据
bos.write("hello".getBytes());
// 释放资源,注意，并不需要fos.close( );
bos.close();
}
======================================
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
20.BufferedInputStream读取数据
注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"bos.txt"));
// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 释放资源
bis.close();
}
21.字节流四种方式复制MP4并测试效率
需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
字节流四种方式复制文件
基本字节流一次读写一个字节
基本字节流一次读写一个字节数组
高效字节流一次读写一个字节
高效字节流一次读写一个字节数组
=================分割线==========================
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
//中间4个方法一个一个测试并注释掉其它的方法
// method1("e:\\哥有老婆.mp4", "copy1.mp4");
// method2("e:\\哥有老婆.mp4", "copy2.mp4");
// method3("e:\\哥有老婆.mp4", "copy3.mp4");
method4("e:\\哥有老婆.mp4", "copy4.mp4");
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
// 高效字节流一次读写一个字节数组：
public static void method4(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
// 高效字节流一次读写一个字节：
public static void method3(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}
// 基本字节流一次读写一个字节数组
public static void method2(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}
// 基本字节流一次读写一个字节
public static void method1(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
====================分割线==================
字节流四种方式复制文件运行结果：
* 基本字节流一次读写一个字节： 共耗时：117235毫秒
* 基本字节流一次读写一个字节数组： 共耗时：156毫秒
* 高效字节流一次读写一个字节： 共耗时：1141毫秒
* 高效字节流一次读写一个字节数组： 共耗时：47毫秒
22.仿照上一个案例
本人模仿了一个
下面是用于测试的文件f4v(9.14M)
代码如下
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：把f:\\测试视频.f4v复制到当前项目目录下的copy.f4v中
*
* 字节流四种方式复制文件：
* 基本字节流一次读写一个字节
* 基本字节流一次读写一个字节数组
* 高效字节流一次读写一个字节
* 高效字节流一次读写一个字节数组
*/
public class CopyF4VDemo {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
//method1("f:\\测试视频.f4v", "copy1.f4v");
//method2("f:\\测试视频.f4v", "copy2.f4v");
//method3("f:\\测试视频.f4v", "copy3.f4v");
method4("f:\\测试视频.f4v", "copy4.f4v");
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
public static void method4(String srcStirng, String desString) throws IOException {
// 高效字节流一次读写一个字节数组：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcStirng));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
int len = 0;
byte[] bys = new byte[1024];
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bis.close();
bos.close();
}
public static void method3(String srcStirng, String desString) throws IOException {
// 高效字节流一次读写一个字节：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcStirng));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bis.close();
bos.close();
}
public static void method2(String srcStirng, String desString) throws IOException {
// 基本字节流一次读写一个字节数组：
FileInputStream fis = new FileInputStream(srcStirng);
FileOutputStream fos = new FileOutputStream(desString);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fis.close();
fos.close();
}
public static void method1(String srcStirng, String desString) throws IOException {
// 基本字节流一次读写一个字节：
FileInputStream fis = new FileInputStream(srcStirng);
FileOutputStream fos = new FileOutputStream(desString);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fis.close();
fos.close();
}
}
=====================================
运行截图(逐个运行)
项目路径下(E:\eclipse\workspace\day20_IO)有新复制的文件
总结：
字节流四种方式复制文件：
基本字节流一次读写一个字节： 共耗时：27348毫秒
基本字节流一次读写一个字节数组：共耗时：121毫秒
高效字节流一次读写一个字节： 共耗时：361毫秒
高效字节流一次读写一个字节数组： 共耗时：14毫秒
day20笔记补充
IO流分类
字节流：
InputStream
FileInputStream
BufferedInputStream
OutputStream
FileOutputStream
BufferedOutputStream
字符流：
Reader
FileReader
BufferedReader
Writer
FileWriter
BufferedWriter
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- {传智播客} (学习笔记)--Java调用存储过程实现Oracle数据库分页
- 传智播客JAVA培训struts2学习笔记一
- 传智播客-Java学习笔记day21
- 传智播客-Java学习笔记day25
- 传智播客-Java学习笔记day11
- 学习java多线程的笔记4--传智播客_张孝祥_空中网挑选实习生的面试题(来源于视频)
- 传智播客_张孝祥_Java基础4_面向对象下_学习笔记
- 传智播客-Java学习笔记day14
- 传智播客-刘意-java深入浅出精华版学习笔记Day01
- 传智播客-Java学习笔记day23
- 传智播客-刘意-java深入浅出精华版学习笔记Day03
- 传智播客-Java学习笔记day15
- 传智播客-刘意-java深入浅出精华版学习笔记Day02
- 传智播客-Java学习笔记day18
- 传智播客-Java学习笔记day24
- 传智播客-Java学习笔记day16
- 传智播客JAVA培训 2010610 Ibatis学习笔记
- 传智播客-Java学习笔记day12
- 传智播客JAVA培训 2010610 Ibatis学习笔记
- 传智播客-Java学习笔记day26