输入和输出--字节流

1. 输入和输出（I/O流）

关流原则：先开的后关

变量

数组

对象

对象数组

集合

文件的操作

2. 使用File类操作文件或目录

java.io.File类。

需求：获取某个文件的大小。

常用的API

1. long length(); 获取文件的大小 单位：字节
2. boolean exists(); 判断文件/目录是否存在
3. boolean isFile(); 判断是否是文件
4. boolean isDirectory(); 判断是否是目录
5. String getPath(); 获取相对路径
6. String getAbsolutePath(); 获取绝对路径
7. boolean delete(); 删除空文件夹 、 文件
8. boolean createNewFile(); 创建【文件】
9. boolean mkdir(); 创建文件夹
10. String getName(); 获取文件名，带有扩展名
11. list等…

---

// 1.创建文件对象 
		// File("D:\\a.txt");
		File file = new File("d:/a.txt");
	
		// 判断是否存在
		if(file.exists()) {
			// 判断是否是文件
			if(file.isFile()) {
				// 2.通过File类的方法 获取指定信息   单位：字节B  
				long length = file.length();
				System.out.println("文件的大小为："+length);
			}else {
				System.out.println("非文件！");
			}
		}else {
			System.out.println("文件不存在！");
		}

1、new File(“d:/a.txt”)创建文件对象的时候 这个文件可能存在 也可能不存在
2、一个字符=两个字节
3、FileInputStream 创建文件的时候 文件如果不存在 会报错

下面介绍了几种创建文件的方式及相关api的使用

---

             // 1.创建文件对象  
				// p1：父路径   p2：子路径
				File file = new File("d:\\", "a.txt");
				
				// 2.获取文件名
				String name = file.getName();
				System.out.println("文件/文件夹名："+name);
				//输出a.txt
				// 删除文件/文件夹【只能删除空文件夹、文件】 （不会进入回收站  直接永久删除）
				if(file.delete()) {
					System.out.println("删除成功！");
				}else{
					System.out.println("删除失败！");
				}

---

        File file1 = new File("d:\\");
		// p1：父路径的File对象  p2：子路径
		// 这些构造出现的目的 是为了丰富你未来创建的方式     因为后期有可能获取到指定的一个父路径文件对象  你还需要在此路径下创建其他的东西
		File file = new File(file1, "b");
		
		// 判断文件是否存在
		if(!file.exists()) {
			System.out.println("文件不存在");
			// 只能创建文件
			if(file.createNewFile()) {
				System.out.println("创建文件成功！");
			}else {
				System.out.println("创建文件失败！");
			}
		}else {
			System.out.println("文件存在！");
		}
		
		// file.mkdir()

---

/*File file = new File("b.txt");
		// file.createNewFile();
		// 获取绝对路径
		String absolutePath = file.getAbsolutePath();
		System.out.println(absolutePath);
		// 相对路径
		String path = file.getPath();
		System.out.println(path);*/
		
		// 当你创建文件输入的是绝对地址   此时获取相对和绝对路径结果都是一样的
		File file = new File("d:/b.txt");
		String absolutePath = file.getAbsolutePath();
		String path = file.getPath();
		System.out.println(absolutePath);
		System.out.println(path);

d盘下 有文件夹a a下面有一个b.txt
相对路径 a\b.txt (理解为有一个参照物 )
绝对路径 d:\a\b.txt

3. 理解流的概念和分类

流：（电流、水流、车流）乃至于我们计算机世界中的数据流。

它所代表的是一组有序的数据序列。 以先进先出的形式进行传递（流动）。

1. 输入流（读）
2. 输出流（写）

inputstream outputstream都是抽象类

4. 会使用字节流读写文本文件

InputSteam（父类是抽象类 没有办法创建对象，找他的子类fileInputStream）
-> FileInputStream 字节输入流

构造：

​ FileInputStream(File file);

​ FileInputStream(String path);

常用方法：

​ int read(); 从输入流中读取一个字节数据

​ int read(byte[] b); 从输入流中读取字节数组b长度的字节数据，会将读取到的字节数据存储到字节数组中。返回值是真正读取到的总字节数量。

​ int read(byte[] b,int offset,int length); 从输入流中读取指定索引开始 指定长度的字节数据。

​ void close(); 关流！！！！！

​ int avaliable(); 返回可读取到的字节数量

---

---

		// 1.创建字节输入流对象
		try (FileInputStream fis = new FileInputStream("d:/b.txt");) {
			// 2.读取字节数据
			//规范写1024
			byte[] b = new byte[1024];
			// 读取一个字节数组长度的字节数据 返回值返回的是实际读取的字节数量
			int read = fis.read(b);//这里可以直接fis.read(b) 不需要返回 不能去掉 否则读不出来数据
			System.out.println(read);//输出3 因为b.txt里面内容为aAc
			//---------------------------------------------------------
			//保存的数据在read变量里面
			
			
			/*
			 * for (byte c : b) { System.out.println(c); }
			 */
			// 利用字符串的构造 将字节数组转换为字符串内容
			String string = new String(b);
			System.out.println(string);//此时输出的内容就和记事本中的一样aAc但是后面却有很多空格  选中以后才能看见
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
	     	fis.close();
		}

---

		FileInputStream fis = new FileInputStream("d:/b.txt");
		// 获取指定文件的可读字节数
		int available = fis.available();
		System.out.println(available);
		byte[] b = new byte[available];
		
		// 读取到字节数组中
		fis.read(b);
		
		String str = new String(b);
		System.out.println(str);
		
		// 关流！！！！
		fis.close();

---

OutputStream -> FileOutputStream 字节输出流

构造：（默认情况下，如果文件不存在 输出流会自动创建文件，并且每一次都会覆盖文件内容）

​ FileOutputStream(File file);

​ FileOutputStream(String path);

​ FileOutputStream(String path,boolean append); 可以继续追加数据

常用方法：

​ void write(int byte); 将一个字节写入输出流

​ void write(byte[] b); 将一个字节数组写入输出流

​ void write(byte[] b,int offset, int length); 将一个字节数组内指定索引开始 指定长度的字节数据写入输出流

​ void close(); 关流！！！

---

try {
			// 如果文件不存在 可以自动创建！  但是每一次写入数据都会进行覆盖！
			// 1.创建字节输出流
			FileOutputStream fos = new FileOutputStream("d:/c.txt");
			
			// 可以追加数据 不会 覆盖
			// FileOutputStream fos = new FileOutputStream("d:/c.txt",true);
			// 2.输出字节
			// fos.write(99);
			byte[] b = {99,98,97,94,95,94};
			//fos.write(b);
			// p2:从此数组的哪个索引开始  p3：输出多少个长度的字节
			fos.write(b, 3, 3);
			// 3.关流
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

---

5.相关jar commons-io

	//d盘下的a.txt复制到e盘下的b.txt  进行复制的时候 文件的内容也在 前提 a.txt必须存在
		try {
			//导入commons-io的jar包
			FileUtils.copyFile(new File("d:/a.txt"), new File("e:/b.txt"));
		} catch (IOException e) {
			e.printStackTrace();
		}

---

需求：利用字节流 将d盘下的a.txt 复制到 e盘下的c.txt

public class Test1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			// 1.指定数据源
			fis = new FileInputStream("d:/a.txt");
			// 2.指定输出目的地
			fos = new FileOutputStream("e:/c.txt");
			
			// byte[] b = new byte[fis.available()];
			byte[] b = new byte[1024];
			int len = 0;
			// 边读边写
			// 循环读取输入流  每次读取1024个字节数据
			while((len = fis.read(b)) != -1) {
				fos.write(b,0,len);
				//或者fos.write(b);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			// 3.关流
			try {
				// 先开的后关
				if(fos != null) {
					fos.close();
				}
				if(fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}