第六章——IO流
1、异常概述
异常：异常就是Java程序在编译或运行过程中出现的错误。
异常由来：问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。
我们见过的异常,角标越界异常,空指针异常
/*
异常：java程序编译或运行过程中出现的问题
Throwable:
Error: 表示非常严重的问题，自己无法解决的问题
Exception:
除了RuntimeException其它异常【编译时期异常】: 一般指的是异常尚未处理就编译了
RuntimeException【运行时期异常】: 运行过程中报错了，一般情况下是因为语法逻辑不正确导致
JVM遇到问题时，默认的处理方案是：停止程序，抛出错误。
*/
//class Demo implements Cloneable{
// @Override
// protected Object clone() throws CloneNotSupportedException {
// return super.clone();
// }
//}
public class ExceptionDemo1 {
public static void main(String[] args) {
// Demo demo = new Demo();
// Object clone = demo.clone();
// int[] arr = {11,22,33,44};
// System.out.println(arr[5]);
int i = 5;
int j = 0;
System.out.println(i/j);
System.out.println("hello world");
}
}
============================================================
/*
异常的处理方案：
1、try...catch...finally
try...catch使用注意事项：
1、当try中出现异常时，JVM会对应创建一个异常类对象
2、自上而下会与catch中的异常进行匹配，若匹配上就相当于处理了，执行catch中的逻辑
3、若try中有多个异常，当第一个异常触发时，try中的其它后续代码都不会执行，JVM会对应创建一个异常类对象进行第二步匹配
4、可以直接写一个catch里面是所有异常的父类、
5、若存在多个catch匹配，需要将父类异常往后写
6、若使用jdk新特性的写法的话，异常类之间不能存在继承关系
*/
public class ExceptionDemo2 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
// try {
// System.out.println(arr[8]); // new ArrayIndexOutOfBoundsException()
// System.out.println(10/3); // new ArithmeticException()
// System.out.println("江川比李刚帅！");
// }catch (ArrayIndexOutOfBoundsException e){ // = new ArrayIndexOutOfBoundsException()
// System.out.println("出错啦！！");
// }catch (ArithmeticException e){
// System.out.println("除0错误！！");
// }
// try {
// System.out.println(arr[2]); // new ArrayIndexOutOfBoundsException()
// System.out.println(10/0); // new ArithmeticException()
// System.out.println("江川比李刚帅！");
// }catch (ArithmeticException e){
// System.out.println("除0错误！！");
// }catch (Exception e){ // = new ArrayIndexOutOfBoundsException()
// System.out.println("出错啦！！");
// }
try {
System.out.println(arr[8]); // new ArrayIndexOutOfBoundsException()
System.out.println(10 / 3); // new ArithmeticException()
System.out.println("江川比李刚帅！");
} catch (ArrayIndexOutOfBoundsException | ArithmeticException e) { // = new ArrayIndexOutOfBoundsException()
System.out.println("出错啦！！");
}
System.out.println("李刚真帅！");
}
}
/*
try...catch...finally
无论try中的代码是否出错，finally都会执行。
finally一般来说，用作释放资源的作用。
*/
public class ExceptionDemo4 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
try {
System.out.println(3/2);// new ArrayIndexOutOfBoundsException()
} catch (Exception e) { // = new ArrayIndexOutOfBoundsException()
e.printStackTrace();
} finally {
System.out.println("数加666");
}
System.out.println("李刚是世界首富！！");
}
}
============================================================/*
throws: 抛出
在方法的定义上抛出异常类, throws本身是不会处理异常的，只是当时方法内部不用处理了，
但是当调用者调用有问题的方法时，需要调用者进行处理
throw: 抛出
在方法内部抛出异常对象，表示一个确定的异常
注意：
当调用者调用抛出运行时期异常的方法时，可以选择不去处理，也能运行。
当调用者调用抛出编译时期异常的方法是，必须要进行处理，否则编译不通过无法运行。
小故事理解 throw throws try...catch 的使用：
江川是一个快乐的小矿工，有一天他挖到了一个远古炸弹💣【throw】，往洞外运输【throws】,运输给了矿厂管理人员
管理员对炸弹💣进行处理【try..catch】
*/
public class ThrowsDemo1 {
public static void main(String[] args){
// try {
// fun1();
// }catch (Exception e){
// e.printStackTrace();
// }
// fun1();
//
// System.out.println("hello world");
// try {
// fun2();
// }catch (Exception e){
// e.printStackTrace();
// }
// fun1();
try{
fun3();
}catch (Exception e){
e.printStackTrace();
}
}
public static void fun3() throws Exception{
int i= 0;
if(i==0){
throw new ArithmeticException();
}else {
System.out.println(5/i);
}
}
public static void fun2() throws IOException {
FileInputStream fis = new FileInputStream("");
}
public static void fun1() throws ArithmeticException{
int[] arr = {11, 22, 33, 44, 55};
System.out.println(3 / 0);// new ArrayIndexOutOfBoundsException()
System.out.println("李刚是世界首富！！");
}
}
2、File类
File类的概述
文件和目录路径名的抽象表示形式
构造方法
public File(String pathname)
public File(String parent,String child)
public File(File parent,String child)
/*
File【文件】: 是计算机中所有文件的抽象表示, 将来File对象目标可能存在，也可能不存在。
构造方法：
public File(String pathname)
public File(String parent,String child)
public File(File parent,String child)
路径：
绝对路径【完整路径】：D:\projects\IdeaProjects\bigdara32\java\src\com\shujia\day15\ketang\a1.txt
相对路径：java/src/com/shujia/day15/ketang/a1.txt
*/
public class FileDemo1 {
public static void main(String[] args) {
//public File(String pathname)
// File f1 = new File("D:\\projects\\IdeaProjects\\bigdara32\\java\\src\\com\\shujia\\day15\\ketang\\a1.txt");
// System.out.println(f1);
// File f2 = new File("java/src/com/shujia/day15/ketang/a1.txt");
// System.out.println(f2);
//public File(String parent,String child)
// File f1 = new File("D:\\projects\\IdeaProjects\\bigdara32\\java\\src\\com\\shujia\\day15\\ketang","a1.txt");
// System.out.println(f1);
//public File(File parent,String child)
File file = new File("D:\\projects\\IdeaProjects\\bigdara32\\java\\src\\com\\shujia\\day15\\ketang");
File f1 = new File(file, "a1.txt");
System.out.println(f1);
}
}
============================================================
/*
创建功能
public boolean createNewFile()
public boolean mkdir()
public boolean mkdirs()
删除功能
public boolean delete()
重命名功能
public boolean renameTo(File dest)
*/
public class FileDemo2 {
public static void main(String[] args) throws Exception{
File file = new File("java/src/com/shujia/day15/ketang/a1.txt");
//public boolean createNewFile()
// System.out.println(file.createNewFile());
//public boolean mkdir() 创建单极文件夹Z
System.out.println(file.mkdir());
//public boolean mkdirs() 创建多极文件夹
// System.out.println(file.mkdirs());
//public boolean delete() 只能删除空文件夹，或一个文件
// System.out.println(file.delete());
//public boolean renameTo(File dest)
// File file2 = new File("java/src/com/shujia/day15/ketang/李刚.txt");
// System.out.println(file.renameTo(file2));
}
}
============================================================
/*
判断功能
public boolean isDirectory()
public boolean isFile()
public boolean exists()
public boolean canRead()
public boolean canWrite()
public boolean isHidden()
*/
public class FileDemo3 {
public static void main(String[] args) {
File file = new File("java/src/com/shujia/day15/ketang/李刚.txt");
// public boolean isDirectory()
System.out.println(file.isDirectory());
//public boolean isFile()
System.out.println(file.isFile());
//public boolean exists()
System.out.println(file.exists());
//public boolean canRead() 是否可读
System.out.println(file.canRead());
//public boolean canWrite() 是否可写
System.out.println(file.canWrite());
//public boolean isHidden() 是否被隐藏
System.out.println(file.isHidden());
}
}
============================================================/*
基本获取功能
public String getAbsolutePath()
public String getPath()
public String getName()
public long length()
public long lastModified()
*/
public class FileDemo4 {
public static void main(String[] args) {
File file = new File("java/src/com/shujia/day15/ketang/李刚.txt");
// public String getAbsolutePath() 获取绝对路径
System.out.println(file.getAbsolutePath());
//public String getPath() 获取相对路径
System.out.println(file.getPath());
//public String getName() 获取文件或文件夹的名字
System.out.println(file.getName());
//public long length() 获取文件中字节数
System.out.println(file.length());
//public long lastModified() 获取上一次修改的时间戳【毫秒级别的】
// System.out.println(file.lastModified());
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:dd").format(new Date(file.lastModified()));
System.out.println("上一次修改的时间："+time);
}
}
============================================================/*
高级获取功能
public String[] list()
public File[] listFiles()
*/
public class FileDemo5 {
public static void main(String[] args) {
File file = new File("java/src/com/shujia/day15/ketang");
//public String[] list() 将目录下所有的文件以及文件夹的名字放到一个数组中返回
String[] nameList = file.list();
if(nameList!=null){
for (String s : nameList) {
System.out.println(s);
}
}
// assert nameList!=null;
// for (String s : nameList) {
// System.out.println(s);
// }
//public File[] listFiles() 将目录下所有的文件以及文件夹都封装成一个一个的File对象放到一个数组中
File[] files = file.listFiles();
if(files!=null){
for (File file1 : files) {
System.out.println(file1);
}
}
}
}
============================================================//需求：获取ketang目录下所有.txt后缀的文件
public class FileDemo6 {
public static void main(String[] args) {
File file = new File("java/src/com/shujia/day15/ketang");
//获取当前目录下所有的文件或者文件夹的集合
File[] files = file.listFiles();
if(files!=null){
for (File file1 : files) {
if(file1.isFile() && file1.getName().endsWith(".txt")){
System.out.println(file1.getName());
}
}
}
}
}
============================================================
/*
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)
*/
public class FileDemo7 {
public static void main(String[] args) {
File file = new File("java/src/com/shujia/day15/ketang");
//public File[] listFiles(FilenameFilter filter)
File[] files = file.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
// 当这里返回true的时候，表示将文件放到数组中
// dir表示当前目录，name表示文件或者文件夹名字
File f = new File(dir, name);
return f.isFile() && f.getName().endsWith(".txt");
}
});
if(files!=null){
for (File file1 : files) {
System.out.println(file1);
}
}
}
}
3、递归
递归
方法定义中调用方法本身的现象
递归注意实现
要有出口，否则就是死递归
次数不能太多，否则就内存溢出
构造方法不能递归使用
/*
递归：方法定义时内部调用自身的现象
fun1().fun2() 这叫方法的链式调用
fun1(show1()) 这叫方法的嵌套调用
写递归需要考虑的东西：
1、开始条件
2、出口
递归：
1、从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的故事内容： 1
从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的故事内容： 2
从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的故事内容： 3
从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的故事内容： 4
....
结束条件：山倒了，老和尚圆寂了。
2、来数加学习大数据，找工作，挣钱，娶老婆，生娃：
来数加学习大数据，找工作，挣钱，娶老婆，生娃：
来数加学习大数据，找工作，挣钱，娶老婆，生娃：
...
结束条件：挣不到钱，没有生娃...
需求：使用递归实现一个数的阶乘
*/
public class DiGuiDemo1 {
public static void main(String[] args) {
int res = jieCheng(5);
System.out.println("5的阶乘是：" + res);
}
// 5*4*3*2*1
public static int jieCheng(int i) {
if (i == 1) {
return 1;
} else {
return i * jieCheng(--i);
// 5 * jieCheng(4)
// 5 * 4 * jieCheng(3)
// 5 * 4 * 3 * jieCheng(2)
// 5 * 4 * 3 * 2 * jieCheng(1)
}
}
// public static void fun1(){
// fun1();
// }
}
4、字节流
按照数据流向
输入流 读入数据
输出流 写出数据
按照数据类型
字节流
字符流
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
如果你什么都不知道，就用字节流
/*
IO流【输入输出流】：
按照流向划分：
输入流：外部数据 -> java程序
输出流：java程序 -> 外部数据
按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：
字节流【万能流】：
字节输出流：
OutputStream（抽象类）
- FileOutputStream（实现子类）
字节输入流：
InputStream（抽象类）
字符流【记事本能看懂】：
字符输入流：
字符输出流：
FileOutputStream：
构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
*/
public class FileOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
// FileOutputStream(File file) 将目标文件封装成File对象
// 若目标文件不存在，则会自动创建
// FileOutputStream fos = new FileOutputStream(new File("java/src/com/shujia/day16/a1.txt"));
//FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
}
}
============================================================
/*
public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)
思考：
1、如何实现文件内容追加写？ 使用另一个重载的构造方法传入append参数值
2、如何实现写的时候换行？写一个换行符
*/
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws Exception{
// FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
//public FileOutputStream(String name, boolean append)
FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt", true);
//public void write(int b) 写一个ASCII码值
// fos.write(97);
// public void write(byte[] b) 写一个字节数组到文件中
// byte[] bytes = {97,98,99,100,101,102};
// fos.write(bytes);
//public void write(byte[] b,int index,int len)
// fos.write(bytes,2,3);
fos.write("\r\n".getBytes());
fos.write("李刚真帅！".getBytes());
//释放资源
fos.close();
}
}
============================================================/*
IO流【输入输出流】：
按照流向划分：
输入流：外部数据 -> java程序
输出流：java程序 -> 外部数据
按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：
字节流【万能流】：
字节输出流：
OutputStream（抽象类）
- FileOutputStream（实现子类）
字节输入流：
InputStream（抽象类）
- FileInputStream（实现子类）
字符流【记事本能看懂】：
字符输入流：
字符输出流：
FileInputStream：
构造方法：
FileInputStream(File file)
FileInputStream(String name)
成员方法：
public int read()
public int read(byte[] b)
*/
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("java/src/com/shujia/day16/a1.txt"));
FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a1.txt");
//public int read() 一次只读取一个字节
// 如果没有读到数据，返回-1
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// System.out.print((char)fis.read());
// int i = 0;
// while ((i = fis.read()) != -1) {
// System.out.print((char) i);
// }
//public int read(byte[] b) 一次读取一个字节数组
//创建一个字节数组，用作接收读取到的字节
byte[] bytes = new byte[7];
int length = 0;
while ((length = fis.read(bytes))!=-1){
//读取到的字节在字节数组中
//返回的是实际读取到的字节数
//将字节数组转字符串
String s = new String(bytes,0,length);
System.out.print(s);
}
// 释放资源
fis.close();
}
}
============================================================/*
使用字节输入流读取汉字
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a2.txt");
// 一次读取一个字节
System.out.println((char) fis.read());
//一次读取一个字节数组
// byte[] bytes = new byte[1024];
// int length = fis.read(bytes);
// String s = new String(bytes, 0, length);
// System.out.println(s);
// 释放资源
fis.close();
}
}
============================================================
/*
OutputStream:
FileOutputStream【普通的字节输出流】：
BufferedOutputStream【字节缓冲输出流】：
*/
public class BufferedOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
//BufferedOutputStream(OutputStream out)
//创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
//创建一个字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java/src/com/shujia/day16/a2.txt"));
bos.write("李刚是世界上最帅的男人！".getBytes());
bos.write("好好学习".getBytes());
bos.flush();
//释放资源
bos.close(); // 关闭缓冲流的时候，会先将内存中的数据刷到磁盘中
}
}
============================================================/*
InputStream:
FileInputStream【普通的字节输入流】:
BufferedInputStream【字节缓冲输入流】:
*/
public class BufferedInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//BufferedInputStream(InputStream in)
//创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java/src/com/shujia/day16/a1.txt"));
// 一次读一个字节
// int i = 0;
// while ((i=bis.read())!=-1){
// System.out.print((char) i);
// }
// 一次都一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while ((length = bis.read(bytes)) != -1) {
String s = new String(bytes, 0, length);
System.out.print(s);
}
//释放资源
bis.close();
}
}
5、字符流
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
- FileReader【继承自InputStreamReader】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
- FileWriter【继承自OutputStreamWriter】
*/
public class FileWriterDemo1 {
public static void main(String[] args) throws Exception{
//创建字符输出流对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt"));
// FileWriter fw = new FileWriter("java/src/com/shujia/day16/b2.txt");
//创建字符输入流对象
// InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b2.txt"));
FileReader fr = new FileReader("java/src/com/shujia/day16/b2.txt");
//一次读一个字符
// int i = 0;
// while ((i = fr.read())!=-1){
// System.out.print((char) i);
// }
//一次读一个字符数组
char[] chars = new char[1024];
int length = 0;
while ((length = fr.read(chars))!=-1){
String s = new String(chars, 0, length);
System.out.print(s);
}
// fw.write("今天的天气不错！");
// fw.flush();
fr.close();
// fw.close();
}
}
============================================================================================
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
- FileReader【继承自InputStreamReader】
- BufferedReader 【字符缓冲输入流】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
- FileWriter【继承自OutputStreamWriter】
- BufferedWriter【字符缓冲输出流】
BufferedReader 【字符缓冲输入流】:
构造方法：
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
特殊功能：
public String readLine() 一次读取文本文件内容的一行, 不会读取换行符
*/
public class BufferedReaderDemo1 {
public static void main(String[] args) throws Exception {
//创建字符缓冲输入流对象
// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b3.txt")));
BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/day16/b3.txt"));
//一次读一个字符
// int i = 0;
// while ((i=br.read())!=-1){
// System.out.print((char) i);
// }
//一次读一个字符数组
// char[] chars = new char[1024];
// int length = 0;
// while ((length=br.read(chars))!=-1){
// String s = new String(chars, 0, length);
// System.out.print(s);
// }
//一次读取一行数据
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//释放资源
br.close();
}
}
============================================================================================
/*
字符流：
字符输入流：
Reader【抽象类】
- InputStreamReader【具体实现子类】
- FileReader【继承自InputStreamReader】
- BufferedReader 【字符缓冲输入流】
字符输出流：
Writer【抽象类】
- OutputStreamWriter【具体实现子类】
- FileWriter【继承自OutputStreamWriter】
- BufferedWriter【字符缓冲输出流】
BufferedWriter【字符缓冲输出流】：
构造方法：
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
特殊方法：
newLine(); // 默认会自动根据当前的系统生成一个换行符
*/
public class BufferedWriterDemo1 {
public static void main(String[] args) throws Exception{
//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day16/b3.txt"));
bw.write("落霞与孤鹜齐飞");
// bw.write("\r\n"); // 这里的换行符需要根据将来运行的系统环境来设置
bw.newLine(); // 默认会自动根据当前的系统生成一个换行符
bw.write("秋水共长天一色");
bw.flush();
//释放资源
bw.close();
}
}
6、文件复制
/*
复制文件：
数据源：D:\IU.jpg
输入流：
字节输入流：InputStream
- FileInputStream
目的地：E:\李知恩.jpg
输出流：
字节输出流：OutputStream
- FileOutputStream
*/
public class CopyFileTest1 {
public static void main(String[] args) throws Exception {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("D:\\IU.jpg");
//创建字节输出流对象那个
FileOutputStream fos = new FileOutputStream("E:\\李刚的第二个对象.jpg");
// 方式1：一次读写一个字节
// int i = 0;
// while ((i=fis.read())!=-1){
// fos.write(i);
// }
// 方式2：一次读写一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while ((length=fis.read(bytes))!=-1){
fos.write(bytes,0,length);
}
//释放资源
fos.close();
fis.close();
}
}
============================================================================================
/*
比较4种复制读写的速度
数据源：E:\bigdata32\32期day16 字节流 1.mp4
*/
public class CopyFileTest2 {
public static void main(String[] args) {
//1、普通字节流一次读写一个字节
// fun1(); // > 10min 2231484
//3、字节缓冲流一次读写一个字节
// fun2(); //2834749
//2、普通字节流一次读写一个字节数组
// fun3(); // 共消耗 707 毫秒
//4、字节缓冲流一次读写一个字节数组
fun4(); // 共消耗 502 毫秒
}
public static void fun4(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//创建普通字节输入流对象
bis = new BufferedInputStream(new FileInputStream("E:\\bigdata32\\32期day16 字节流 1.mp4"));
//创建普通字节输出流对象那个
bos = new BufferedOutputStream(new FileOutputStream("D:\\a4.mp4"));
byte[] bytes = new byte[1024];
int length = 0;
long start = System.currentTimeMillis();
while ((length= bis.read(bytes))!=-1){
bos.write(bytes,0,length);
bos.flush();
}
long end = System.currentTimeMillis();
System.out.println("共消耗 "+(end-start)+" 毫秒");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void fun3(){
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建普通字节输入流对象
fis = new FileInputStream("E:\\bigdata32\\32期day16 字节流 1.mp4");
//创建普通字节输出流对象那个
fos = new FileOutputStream("D:\\a3.mp4");
byte[] bytes = new byte[1024];
int length = 0;
long start = System.currentTimeMillis();
while ((length=fis.read(bytes))!=-1){
fos.write(bytes,0,length);
}
long end = System.currentTimeMillis();
System.out.println("共消耗 "+(end-start)+" 毫秒");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//字节缓冲流一次读写一个字节
public static void fun2(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//创建普通字节输入流对象
bis = new BufferedInputStream(new FileInputStream("E:\\bigdata32\\32期day16 字节流 1.mp4"));
//创建普通字节输出流对象那个
bos = new BufferedOutputStream(new FileOutputStream("D:\\a2.mp4"));
int i = 0;
int i2 = 1;
long start = System.currentTimeMillis();
while ((i=bis.read())!=-1){
System.out.println(i2++);
bos.write(i);
bos.flush();
}
long end = System.currentTimeMillis();
System.out.println("共消耗 "+(end-start)+" 毫秒");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//普通字节流一次读写一个字节
public static void fun1() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建普通字节输入流对象
fis = new FileInputStream("E:\\bigdata32\\32期day16 字节流 1.mp4");
//创建普通字节输出流对象那个
fos = new FileOutputStream("D:\\a1.mp4");
int i = 0;
int i2 = 1;
long start = System.currentTimeMillis();
while ((i=fis.read())!=-1){
System.out.println(i2++);
fos.write(i);
}
long end = System.currentTimeMillis();
System.out.println("共消耗 "+(end-start)+" 毫秒");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
============================================================================================
/*
把java/src/com/shujia/day16/a4.txt内容复制到java/src/com/shujia/day16/b1.txt中
数据源：java/src/com/shujia/day16/a4.txt
字符输入流：
Reader:
- InputStreamReader
目的地：java/src/com/shujia/day16/b1.txt
字符输出流：
Writer:
- OutputStreamWriter
*/
public class CopyFileTest3 {
public static void main(String[] args) throws Exception {
// 创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a4.txt"));
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b2.txt"));
//一次读写一个字符
// int i = 0;
// while ((i = isr.read()) != -1) {
// osw.write(i);
// osw.flush();
// }
//一次读写一个字符数组
char[] chars = new char[1024];
int length = 0;
while ((length=isr.read(chars))!=-1){
osw.write(chars,0,length);
osw.flush();
}
//释放资源
osw.close();
isr.close();
}
}
============================================================================================
public class CopyFileTest4 {
public static void main(String[] args) throws Exception {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/day16/b3.txt"));
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day16/c3.txt"));
//1、一次读写一个字符
// int i = 0;
// while ((i=br.read())!=-1){
// bw.write(i);
// bw.flush();
// }
//2、一次读写一个字符数组
// char[] chars = new char[1024];
// int length = 0;
// while ((length = br.read(chars)) != -1) {
// bw.write(chars, 0, length);
// bw.flush();
// }
//3、一次读写一行
String line = null;
while ((line= br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
7、序列化流
/*
序列化：将对象转化成数据流一样在网络中传输
对象输出流：ObjectOutputStream
只有实现了Serializable接口的类的对象才可以进行序列化
反序列化：将网络中数据流还原成一个对象
对象输入流：ObjectInputStream
我们正常写一个对象之后，读取一个对象都是没有问题的。
但是当我们修改了原来的类的时候，再次读取存储的对象就报错了
java.io.InvalidClassException:
com.shujia.day16.Teacher;
local class incompatible:
stream class desc serialVersionUID = -4530247781226673719,
local class serialVersionUID = -4180828856871739850
若不想让某一个成员序列化的话，只需要在该成员前面加上transient关键字
*/
public class ObjectOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
// write();
read();
}
public static void read() throws Exception{
//ObjectInputStream(InputStream in)
//创建从指定的InputStream读取的ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java/src/com/shujia/day16/obj.txt"));
Object o = ois.readObject(); //Object o = new Teacher("小虎", 18)
Teacher t1 = (Teacher)o;
System.out.println(t1);
ois.close();
}
public static void write() throws Exception{
Teacher t1 = new Teacher("小虎", 18);
//创建ObjectOutputStream对象
//ObjectOutputStream(OutputStream out)
//创建一个写入指定的OutputStream的ObjectOutputStream。
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("java/src/com/shujia/day16/obj.txt"));
oos.writeObject(t1);
oos.flush();
//释放资源
oos.close();
}
}
浙公网安备 33010602011771号