【File2】

Kovyi_Mar25

已于 2023-04-20 22:00:25 修改

阅读量94

点赞数

分类专栏： java基础文章标签： java

于 2023-04-16 14:11:27 首次发布

本文链接：https://blog.csdn.net/wrrare/article/details/130182044

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

IO流 I = Input = 输入 O = Output = 输出

流：指的是数据从源点传输到汇点的管道而已

流的分类：
   按照方向分：   输入流输出流       *：参照物：正在写的Java程序
   按照单位分：   字节流字符流
   按照功能分：   节点流过滤流（包装流、处理流）

一起上路：

InputStream   所有字节输入流统一的父类抽象类
   int read()
   int read(byte[] data)
   int read(byte[] data,int off,int len)

OutputStream   所有字节输出流统一的父类抽象类
   write(int data)
   write(byte[] data)
   write(byte[] data,int off,int len)

FileInputStream    输入流字节流节点流
FileOutputStream   输出流字节流节点流
   *: 它们都是节点流构造方法允许传入String路径或者File对象
   *: 虽然它们都是节点流但是只能连接文件（皮肤）
       不能连接目录（石头）否则直接触发异常【拒绝访问！】
   *: FileInputStream 最常用的是 read(byte[])
   *: FileOutputStream 最常用的却是 write(byte[],int,int)
   *: FileInputStream 以-1作为读取结束的标识
   *: FileOutputStream是节点输出流
       节点输出流创建对象的时候如果连接的文件不存在
       也会在创建流的第一时间自动创建出来不需要手建
       其实File类当中有个方法叫createNewFile() 咱没讲
       但是如果连接的目录结构都不存在将直接异常，所以目录结构必须自己建
       File类有个方法叫mkdirs() 一等优先级
   *: FileOutputStream是节点输出流杀伤性极强
       如果连接的文件已经存在
       也会在创建流的那一刻被新的空白文件直接替换
       如果我们的需求是在原有内容的最后追加新内容
       此时构造方法可以传参指定追加模式开启
       new FileOutputStream("abc.txt",true);
   *: 无论何时何地不要让节点输入流和
       节点输出流同时连接同一文件否则怎样都是错
   *: 你要学会标准try catch 和 TWR两种形式处理异常

BufferedInputStream   输入流字节流过滤流
BufferedOutputStream   输出流字节流过滤流
   *: 作为过滤流的它们给原本的节点流添加缓冲空间
       从而提高每次读写的吞吐量进而提高效率
   *: 它们都是过滤流不能直接连接文件只能连接其它的流
   *: 它们构造方法第二个参数都允许指定缓冲空间的大小
       默认8192 也就是8k
   *: BufferedInputStream 最常用的read()
   *: BufferedOutputStream 最常用的write()
   *: BufferedInputStream 以-1作为读取结束的标识
   *: BufferedOutputStream 是带缓冲的输出流
       使用带缓冲的输出流务必注意及时清空缓冲
       以防止数据滞留缓冲空间导致丢失
       缓冲区什么情况下会清空:
           1.满了自动清空无需操作
           2.关闭流的操作会触发清空缓冲
           3.手动清空缓冲主动调用flush();

DataInputStream       输入流字节流过滤流
DataOutputStream   输出流字节流过滤流
   *: 作为过滤流的它们是为了给原本的流
       添加读写基本数据类型的功能的
   *: 它们都是过滤流不能直接连接文件只能连接其它的流

   boolean char byte short int long float double
   *: DataInputStream 提供的核心方法 readXxxx() 有返回值
   *: DataOutputStream 提供的核心方法 writeXxxx() 要参数
   *: DataInputStream 不能再以-1作为读取结束的标识了
       一旦到达文件结尾还继续尝试读取
       将直接触发EOFException => End Of File

ObjectInputStream   输入流字节流过滤流
ObjectOutputStream   输出流字节流过滤流
   *: 作为过滤流的它们是为了给原本的流
       添加读写对象的功能的
   *: 它们都是过滤流不能直接连接文件只能连接其它的流
   *: ObjectInputStream 核心方法 readObject() 有返回值
   *: ObjectOutputStream 核心方法 writeObject() 要参数
   *: ObjectInputStream 同样不能以-1作为读取结束的标识
       如果已经达到文件结尾还继续尝试读取
       将直接触发EOFException
   *: 想要持久化首先需要序列化
       想要被保存到磁盘文件当中的对象它的类型
       必须要实现序列化接口 implements Serializable
       如果要保存的这个对象当中有其它引用类型的属性
       就连这些属性的类型也必须要实现序列化接口
       如果某些属性无关紧要不需要参与持久化存储
       可以使用修饰符transient修饰
           transient => 不参与持久化
   *: 如果想要持久化的是一个集合对象
       则必须保证集合当中的元素的类型必须实现序列化接口
       如果要持久化的是一个使用了比较器的TreeSet或者TreeMap
       就连比较器的类型也要实现序列化接口
       (因为比较器是TreeSet或者TreeMap的一个属性)

import java.io.*;
public class TestFileInputStreamOne{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("abc.txt");
		int data;//一个字节一个字节的读!!!,不是 int len
		while((data = fis.read()) != -1){
			System.out.print((char)data);
		}
	}
}

import java.io.*;
public class TestFileInputStreamTwo{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("abc.txt");
		byte[] data = new byte[3];//配合大数组读取
		int len;
		while((len = fis.read(data)) != -1){
			//打印我们读取到的数据
			for(int i = 0;i < len;i++){
				System.out.print((char)data[i]);
			}
		}
		fis.close();
	}
}

import java.io.*;
public class TestFileCopy{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("src.zip");
		FileOutputStream fos = new FileOutputStream("copy.zip");
		byte[] data = new byte[5<<20];
		int len;
		while((len = fis.read(data)) != -1){
			fos.write(data,0,len);//!!!
		}
		fos.close();//!!!
		fis.close();//!!!
	}
}

import java.io.*;
//TestExceptionPlus3 + TestExceptionPlus4
public class TestFileCopyWithTryCatch{
	public static void main(String[] args){
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try{
			fis = new FileInputStream("src.zip");
			fos = new FileOutputStream("copyTryCatch.zip");
			byte[] data = new byte[5<<20];
			int len;
			while((len = fis.read(data)) != -1){
				fos.write(data,0,len);
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				fos.close();
			}catch(Exception e){
				e.printStackTrace();
			}finally{
				try{
					fis.close();
				}catch(Exception e){
					e.printStackTrace();
				}
			}
		}
	}
}

import java.io.*;
//TWR => Try-With-Resources => 带有资源控制的try catch语法
/*
	定义在小括号当中的资源 会在代码执行离开大括号的时候
		自动的逆向关闭				since JDK7.0
*/
public class TestFileCopyWithTWR{
	public static void main(String[] args)throws Exception{
		try(FileInputStream fis = new FileInputStream("src.zip");
			FileOutputStream fos = new FileOutputStream("copyTWR.zip")){

			byte[] data = new byte[5<<20];
			int len;
			while((len = fis.read(data)) != -1){
				fos.write(data,0,len);//!!!
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

import java.io.*;
public class TestFocus{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("test.txt");
		FileOutputStream fos = new FileOutputStream("test.txt",true);//开启追加模式,但是找不到-1 结束不了

		int data;//一个一个字节的读
		while((data = fis.read()) != -1){
			fos.write(data);
		}
		fos.close();
		fis.close();
	}
}

/*
	请找出c:\\所有的.jpg图片
		并且将其复制到d:\\foto目录当中

		*：foto目录本身并不存在 需要自己用代码建
		*：c盘下不同的子目录当中 可能会有重名的文件 不能直接复制
			在foto目录下 不使用原有文件名 以序列编号命名
				00001.jpg
				00002.jpg
				00003.jpg
				....
*/
import java.io.*;
public class BigOne{
	static int id;
	public static void main(String[] args){
		File dir = new File("d:\\foto");
		if(!dir.exists()){
			dir.mkdirs();
		}
		kill(new File("c:\\"));
	}
	public static void kill(File ff){
		File[] ds = ff.listFiles((x) -> x.isDirectory());
		File[] js = ff.listFiles((x) -> x.isFile() && x.getName().toLowerCase().endsWith(".jpg"));
		if(ds == null) return;
		for(File f: ds){
			kill(f);
		}
		for(File f : js){
			//复制它
			String newName = String.valueOf(++id);
			while(newName.length() < 5){
				newName = "0" + newName;
			}
			newName += ".jpg";

			File tar = new File("d:\\foto",newName);
            
			try(FileInputStream fis = new FileInputStream(f);//!!!
				FileOutputStream fos = new FileOutputStream(tar)){//!!!

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

			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
}

/*
	请找出c:\\所有的.jpg图片
		并且将其复制到d:\\foto目录当中

		*：foto目录本身并不存在 需要自己用代码建
		*：c盘下不同的子目录当中 可能会有重名的文件 不能直接复制
			在foto目录下 不使用原有文件名 以序列编号命名
				00001.jpg
				00002.jpg
				00003.jpg
				....
*/
import java.io.*;
public class BigOneAG{
	static int id;
	public static void main(String[] args){
		createTarget();
		kill(new File("c:\\"));
	}
	//创建目标文件夹的方法
	public static void createTarget(){
		File dir = new File("d:\\foto");
		if(!dir.exists()){
			dir.mkdirs();
		}
	}
	//得到下一个文件名的方法!!!
	public static String nextName(){
		String str = String.valueOf(++id);
		StringBuffer buff = new StringBuffer(str);
		while(buff.length() < 5){
			buff.insert(0,"0");
		}
		buff.append(".jpg");
		return buff.toString();
	}
	//复制文件的方法
	public static void copy(File src,File tar){
		try(FileInputStream fis = new FileInputStream(src);
			FileOutputStream fos = new FileOutputStream(tar)){

				byte[] data = new byte[65536];
				int len;
				while((len = fis.read(data)) != -1){
					fos.write(data,0,len);
				}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	//递归遍历
	public static void kill(File ff){
		File[] ds = ff.listFiles((x) -> x.isDirectory());
		File[] js = ff.listFiles((x) -> x.isFile() && x.getName().toLowerCase().endsWith(".jpg"));
		if(ds == null) return;
		for(File f: ds){
			kill(f);
		}
		for(File f : js){
			String newName = nextName();
			File tar = new File("d:\\foto",newName);
			copy(f,tar);
		}
	}
}

import java.io.*;
public class TestBufferedStream{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("src.zip");
		BufferedInputStream bis = new BufferedInputStream(fis,5<<20);//默认8k

		FileOutputStream fos = new FileOutputStream("BufferedStream.zip");
		BufferedOutputStream bos = new BufferedOutputStream(fos,5<<20);

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

import java.io.*;
public class TestDataStream{
	public static void main(String[] args)throws Exception{
		/*int level = 9999;
		FileOutputStream fos = new FileOutputStream("level.data");
		DataOutputStream dis = new DataOutputStream(fos);
		dis.writeInt(level);//!!!
		dis.close();*/

		FileInputStream fis = new FileInputStream("level.data");
		DataInputStream dis = new DataInputStream(fis);
		int okay = dis.readInt();//!!!
		dis.close();
		System.out.println(okay);
	}
}

import java.io.*;
public class HelloWorld{
	public static void main(String[] args)throws Exception{
		int count = 1;
		File file = new File("count.data");
		//再读档
		if(file.exists()){
			FileInputStream fis = new FileInputStream(file);
			DataInputStream dis = new DataInputStream(fis);
			count = dis.readInt();//!!!
			dis.close();
		}
		if(count > 10){
			System.out.println("请充值后访问");
			return;
		}
		System.out.println("你已经访问了" + count + "次");
		count++;
		//先存档
		FileOutputStream fos = new FileOutputStream(file);
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeInt(count);//!!!
		dos.close();
	}
}

import java.io.*;
public class HelloWorld{
	public static void main(String[] args){
		int time = 1;
		File file = new File("cs.data");
		if(file.exists()){
			try(DataInputStream dis = new DataInputStream(new FileInputStream(file))){
				time = dis.readInt();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		if(time > 10){
			System.out.println("请缴费后继续使用");
			return;
		}
		System.out.println("HelloWorld : " + time);
		time++;
		try(DataOutputStream dos = new DataOutputStream(new FileOutputStream(file))){
			dos.writeInt(time);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

import java.io.*;
import java.util.*;
public class TestObjectStream{
	public static void main(String[] args)throws Exception{

		Date today = new Date();

		FileOutputStream fos = new FileOutputStream("月光宝盒.data");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(today);//!!!
		oos.close();
	}
}

import java.io.*;
import java.util.*;
public class TestObjectStream{
	public static void main(String[] args)throws Exception{
		FileInputStream fis = new FileInputStream("月光宝盒.data");
		ObjectInputStream ois = new ObjectInputStream(fis);
		Object obj = ois.readObject();//!!!
		Date theDate = (Date)obj;//!!!
		ois.close();
		System.out.println(theDate);
	}
}

import java.io.*;
public class TestObjectStreamPlus{
	public static void main(String[] args)throws Exception{

		Teacher tea = new Teacher("JayZhou",36);

		FileOutputStream fos = new FileOutputStream("电冰箱.data");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(tea);
		oos.close();

		/*
		FileInputStream fis = new FileInputStream("电冰箱.data");
		ObjectInputStream ois = new ObjectInputStream(fis);
		Object obj = ois.readObject();
		System.out.println(obj);
		ois.close();
		*/
	}
}
class Computer{
	String logo;
	public Computer(String logo){
		this.logo = logo;
	}
}

class Teacher implements Serializable{//标识
	String name;
	int age;
	//transient => 短暂的 转瞬即逝的 => 不参与持久化的
	transient Computer pc;
	public Teacher(String name,int age){
		this.name = name;
		this.age = age;
		pc = new Computer("Lenovo");
	}
	@Override
	public String toString(){
		return name + " : " + age;
	}
}