Java——Contents1（File、字节流）

File类

File类创建功能

方法名	说明
public boolean createNewFile()	但具有该名称的文件不存在时，创建一个有该抽象路径命名的新空文件
public boolean mkdir()	创建由此抽象路径命名的目录
public boolean mkdirs()	创建由此抽象路径命名的目录，包括任何必须但不存在的父目录

import java.io.File;
import java.io.IOException;

/*
File类

public boolean createNewFile()   但具有该名称的文件不存在时，创建一个有该抽象路径命名的新空文件
	如果文件不存在，就创建文件，并返回true
	如果文件存在，就不创建文件，并返回false
 
 
public boolean mkdir()创建由此抽象路径命名的目录
	如果目录不存在，就创建文件，并返回true
	如果目录存在，就不创建文件，并返回false
	
	
public boolean mkdirs()创建由此抽象路径命名的目录，包括任何必须但不存在的父目录
	如果目录不存在，就创建文件，并返回true
	如果目录存在，就不创建文件，并返回false


*/

public class FileDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//需求1：要在E:\\itcast目录下创建一个文件java.txt
		File f1 = new File("E:\\itcast\\java.txt");
		System.out.println(f1.createNewFile());//抛出异常
		System.out.println("---------");

		//需求2：要在E:\\itcast目录下创建一个目录JavaSE
		File f2 = new File("E:\\itcast\\JavaSE");
		System.out.println(f2.mkdir());
		System.out.println("---------");

		//需求3：要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
		File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
		System.out.println(f3.mkdirs());
		System.out.println("---------");

		//需求4：要在E:\\itcast目录下创建一个文件javase.txt
		File f4 = new File("E:\\itcast\\javase.txt");
		//		System.out.println(f4.mkdir());//创建了一个javase.txt目录，不能根据路径名决定是文件还是目录
		System.out.println(f4.createNewFile());//会返回false，因为不能存在同名的，不管是文件还是目录

	}
}

File类判断和获取功能

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
public boolean isFire()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在
public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
public String getPath()	将此抽象路径名转换为路径名字符串
public String getName()	返回由此抽象路径名表示的文件或目录的名称
public String[] list()	返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

import java.io.File;
import java.io.IOException;

/*
File类判断和获取功能**

public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
public boolean isFire()测试此抽象路径名表示的File是否为文件
public boolean exists()测试此抽象路径名表示的File是否存在

public  String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
public String getPath()将此抽象路径名转换为路径名字符串
public String getName()返回由此抽象路径名表示的文件或目录的名称

public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组

*/

public class FileDemo2 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//创建一个file对象
		File f = new File("java.txt");
		//		System.out.println(f.createNewFile());

		//		public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
		//		public boolean isFire()测试此抽象路径名表示的File是否为文件
		//		public boolean exists()测试此抽象路径名表示的File是否存在
		System.out.println(f.isDirectory());
		System.out.println(f.isFile());
		System.out.println(f.exists());
		/*运行结果：
		false
		true
		true
		*/

		//		public  String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
		//		public String getPath()将此抽象路径名转换为路径名字符串
		//		public String getName()返回由此抽象路径名表示的文件或目录的名称
		System.out.println(f.getAbsolutePath());
		System.out.println(f.getPath());
		System.out.println(f.getName());
		/*运行结果：
		F:\Users\ASUS\eclipse-workspace\hello java\java.txt
		java.txt//封装的路径
		java.txt//路径的名称
		*/

		System.out.println("---------");
		//		public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
		//		public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
		File f2 = new File("E:itcast");
		String[] strArray = f2.list();
		for (String str : strArray) {
    
    
			System.out.println(str);
		}
		System.out.println("---------");
		File[] fileArray = f2.listFiles();
		for (File file : fileArray) {
    
    
			//			System.out.println(file);
			//			System.out.println(file.getName());
			if (file.isFile()) {
    
    //如果是文件就输出名称
				System.out.println(file.getName());
			}

		}

	}
}

运行结果：
在这里插入图片描述
File类删除功能

方法名	说明
public boolean delete()	删除由此抽象路径名表示的文件或目录

绝对路径和相对路径的区别

绝对路径：完整的路径名，不需要任何其他信息就可以定位它所代表示的文件。例如：E:\ \tcast\ \java.txt
相对路径：必须使用取自其他路径名的信息进行解释。例如：javafile\ \java.txt

删除目录时的注意事项：

如果一个目录中有内容（目录，文件），不能直接删除。应该先删除目录中的内容，最后才能删除目录

import java.io.File;
import java.io.IOException;

/*
File类删除功能

public boolean delete()   删除由此抽象路径名表示的文件或目录 

*/
public class FileDemo3 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//		File f1=new File("E:\\itcast\\java.txt");
		//需求1：在当前模块目录下创建java.txt文件
		File f1 = new File("java.txt");
		//		System.out.println(f1.createNewFile());

		//		需求2：删除当前模块目录下的java.txt文件
		System.out.println(f1.delete());
		System.out.println("--------");

		//		需求3：在当前模块下创建ifcast目录
		File f2 = new File("itcast");
		//		System.out.println(f2.mkdir());

		//		需求4：删除当前模块下创建ifcast目录
		System.out.println(f2.delete());
		System.out.println("--------");

		//		需求5：在当前模块下创建itcast目录，然后再该目录下创建java.txt文件
		File f3 = new File("itcast");
		//		System.out.println(f3.mkdir());
		File f4 = new File("itcast\\java.txt");
		//若没有上级目录:java.io.IOException: 系统找不到指定的路径。
		//		System.out.println(f4.createNewFile());

		//		需求6：删除当前模块下的目录itcast
		System.out.println(f4.delete());
		System.out.println(f3.delete());//false:如果要删除的目录下面还有内容，就不能直接删

	}
}

递归

递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象

递归解决问题的思路：
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容：

递归出口：否则会出现内存溢出
递归规则：与原问题相似的规模较小的问题

public class DiGuiDemo {
    
    
	public static void main(String[] args) {
    
    
		//回顾不死神兔问题：求第20个月兔子的对数
		//每个月的兔子对数：1,1,2,3,5,8...
		int[] arr = new int[20];

		arr[0] = 1;
		arr[1] = 1;

		for (int i = 2; i < arr.length; i++) {
    
    
			arr[i] = arr[i - 1] + arr[i - 2];

		}
		System.out.println(arr[19]);
		System.out.println(f(20));
	}

	/*
	递归解决问题，首先要定义一个方法
		定义一个方法f(n);表示第n个月的兔子对数
		那么，第n-1个月的兔子对数f(n-1)
		同理，第n-2个月的兔子f(n-2)
		
	//StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
		
		*/
	public static int f(int n) {
    
    
		if (n == 1 || n == 2) {
    
    
			return 1;
		}
		return f(n - 1) + f(n - 2);
	}

}

运行结果：
在这里插入图片描述

案例：递归求阶乘

需求：用递归求5的阶乘，并把结果在控制台输出

/*
案例：递归求阶乘
需求：用递归求5的阶乘，并把结果在控制台输出
*/
public class DiGuiDemo2 {
    
    
	public static void main(String[] args) {
    
    
		System.out.println("5的阶乘是：" + f(5));
	}

	//定义一个方法，用于递归求阶乘
	public static int f(int n) {
    
    
		if (n == 1) {
    
    
			return 1;
		}

		return n * f(n - 1);
	}
}

运行结果：
在这里插入图片描述

案例：遍历目录

需求：给定一个路径E:\ \itcast，请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
在这里插入图片描述

import java.io.File;

/*
案例：遍历目录
需求：给定一个路径E:\\itcast，请通过递归完成遍历该目录下的所有内容，
并把所有文件的绝对路径输出在控制台
*/

public class DiGuiDemo3 {
    
    
	public static void main(String[] args) {
    
    
		//根据给定的路径创建对象
		File f = new File("E:\\itcast");

		get(f);
	}

	//定义一个方法。
	public static void get(File f) {
    
    
		//获取给定目录下所有内容
		File[] fileArray = f.listFiles();
		//遍历该file数组，得到每一个file对象
		if (null != fileArray) {
    
    
			for (File file : fileArray) {
    
    
				//判断该file是否是目录
				if (file.isDirectory()) {
    
    
					//是，递归调用
					get(file);
				} else {
    
    
					//不是，获取绝对路径，输出
					System.out.println(file.getAbsolutePath());
				}
			}
		}

	}

}

运行结果：
在这里插入图片描述

字节流

IO流概述和分类

IO流概述：

IO：输入/输出（Input/Output）
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
IO流就是用来处理设备间数据传输问题的
常见的应用：文件复制；文件上传；文件下载

IO流分类：

按照数据的流向
输入流：读数据
输出流：写数据
按照数据类型来分
字节流：字节输入流；字节输出流
字符流：字符输入流；字符输出流

一般来说，IO流的分类是按照数据类型来分的

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果不知道使用哪种类型的流，就饿使用字节流

字节流写数据

字节流抽象基类：

InputStream：这个抽象类是表示字节输入流的所有类的超类
OutputStream：这个抽象列是表示字节输出流的所有类的超类
子类名特点：子类名称都是以其父名作为子类名的后缀

FileOutputStream：文件输出流用与将数据写入File

FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
调用字节输出流对象的写数据方法
释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

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

/*

字节流写数据**

字节流抽象基类：

 - InputStream：这个抽象类是表示字节输入流的所有类的超类
 - OutputStream：这个抽象列是表示字节输出流的所有类的超类
 - 子类名特点：子类名称都是以其父名作为子类名的后缀

FileOutputStream：文件输出流用与将数据写入File

 - FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
*/

public class FileOutputStreamDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//创建字节输出流对象
		//FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
		FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
		/*
		做了三件事：
			调用系统功能创建了文件
			创建了字符输出流对象
			让字符输出流对象指向创建好的文件
		*/

		//void write (int b)：将指定的字节写入此文件输出流
		fos.write(97);//a
		//		fos.write(57);//9
		//		fos.write(55);//7

		//最后都要释放资源
		//void close():关闭此文件输出流并释放与此流相关联的任何系统资源
		fos.close();

	}
}

字节流输入的三种方式

字节流写数据的3种方法

方法名	说明
void write(int b)	将指定的字节写入此文件输出流，一次写一个字节数据
void write(byte[] b)	将b.leangth字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
void write(byte[] b,int off,int len)	将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据

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

/*

构造方法：
	FileOutputStream(String name)：创建文件输出以指定的名称写入文件
	FileOutputStream(File file)：创建文件输出流以写入有指定的File对象表示的文件


字节流写数据的3种方法

void write(int b)   将指定的字节写入此文件输出流，
					一次写一个字节数据
void write(byte[] b)将b.leangth字节从指定的字节数组写入此文件输出流，
					一次写一个字节数组数据
void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，
									一次写一个字节数组的部分数据
*/

public class FileOutputStreamDemo2 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//1:FileOutputStream(String name)：创建文件输出以指定的名称写入文件
		FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
		//new File(name)
		//		FileOutputStream fos=new FileOutputStream(new File("..\\hello java\\fos.txt"));//相当于上面的

		//2:FileOutputStream(File file)：创建文件输出流以写入有指定的File对象表示的文件
		//		File file=new File("..\\hello java\\fos.txt");
		//		FileOutputStream fos2=new FileOutputStream(file);
		//		FileOutputStream fos2=new FileOutputStream(new File("..\\hello java\\fos.txt"));//两种都可以

		//void write(int b)   将指定的字节写入此文件输出流，
		//一次写一个字节数据
		//		fos.write(97);
		//		fos.write(98);
		//		fos.write(99);
		//		fos.write(100);
		//		fos.write(101);
		/*abcde*/

		//void write(byte[] b)将b.leangth字节从指定的字节数组写入此文件输出流，
		//一次写一个字节数组数据
		//		byte[] bys= {97,98,99,100,101};
		//byte[] getByted():返回字符串对应的字节数组
		byte[] bys = "abcde".getBytes();
		//		fos.write(bys);
		/*abcde*/

		//void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，
		//一次写一个字节数组的部分数据
		//		fos.write(bys,0,bys.length);//abcde
		fos.write(bys, 1, 3);//bcd

		//释放资源
		fos.close();

	}
}

字节流写数据的两个小问题
字节流写数据如何实现换行？

写完数据后，加换行符
window：\r\n
linux：\n
mac：\r

字节流写数据如何实现追加写入？

public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开头

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

/*
字节流写数据的两个小问题

	1.字节流写数据如何实现换行？
	不同系统换行识别是不一样的
		windeow:\r\n
		linux:\n
		mac:\r
		
	2.字节流写数据如何实现追加写入？
		public fileOutputStream(String name,boolean append)
			创建文件输出流以指定的名称写入文件。
			如果第二个参数为true，则字节将写入文件的末尾而不是开头
*/

public class FileOutputStreamDemo3 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//创建字节输出流对象
		//		FileOutputStream fos=new FileOutputStream("..\\hello java\\fos.txt");
		FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt", true);

		//写数据
		for (int i = 0; i < 10; i++) {
    
    
			fos.write("hello".getBytes());
			fos.write("\r\n".getBytes());//换行
		}

		//释放资源
		fos.close();

	}
}

字节流写数据加入异常处理

finally：在异常处理时提供finally块来执行所有清楚操作。比如说IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清楚操作;
}

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

/*
字节流数据加入异常处理
*/
public class FileOutputStreamDemo4 {
    
    
	public static void main(String[] args) {
    
    
		/*
		try {
			FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
			fos.write("hello".getBytes());
			fos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		*/
		
		//加入finally来实现释放资源
		FileOutputStream fos = null;//在外面创建fos，给初始化null
		try {
    
    
			//			fos=new FileOutputStream("Z:\\hello java\\fos.txt");//错误地址
			fos = new FileOutputStream("..\\hello java\\fos.txt");
			fos.write("hello".getBytes());
			fos.close();
		} catch (IOException e) {
    
    
			e.printStackTrace();
		} finally {
    
    
			if (null != fos) {
    
    //释放资源前对fos进行不为null的判断
				try {
    
    
					fos.close();//快捷键try...catch方法
				} catch (IOException e) {
    
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

	}
}

字节流读数据（一次读一个字节数据）

需求：把文件fos.txt中的内容读取出来在控制台输出

FileInputStream：从文件系统中的文件获取输入字节

FileInputStream(String name)：通过打开与实际文件的连接俩创建一个FileInputStream，该文件由文件系统中的路径名name命名

使用字节输入流读数据的步骤：

创建字节输入流对象
调用字节输入流对象的读数据方法
释放资源

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

/*
字节流读数据（一次读一个字节数据）**

需求：把文件fos.txt中的内容读取出来在控制台输出

FileInputStream：从文件系统中的文件获取输入字节

 - FileInputStream(String name)：通过打开与实际文件的连接俩创建一个FileInputStream，该文件由文件系统中的路径名name命名

使用字节输入流读数据的步骤：

 1. 创建字节输入流对象
 2. 调用字节输入流对象的读数据方法
 3. 释放资源
*/

public class FileInputStreamDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//创建字节输入流对象
		//FileInputStream(String name)
		FileInputStream fis = new FileInputStream("..\\hello java\\fos.txt");
		/*
			fos.txt中的内容
				ab
		*/

		//调用字节输入流对象的读数据方法
		//int read():从该输入流读取一个字节的数据

		/*
		//第一次读取数据
		int i = fis.read();
		System.out.println(i);//97
		System.out.println((char)i);//a 强制转换
		
		//第一次读取数据
		i = fis.read();
		System.out.println(i);//98
		System.out.println((char)i);//b 强制转换
		
		//再多读取两次
		i = fis.read();
		System.out.println(i);//-1 文件中没有数据了，返回-1
		i = fis.read();
		System.out.println(i);//-1
		*/

		/*
		//判断条件：文件末尾-1
		int by=fis.read();
		while(by!=-1) {
		//			System.out.println(by);
			System.out.print((char)by);
			by=fis.read();
		}
		运行结果：
		ab
		
		*/

		//优化上面的程序
		int by;
		/*
		fis.read():读数据
		by=fis.read():把读取到的数据赋值给by
		by！=-1:判断读取到的数据是否是-1
		
		*/
		while ((by = fis.read()) != -1) {
    
    
			System.out.print((char) by);
		}
		//		运行结果：
		//		ab

		//释放资源
		fis.close();

	}
}

案例：复制文本文件

需求：把“E:\\itcast\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

分析：复制文本文件，就是把文件内容从一个文件中读取出来（数据源），然后写入另一个文件中（目的地）

数据源：E:\\itcast\\窗里窗外.txt—读数据—InputStream—FileInputStream
目的地：…\\hello java\\窗里窗外.txt—写数据—OutputStream—FileOutputStream

在这里插入图片描述

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

/*
案例：复制文本文件
需求：把“E:\\\itcast\\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

分析：复制文本文件，就是把文件内容从一个文件中读取出来（**数据源**），然后写入另一个文件中（**目的地**）

数据源：E:\\\itcast\\\窗里窗外.txt---读数据---InputStream---FileInputStream
目的地：..\\\hello java\\\窗里窗外.txt---写数据---OutputStream---FileOutputStream

*/
public class CopyDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//根据数据源创建字节输入流对象
		FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");

		//根据目的地创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("..\\hello java\\窗里窗外.txt");

		//读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
		int by;
		while ((by = fis.read()) != -1) {
    
    
			fos.write(by);
		}

		//释放资源
		fos.close();
		fis.close();

	}
}

运行结果：
在这里插入图片描述
字节流读数据（一次读一个字节数组数据）

需求：把文件fos.txt中的内容读取出来在控制台输出

使用字节输入流读数据的步骤：

创建字节输入流对象
调用字节输入流对象的读数据方法
释放资源

在这里插入图片描述

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

/*
字节流读数据（一次读一个字节数组数据）**

需求：把文件fos.txt中的内容读取出来在控制台输出

使用字节输入流读数据的步骤：

 1. 创建字节输入流对象
 2. 调用字节输入流对象的读数据方法
 3. 释放资源
*/
public class FileInputStreamDemo2 {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("..\\hello java\\fos.txt");

		//调用字节输入流对象的读数据方法
		//int read(byte[] b)：从该输入流读取最多 b.length个字节的数据到一个字节数组

		/*
		byte[] bys=new byte[5];
		
		//第一次读取数据
		int len = fis.read(bys);
		System.out.println(len);
		//String(byte[] bytes)
		//		System.out.println( new String(bys) );
		System.out.println( new String(bys,0,len) );
		
		//第二次读取数据
		len = fis.read(bys);
		System.out.println(len);
		//		System.out.println( new String(bys) );
		System.out.println( new String(bys,0,len) );
		
		//第三次读取数据
		len = fis.read(bys);
		System.out.println(len);
		//String(byte[] bytes,int offset,int length)
		System.out.println( new String(bys,0,len) );
		//		System.out.println( new String(bys) );
		
		//再多读取两次
		len = fis.read(bys);
		System.out.println(len);
		len = fis.read(bys);
		System.out.println(len);
		
		运行结果：
		5
		hello
		5
		
		wor
		5
		ld 
		
		-1
		-1
		
		
		*/

		/*
		hello\r\n
		world\r\n
		
		第一次：hello
		第二次：\r\nwor
		第三次：ld\r\nr
		*/

		byte[] bys = new byte[1024];//1024及其整数倍
		int len;
		while ((len = fis.read(bys)) != -1) {
    
    
			System.out.print(new String(bys, 0, len));
		}
		/*
		运行结果：
		hello
		world 
		
		*/

		//释放资源
		fis.close();

	}
}

案例：复制图片

需求：把“E:\\itcast\\mn.jpg”复制到模块目录下的“mn.jpg”
在这里插入图片描述

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

/*
案例：复制图片

需求：把“E:\\\itcast\\\mn.jpg”复制到模块目录下的“mn.jpg”

*/
public class CopyJpg {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//根据数据源创建字节输入流对象
		FileInputStream fis = new FileInputStream("E:\\itcast\\mn.jpg");

		//根据目的地创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("..\\hello java\\mn.jpg");

		//读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
		byte[] bys = new byte[1024];
		int len;
		while ((len = fis.read(bys)) != -1) {
    
    
			fos.write(bys, 0, len);
		}

		//释放资源
		fis.close();
		fos.close();

	}
}

运行结果：
在这里插入图片描述
字节缓冲流

字节缓冲流：

BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以想底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

字节缓冲输出流：BufferedOutputStream(OutputStream out)
字节缓冲输入流：BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅是提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

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

/*
字节缓冲流：

 - BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以想底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
 - BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

 - 字节缓冲输出流：BufferedOutputStream(OutputStream out)
 - 字节缓冲输入流：BufferedInputStream(InputStream in)

*/
public class BufferStreamDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//字节缓冲输出流：BufferedOutputStream(OutputStream out)
		//		FileOutputStream fos=new FileOutputStream("..\\hello java\\bos.txt");
		//		BufferedOutputStream bos=new BufferedOutputStream(fos);

		//合并成一步
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\bos.txt"));
		//写数据
		bos.write("hello\r\n".getBytes());
		bos.write("world\r\n".getBytes());
		//释放资源
		bos.close();

		//字节缓冲输入流：BufferedInputStream(InputStream in)
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\hello java\\bos.txt"));

		//读数据
		/*
		//一次读取一个字节数据
		int by;
		while((by=bis.read())!=-1) {
			System.out.print((char)by);
		}
		*/
		//一次读取一个字节数组的数据
		byte[] bys = new byte[1024];
		int len;
		while ((len = bis.read(bys)) != -1) {
    
    
			System.out.print(new String(bys, 0, len));
		}

		//释放资源
		bis.close();

	}
}

运行结果：
在这里插入图片描述

案例：复制视频

需求：把“E:\\itcast\\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”
思路：

根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制视频
释放资源

在这里插入图片描述

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

/*
案例：复制视频
需求：把“E:\\\itcast\\\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”
思路：

 1. 根据数据源创建字节输入流对象
 2. 根据目的地创建字节输出流对象
 3. 读写数据，复制视频
 4. 释放资源
 
 
 四种方式实现复制视频，并记录每种方式复制视频的时间
 	1.基本字节流一次读写一个字节		共耗时：72743毫秒
 	2.基本字节流一次读写一个字节数组		共耗时：87毫秒
 	3.字节缓冲流一次读写一个字节		共耗时：198毫秒
 	4.字节缓冲流一次读写一个字节数组		共耗时：22毫秒

*/

public class CopyAviDemo {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//记录开始时间
		long startTime = System.currentTimeMillis();

		//复制视频
		//		method1();
		//		method2();
		//		method3();
		method4();

		//记录结束时间
		long endTime = System.currentTimeMillis();
		System.out.println("共耗时：" + (endTime - startTime) + "毫秒");

	}

	//4.字节缓冲流一次读写一个字节数组
	private static void method4() throws IOException {
    
    
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\字节流复制图片.avi"));

		byte[] bys = new byte[1024];
		int len;
		while ((len = bis.read(bys)) != -1) {
    
    
			bos.write(bys, 0, len);
		}

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

	}

	//3.字节缓冲流一次读写一个字节
	private static void method3() throws IOException {
    
    
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\字节流复制图片.avi"));

		int by;
		while ((by = bis.read()) != -1) {
    
    
			bos.write(by);
		}

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

	}

	//2.基本字节流一次读写一个字节数组
	private static void method2() throws IOException {
    
    
		FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
		FileOutputStream fos = new FileOutputStream("..\\hello java\\字节流复制图片.avi");

		byte[] bys = new byte[1024];
		int len;
		while ((len = fis.read(bys)) != -1) {
    
    
			fos.write(bys, 0, len);
		}

		fis.close();
		fos.close();

	}

	//1.基本字节流一次读写一个字节
	private static void method1() throws IOException {
    
    
		//E:\\\itcast\\\字节流复制图片.avi
		//模块目录下的字节流复制图片.avi
		FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
		FileOutputStream fos = new FileOutputStream("..\\hello java\\字节流复制图片.avi");

		int by;
		while ((by = fis.read()) != -1) {
    
    
			fos.write(by);

		}

		fos.close();
		fis.close();
	}
}