File的使用和 IO流使用

最新推荐文章于 2022-07-29 11:47:29 发布

weng@

最新推荐文章于 2022-07-29 11:47:29 发布

阅读量225

点赞数

本文链接：https://blog.csdn.net/weng74/article/details/96633393

版权

学习专栏收录该内容

9 篇文章 2 订阅

订阅专栏

java IO篇

JAVA File

File 类

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

File(File parent,String child);

通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。

File(String pathname);

filemethod

public class Demo_method {
	
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//案例找到.txt 结尾的文件并打印
		//demo3();
		//file 类 文件名称过滤器 的使用 例子：找到.txt 结尾的文件并打印
		File dir=new File("C:\\Users\\11276\\Desktop\\dnf");
		String[] test=dir.list(new FilenameFilter() {//变成只存在.txt 的数组
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				//System.out.println(dir);
				//System.out.println(name);
				File file=new File(dir, name);
				return file.isFile()&& file.getName().endsWith(".txt");
			}
		});
		for (String string : test) {//string 中是条件成立的
			System.out.println(string);
		}
	}


	private static void demo3() {
		File findFile=new File("C:\\Users\\11276\\Desktop\\dnf");
		File [] findFileList=findFile.listFiles();
		for (File file: findFileList) {
			if(file.isFile()&&file.getName().endsWith(".txt")) {//获得名字
				System.out.println(file);
			}
		}
	}

	
	private static void demo2() {
		File file=new File("ccc.txt");
		/*
		 * System.out.println(file.exists());
		 * System.out.println(file.getAbsolutePath());//获得绝对路径
		 */	
		//getoath();获取构造方法中传入的路径
		System.out.println(file.getPath());
		//length
		System.out.println(file.length());
		//文件的最后修改时间lastModified
		Date d=new Date(file.lastModified());
		System.out.println(d);
		//public String [] list(); 获取名字
			File dir=new File("C:\\Users\\11276\\Desktop\\dnf");
			String [] list=dir.list();
			for (String string : list) {
				System.out.println(string);
			}
			//public File[] listFile(); 获取对象File
			File[] listFile=dir.listFiles();
			for (File file2 : listFile) {
				System.out.println(file2);//可以对其进行操作
			}
	}

	private static void demo1() {
		/**
		 * isDirectory//判断是否为文件夹
		 * isFile/判断是否为文件
		 * exists//是否存在
		 * canread//是否可读
		 * canwrite//是否可写
		 * isgidden//是否是隐藏
		 * 
		 * @param args
		 */
		// TODO Auto-generated method stub
		File dir1=new File("ccc.text");
		System.out.println(dir1.isDirectory());//判断是否为文件夹
		File dir2=new File("zzz");
		System.out.println(dir1.isFile());//判断是否为文件
		System.out.println(dir2.isFile());
		System.out.println(dir1.exists());//是否存在
		dir2.setReadable(false);//不可写
	}

}

IO流

IO常用的子类

字节流的抽象父类：计算机存储的是字节的格式

inputStream:

Fileinput Stream

public static void main(String[] args) throws IOException {
	//读取的方法1 read(); 返回的类型为int ，
    //不是byte ：byte 可能 碰到 byte 的 -1源码
	//demo1();
	//读取的方法2,规范
	FileInputStream fis=new FileInputStream("ccc.txt");
	int b;
	while((b=fis.read())!=-1) {//结束符为-1(读到末尾)
		System.out.println(b);
	}
}

private static void demo1() throws FileNotFoundException, IOException {
	FileInputStream fis = new FileInputStream("ccc.txt");
	int read = fis.read();
	System.out.println(read);
	fis.close();
}

BuffInputStream

#### 原理：

[外链图片转存失败(img-F3I4WCZP-1563628520420)(C:\Users\11276\AppData\Local\Temp\1562654769950.png)]和小型数组的对比：

[外链图片转存失败(img-lyIk3oNm-1563628520421)(C:\Users\11276\AppData\Local\Temp\1562654988033.png)]

小型处理小型数据会跟快点，因为操作的是一个字节数组，而缓存是操作2个字节数组

outputStream:

FileoutputStream

public static void main(String[] args) throws IOException {
	//创建字节输出流
	FileOutputStream fos=new FileOutputStream("yyy.txt",true);
    //续写的append
    */FileOutputStream(String name, boolean append) 
	创建文件输出流以指定的名称写入文件。 
        /*
	fos.write(97); //虽然写出的是int数但是会转化为byte
	fos.write(98);
	fos.close();
}

简单的案例

/**
	 * 简单的数据拷贝案例
	 *把图片ccc复制到ddd中
	 */
方法1：不推荐，因为效率慢
	FileInputStream fis=new FileInputStream("ccc.jpg");
	FileOutputStream fos=new FileOutputStream("ddd.jpg");
	int d;
	while((d=fis.read())!=-1) {//判断是否存在这个图片
		fos.write(d);
	}
方法2：不推荐，因为有可能内存溢出
	available() ：获得文件的字节数
	FileInputStream fis=new FileInputStream("ccc.jpg");
	FileOutputStream fos=new FileOutputStream("bbb.jpg");
	byte[] arr=new byte[fis.available()];
	fos.write(arr);

原理：

[外链图片转存失败(img-F5N8ELTZ-1563628520422)(C:\Users\11276\AppData\Local\Temp\1562590903851.png)]

解决方案：需要一个容器：数组

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
FileInputStream fis=new FileInputStream("ccc.txt");
FileOutputStream fos=new FileOutputStream("yyy.txt");
byte[] arr=new byte[1024];//创建字节数组
int len;//返回值类型为int
while((len=fis.read(arr))!=-1) {//如果不加arr,就会返回字节的码表，不是个数
/*
 * write(byte[] b, int off, int len) 
将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
 */
fos.write(arr, 0, len);
}
fis.close();
fos.close();
}

读取中文(不推荐使用字符流)

public static void main(String[] args) throws IOException {

		// 读中文 ，字符流不好
		//demo1();
		//取中文
		FileOutputStream fos=new FileOutputStream("ccc.txt");
		fos.write("你好".getBytes());//转化为字节
		fos.write("\r\n".getBytes());
		fos.close();
	}
private static void demo1() throws FileNotFoundException, IOException {
	FileInputStream fis=new FileInputStream("ccc.txt");	
	byte[] arr=new byte[3];
	int len;
	while((len=fis.read(arr))!=-1) {
		System.out.println(new String(arr,0,len));
	}
}

1.7的IO流的标准处理异常代码

public static void main(String[] args) throws IOException {
		// 1.7 流的异常处理
			try(
				//实现的autoclose的方法，所以可以这样用
				FileInputStream fis=new FileInputStream("ccc.txt");
				FileOutputStream fos=new FileOutputStream("yyy.txt");
					){
				int d;
				while((d=fis.read())!=-1) {
					fos.write(d);
				}
			}
		//普通的
		FileInputStream fis=new FileInputStream("ccc.txt");
		FileOutputStream fos=new FileOutputStream("yyy.txt");
		int d;
		while((d=fis.read())!=-1) {
			fos.write(d);
		}
		fis.close();
		fos.close();
	}

小练习

练习1拷贝文件到项目文件下

public class Test_1 {
	/**
	 * 拷贝文件到项目文件下
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		File file=getFile();//获得File
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(file.getName()));
		int b;
		while((b=bis.read())!=-1){
			bos.write(b);
		}
		System.out.println("复制成功");
		bis.close();
		bos.close();
	}
	/**
	 * 创建键盘录入对象
	 * 在主方法接受文件
	 * 读和写文件
	 */
	public static File getFile() {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入名称");
		while(true) {
			String line=sc.nextLine();
			File file=new File(line);//把String 封装成File 类型
			if(!file.exists()) {
				System.out.println("路径不存在");
			} else if(file.isDirectory()) {
				System.out.println("输入的是文件夹的，不正确");
			} else {
				return file;
			}
		}
	}
}

练习2录入数据拷贝到文件

public class Test_2 {
	public static void main(String[] args) throws IOException {
		/**
		 * 练习录入数据拷贝到文件
		 */
		//1.创建键盘录入对象
		Scanner sc=new Scanner(System.in);
		//2.创建输出流对象
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("ccc.txt"));
		//进行拷贝文件
		while(true) {
			//接收数据
			String  line=sc.nextLine();
			if("quit".equals(line)) {
				break;
			}else {
				bos.write(line.getBytes());
				bos.write("\r\n".getBytes());
			}	
		}
		bos.close();
	}
}

字符流的抽象父类：（只能拷贝纯文本）

*reader 根据码表进行读字符

Filereader

[外链图片转存失败(img-mDJDdP2T-1563628520422)(C:\Users\11276\AppData\Local\Temp\1562765574030.png)]

public class Demo_FileReader {
	/**
	 * 字符流 FileReader
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		FileReader fir=new FileReader("ccc.txt");
		int x;
		while((x=fir.read())!=-1) {
			System.out.print((char)x);
		}
	}
}

*writer

Filewriter

public class FileWiter {

	/*

	 * 字符流

	 */

	public static void main(String[] args) throws IOException {

		FileWriter fw=new FileWriter("ccc.txt");

fw.write("大家好111");
	
	fw.close();
}
}

字符流的拷贝(不推荐)

public class FileWiter {

	/*

	 * 字符流

	 */

	public static void main(String[] args) throws IOException {

		demo1();

		//字符流的拷贝

		FileReader fr=new FileReader("ccc.txt");

		FileWriter fw=new FileWriter("zzz.txt");

		int c;

		while((c=fr.read())!=-1) {

			fw.write(c);

		}
		fr.close();
		fw.close();//write类中有一个2k的缓冲区，不关闭就不会显示数据

	}

private static void demo1() throws IOException {
	FileWriter fw=new FileWriter("ccc.txt");
	fw.write("大家好111");
	fw.close();
	
	}
}

原因

[外链图片转存失败(img-yqGlxdok-1563628520423)(C:\Users\11276\AppData\Local\Temp\1562846763258.png)]

[外链图片转存失败(img-ecqaZc5Q-1563628520424)(C:\Users\11276\AppData\Local\Temp\1562846986339.png)]

字符流的缓冲

BufferedReader

[外链图片转存失败(img-2sVEYsqM-1563628520425)(C:\Users\11276\AppData\Local\Temp\1562848773616.png)]

BufferedWriter

[外链图片转存失败(img-C9gx9jtw-1563628520425)(C:\Users\11276\AppData\Local\Temp\1562848810762.png)]

readLine()和newLine()

readLIne属于Bufferedreader,newLine属于Bufferedwriter

public static void main(String[] args) throws IOException {

		BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));

		BufferedWriter bw=new BufferedWriter(new FileWriter("yyy.txt"));

		String Line;

		while((Line =br.readLine())!=null) {//包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null 

			bw.write(Line);

			bw.newLine(); //表示\r\n 
						//可以跨平台使用
		}

		br.close();

		bw.close();

}

小练习将文本反转

  public class Demo_test1 {
  public static void main(String[] args) throws IOException {
  	//创建流对象
  	BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));
  
  	//创建集合
  	ArrayList<String> list=new ArrayList<String>();
  	//保存数据
  	String line;
  	while((line=br.readLine())!=null) {
  		list.add(line);
  		System.out.println(list.size());
  	}
  	br.close();
BufferedWriter bw=new BufferedWriter(new FileWriter("fz.txt"));
for(int i=list.size()-1;i>=0;i--) {
	System.out.println(i);
	bw.write(list.get(i));
	bw.newLine();
}
bw.close();
	}
}

BufferedReader 的子类 LIneNumberinputStream:

[外链图片转存失败(img-myozUppH-1563628520428)(C:\Users\11276\AppData\Local\Temp\1562854353768.png)]

public static void main(String[] args) throws IOException {
		LineNumberReader lnr=new LineNumberReader(new FileReader("yyy.txt"));
		String line;
		lnr.setLineNumber(4);//设置行数的开始
		while((line=lnr.readLine())!=null) {
			System.out.println(lnr.getLineNumber()+":"+line);//获得行数的值
		}
}

IO流（装饰设计模式）

public class Demo_装饰设计模式 {

/**
- 装饰设计模式 的好处是耦合性不强
- 被修饰的类的变化和装饰类的变化无关
- @param args
  */
  public static void main(String[] args) {
  	// TODO Auto-generated method stub
  	new wengyanmin(new Student()).code();;
  	
  }
  }
  interface Coder{
  public void code();
  }
  class Student implements Coder{
  @Override
  public void code() {
  	// TODO Auto-generated method stub
  	System.out.println("javaee");
  	System.out.println("javaweb");
  }
  }
  class wengyanmin implements Coder{
  //1,获取被修饰类的引用
  public Student s;
  //2,构造方法中传入被修饰类的对象
  public  wengyanmin(Student s) {
  	this.s=s;
  }
  //3,对功能进行升级	
  @Override
  public void code() {
  	// TODO Auto-generated method stub
  	s.code();
  	System.out.println("android");
   }
}

使用指定的码表读写字符

InputStreamReaber&OutputStreamWriter字节通向字符的桥梁

使用例子：

public class Demo_InputStreamReader {

	public static void main(String[] args) throws IOException, IOException {
		//更高效的读和写
		BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("ccc.txt"),"utf-8"));
		BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("fz.txt"),"utf-8"));
		int b;
		while((b=br.read())!=-1) {
			bw.write(b);
		}
		br.close();
		bw.close();
	}
}

原理：

[外链图片转存失败(img-tg2kMfrc-1563628520429)(C:\Users\11276\AppData\Local\Temp\1562936770796.png)]

练习：获取一个文本上的每个字符出现的次数，将结果写在times.txt上

public class Demo_test2 {
/**
 * 获取一个文本上的每个字符出现的次数，将结果写在times.txt上
 * @param args
 * @throws IOException 
 */
	public static void main(String[] args) throws IOException {
		//1创建一个输入流对象
		BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));
		//创建一map集合
		HashMap<Character, Integer> map=new HashMap<>();
		//读取每一个字符
		int index;//拿到了每一个字符
		while((index=br.read())!=-1) {
			char c=(char)index;//强制转型
			map.put(c,! map.containsKey(c)? 1: map.get(c)+1);
		}
		br.close();
		//创建输出流对象
		BufferedWriter bw=new BufferedWriter(new FileWriter("times.txt"));
		//遍历集合
		for (Character string : map.keySet()) {
			bw.write(string+"="+map.get(string));//打印
			bw.newLine();
		}
		bw.close();
	}
}

####注意：

要保留一个完整的数字例如10：使用字符流， readLine();方法保留一行的数据

练习试用版软件的体验

public class Demo_test3 {
	/**
	 * 试用版软件的体验,一共有10次使用机会
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//创建输入流对象
		BufferedReader br=new BufferedReader(new FileReader("config.txt"));
		//进行数据的转化
		String lian=br.readLine();
		int cs=Integer.parseInt(lian);
		if(cs>0) {
			System.out.println("还有使用次数"+cs--);
			FileWriter fw=new FileWriter("config.txt");
			fw.write(cs+"");
			fw.close();//要注意加，因为Filewriter 中有个小型的缓存区
		}else {
			System.out.println("请购买");
		}
		br.close();
	}
}

file递归

自己调用自己

缺点：占用内存大

优点：不用知道循环次数

注意：构造方法不能使用递归，不一定有返回值，可以有也可以没有v

public class Demo_递归 {
/**
 * 自己调用自己 求阶层！
 * @param args
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int re=1;
		for(int i=1;i<=5;i++){
			re=re*i;
			System.out.println(re);
		}
		System.out.println(fun(5));
	}
	public static int fun(int i) {
		if(i==1) {
			return 1;
		}else {
			int sum=i*fun(i-1);
			return sum;
		}	
	}
}

File递归的练习

public class Demo_test4 {
/**
 * File类练习
 * 需求： 从键盘输入接收一个文件夹路径，打印出文件夹下的.java文件
 * @param args
 */
	public static void main(String[] args) {
		// 接收文件夹名称
		File FileName=getDic();
		//打印文件夹下的所以.java 文件名
		printFileName(FileName);
	}
	/**
	 * 获取文件夹的方法 getDic();
	 */
	public static File getDic() {
		Scanner sc=new Scanner(System.in);
		while(true){
			String line=sc.nextLine();//获取输入的数据
			//进行判断是否是文件夹
			File file=new File(line);
			if(!file.exists()) {
				System.out.println("文件夹不存在");
			}else if(file.isFile()) {
				System.out.println("你输入的是文件名，不是文件夹");
			}else {
				return file;
			}
		}
	} 
	/**
	 * 打印文件夹下的.java文件
	 * print Filename(File FileNamev)
	 */
	public static void printFileName(File FileName){
		File [] saveFile=FileName.listFiles();//获取文件夹，存储到数组中
		for (File file : saveFile) {//过滤器
			if(file.isFile()&&file.getName().endsWith(".txt")) {
				System.out.println(file);
			}else if(file.isDirectory()) {
				printFileName(file);//进行递归，若找到文件夹则进行继续递归 
			}	
		}
	}
}

IO序列流

什么是序列流：可以把多个字节输入流整合成一个，读取这是从第一个开始读，到最后

原理：

[外链图片转存失败(img-D5OoFTtU-1563628520430)(C:\Users\11276\AppData\Local\Temp\1563112725238.png)]

代码：

public static void main(String[] args) throws IOException {
		demo1();
		//方式2
		FileInputStream fis1=new FileInputStream("yyy.txt");
		FileInputStream fis2=new FileInputStream("ccc.txt");
		SequenceInputStream sis=new SequenceInputStream(fis1, fis2);//序列流
		FileOutputStream fos=new FileOutputStream("c.txt");
		int b;
		while((b=sis.read())!=-1) {
			fos.write(b);
		}
		sis.close();
		fos.close();
	}

	private static void demo1() throws FileNotFoundException, IOException {
		//传统方式
		FileInputStream fis1=new FileInputStream("yyy.txt");
		FileOutputStream fos=new FileOutputStream("c.txt");
		int b;
		while((b=fis1.read())!=-1) {
			fos.write(b);
		}
		fis1.close();
		FileInputStream fis2=new FileInputStream("ccc.txt");
		int c;
		while((c=fis2.read())!=-1) {
			fos.write(c);
		}
		fis2.close();
		fos.close();
	}

多个流的整合

public class Demo_SequenceInputStream {
	/**
	 * SequenceInputStream(InputStream s1,InputStream s2);
	 * 
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();
		//多个序列流整合
		FileInputStream fis1=new FileInputStream("a.txt");
		FileInputStream fis2=new FileInputStream("b.txt");
		FileInputStream fis3=new FileInputStream("c.txt");
		Vector<FileInputStream> vector=new  Vector<FileInputStream>();
		vector.add(fis1);
		vector.add(fis2);
		vector.add(fis3);
		Enumeration<FileInputStream> en= vector.elements();//创建枚举，获取枚举的引用
		SequenceInputStream sis=new SequenceInputStream(en);//传递SequenceInputStream构造
		
		FileOutputStream fos=new FileOutputStream("yyy.txt");
		
		int b;
		while((b=sis.read())!=-1){
			fos.write(b);
		}
		sis.close();
		fos.close();
	}

	private static void demo2() throws FileNotFoundException, IOException {
		//序列流
		FileInputStream fis1=new FileInputStream("yyy.txt");
		FileInputStream fis2=new FileInputStream("ccc.txt");
		SequenceInputStream sis=new SequenceInputStream(fis1, fis2);
		FileOutputStream fos=new FileOutputStream("c.txt");
		int b;
		while((b=sis.read())!=-1) {
			fos.write(b);
		}
		sis.close();
		fos.close();
	}

	private static void demo1() throws FileNotFoundException, IOException {
		//传统方式
		FileInputStream fis1=new FileInputStream("yyy.txt");
		FileOutputStream fos=new FileOutputStream("c.txt");
		int b;
		while((b=fis1.read())!=-1) {
			fos.write(b);
		}
		fis1.close();
		FileInputStream fis2=new FileInputStream("ccc.txt");
		int c;
		while((c=fis2.read())!=-1) {
			fos.write(c);
		}
		fis2.close();
		fos.close();
	}
}

IO流（内存输出流）

什么是内存输出流：

该输出流可以向内存中写输入数据，把内存当成一缓存区，写出之后可以一次性获取所以的数据

使用方法：

toByteArray();

toString();

例子：
public class Demo_ByteArrayOutputStream {
	/**
	 * 内存输出流
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//不使用ByteArrayOutputStream 读取中文
		//demo1();
		//使用ByteArrayOutputStream 读取中文
		FileInputStream fis=new FileInputStream("c.txt");
		ByteArrayOutputStream bos=new ByteArrayOutputStream();//使用内存进行存储
		int b;
		while((b=fis.read())!=-1) {
			bos.write(b);//写到内存当中
		}
		byte [] arr=bos.toByteArray();//将缓冲区的数据全部拿出来，赋值给arr数组
		System.out.println(new String(arr));
		//System.out.println("toString"+bos);
		fis.close();
	}

	private static void demo1() throws FileNotFoundException, IOException {
		FileInputStream fis=new FileInputStream("c.txt");
		byte [] arr=new byte[3];
		int b;
		while((b=fis.read(arr))!=-1) {
			System.out.println(new String(arr,0,b));
		}
	}
}

内存输出流的练习题

/**
 * 定义一个文件输入流，调用read(byte [] b)方法，
 * 将a.txt文件中的内容打印出来 （byte数组大小限制为5）
 * @author 翁艳敏
 *
 */
public class Demo_test5 {
	public static void main(String[] args) throws IOException {
		// 创建文件输入流
		FileInputStream fis=new FileInputStream("c.txt");
		//定义一和字节数组
		byte [] arr=new byte[5];
		//创建内存输出流
		ByteArrayOutputStream bos=new ByteArrayOutputStream();
		//读取数据
		int d;
		while((d=fis.read(arr))!=-1) {
			bos.write(arr,0,d);
		}
		System.out.println(bos);
		fis.close();
	}
}

随机访问流 RandomAccessFile() 了解

public class Demo_ReadomAccessFile {
/*
 * 随机读取
 * 应用多线程下载
 */

	public static void main(String[] args) throws IOException {
		//例子:
		RandomAccessFile raf=new RandomAccessFile("ccc", "rw");
		//第2个参数为 模式 "r" ,"rw" read ,write
		//读和写都可以
		raf.seek(1);//在指定位置设置指针
		raf.close();
    }
}

对象操作流 ObjecOutputStream

personBean:
package Bean;

import java.io.Serializable;

public class Person  implements Serializable{//要实现这个接口
	private  String name;
	private  int age;
	
	

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}	

}

public class Demo_ObjectOutputStream {
	/**
	 * 序列化操作（写入）
	 * 比如游戏就是退出时进行拿数据写到服务器上一样
	 * @param args
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		/*
		 * Person p1=new Person("weng", 22); Person p2=new Person("yan", 23); //Bean
		 * 要实现Serializable 序列化 ObjectOutputStream oos=new ObjectOutputStream(new
		 * FileOutputStream("c.txt")); oos.writeObject(p1); oos.writeObject(p2);
		 * oos.close();
		 */
		//反序列化，就是登陆游戏
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("c.txt"));
		Person p1=(Person) ois.readObject();
		Person p2=(Person) ois.readObject();
		System.out.println(p1);
		System.out.println(p2);
		ois.close();
	}
}

优化对象操作

比如，只写了2个对象，但输出了3个对象，就会报错说读取到末尾错误

使用容器

		//进行优化
		//序列化
		Person p1=new Person("1", 23);
		Person p2=new Person("2", 21);
		Person p3=new Person("3", 23);
		Person p4=new Person("4", 24);
		//创建容器
		ArrayList<Person> arr=new ArrayList<Person>();
		arr.add(p1);
		arr.add(p2);
		arr.add(p3);
		arr.add(p4);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("c.txt"));
		oos.writeObject(arr);	
		//反序列化		
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("c.txt"));
		ArrayList<Person> list= (ArrayList<Person>) ois.readObject();
		for (Person person : list) {
			System.out.println(person);
		}
		oos.close();
		ois.close();
	}

Bean 实现了Serializable 得最好加个ID

private static final long serialVersionUID = 1L;//生成Id号在未存档就读档的情况下可以将原因显示出来
注意要先存档，后读档就不会有问题

数据输入流和输出流

DataInputStream &DatOutputStream

用法：

public static void main(String[] args) throws IOException {
		// 创建一个数据输出流 和对象流一样
		//开发用的很少
		DataOutputStream dos=new DataOutputStream(new FileOutputStream("c.txt"));
		dos.writeInt(999);
		dos.close();
			DataInputStream dataInputStream=new DataInputStream(new FileInputStream("c.txt"));
			int x= dataInputStream.readInt();
		System.out.println(x);
		dataInputStream.close();
	}

打印流属于字节流

[外链图片转存失败(img-DLENGbRi-1563628520431)(C:\Users\11276\AppData\Local\Temp\1563411812353.png)]

public static void main(String[] args) {
		//打印流 printStream
		System.out.println("aaa");
		PrintStream ps=System.out;//获取标记输出流
		ps.println(97);   //转化为String 并打印 toString
		ps.write(97);	//查找码表
		Person person=new Person("aaa",23);
		ps.print(person);//打印引用数据类型 如果是null 就null 反之打印toString
		ps.close();
	}
//自动刷新功能(没用)
public static void main(String[] args) throws IOException {
		//打印流 printStream
		//demo1();
		PrintWriter pw=new PrintWriter(new FileOutputStream("c.txt"),true);
		pw.print(97);
		pw.println(87);//代有自动刷新功能
	}

总结下：

对象流（objectStream），打印流(printStream)，数据流(DataStream)

都类似游戏读档，和取档

比如游戏就是退出时进行拿数据（out）写到服务器上一样

登陆就要输入到服务器 (inp)

和字符流，字节流不一样

2种键盘录入的方法

	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//可以不用关流，因为	没和键盘产生关联
		//InputStreamReader  是字节转化为字符的桥梁
		String lin=br.readLine();
		System.out.println(lin);
		br.close();
		//2
		Scanner sc=new Scanner(System.in);
		String line=sc.nextLine();
		System.out.println(line);

IO流（properties）的使用

使用方法： load store 和properties 的基本用法

public class Demo_Properties {

	/**
	 * properties 是Hashtable 的子类
	 * properties 基本使用都是字符串
	 * @param args
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException, IOException {
		// TODO Auto-generated method stub
		//demo1();
		//demo2();
		//有关properties 的方法 ；load() store()
		Properties prop=new Properties();
		System.out.println("读取前"+prop);
		prop.load(new FileInputStream("config.properties"));
		//修改参数
		prop.setProperty("yan", "11111");
		//修改完要写入到文件中去
		prop.store(new FileOutputStream("config.properties"),null);//写入的相当于是日志
		System.out.println(prop);
		
	}

	private static void demo2() {
		//保存和遍历
		Properties prop=new Properties();
		prop.put("1", "1");
		prop.put("2", "2");
		//遍历
		Enumeration<String> en=(Enumeration<String>) prop.propertyNames();
		while(en.hasMoreElements()) {
			String key=en.nextElement();
			String val=prop.getProperty(key);
			System.out.println(key+"="+val);
		}
	}

	private static void demo1() {
		Properties prop=new Properties();
		prop.put("abc", 1);
		System.out.println(prop);
	}
}

FIle递归练习综合

1，统计文件，和文件夹的大小

public class Demo_test6 {
	/**
	 * 统计文件和文件夹的大小
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		File file=getFile();
		System.out.println(sunFileSize(file));
	}

	/**
	 * 键盘获取一个文件夹路径
	 * getFile()
	 * @return
	 */
	public static File getFile() {
		// 1创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("输入文件夹路径");
		while (true) {
			String ScName = sc.nextLine();
			// 封装成File
			File file = new File(ScName);
			if (!file.exists()) {// 不是
				System.out.println("输入的不是文件");
			} else if (file.isFile()) {
				System.out.println("输入的是文件不是文件夹");
			} else {
				return file;
			}
		}
	}
	/**
	 * 统计文件的大小
	 * sumFileSize
	 */
	public static Long sunFileSize(File file){
		//定义一个求和的变量
		Long sum=0l;
		//获取到文件和文件夹listfiles();
		File[] files=file.listFiles();
		//遍历数组
		for (File filename : files) {
			//进行判断是文件还是文件夹
			if(filename.isFile()) {
				sum=sum+filename.length();
			}else {
				sum=sum+sunFileSize(filename);//递归调用
			}
		}
		return sum;		
	}	
}

2，File类递归删除文件夹

public class Demo_test7 {
/**
 * 删除键盘录入的文件夹
 * 注意：删除不走回收站的,
 * 思路： 先删除文件再删除文件夹
 * 使用递归的方法
 * @param args
 */
	public static void main(String[] args) {
		// 获取文件夹
		File FileName=Demo_test6.getFile();
		//删除键盘录入的文件夹
	}
	public static void deleteFile(File FileName) {
		//获取文件夹和文件
		File [] files =FileName.listFiles();
		for (File deletefile : files) {
			//是文件就直接删除
			if(deletefile.isFile()) {
				deletefile.delete();
			}else{
			//是文件夹，递归调用	
				deleteFile(deletefile);
			}			
		}
		//循环完把空文件夹删除
		FileName.delete();
	}
}

3，模拟拷贝文件

public class Demo_test8 {
/**
 * 模拟拷贝文件
 * @param args
 * @throws IOException 
 */
	public static void main(String[] args) throws IOException {
		// 接收2个文件夹路径，
		//把其中的一个文件夹中内容拷贝到另外的一个当中
		File fz=Demo_test6.getFile();
		File kb=Demo_test6.getFile();
		//创建方法copy(fz,kb)
		copy(fz, kb);
	}
	/**
	 * 拷贝的方法
	 * copy(fz,kb)
	 * @throws IOException 
	 */
	public static void copy(File fz,File kb) throws IOException {
		//再目标文件中创建原文件夹
		//File newDir=new File(kb, fz.getName());
		kb=new File(kb, fz.getName());
		int sum=1;
		//把这个路径创建出来（*）
		//newDir.mkdir();
		kb.mkdir();
		//获取源文件保存到File 数组中
		File [] saveFile =fz.listFiles();//获得原文件中的内容
		for (File file : saveFile) {
			//如果是文件就继续拷贝
			if(file.isFile()) {
			//IO流
				BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
				BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File(kb, file.getName())));
				int b;
				while((b=bis.read())!=-1) {
					bos.write(b);
				}
				bis.close();
				bos.close();
			}else {
				copy(file, kb);
			}
		}
		System.out.println("复制完成"+sum++);
	}
}

4,把文件夹中的所以文件以及文件夹的名字按层级打印

import java.io.File;

/**
 * 把文件夹中的所以文件以及文件夹的名字按层级打印
 * @author 翁艳敏
 *
 */
public class Demo_test9 {
	public static void main(String[] args) {
		//接收一个文件夹
		File dir= Demo_test6.getFile();
		printFile(dir,0);
	}
	/**
	 * 打印文件的层级的方法printFile(File dir)
	 * 返回值： void 
	 * 参数：(File dir,int sum)
	 * @param dir
	 */
	public static void printFile(File dir,int sum) {
		//获取所有文件，及文件夹
		File [] sumFile =dir.listFiles();
		//遍历
		for (File file : sumFile) {
			for(int i=0;i<=sum;i++) {
				System.out.print("\t");
			}
			System.out.println(file);
			if(file.isDirectory()) {
				printFile(file,sum+1);//不用sum++ 因为sum++ 会把原来的值也改变掉
			}
		}
	}
}
 
output
输入文件夹路径
E:\test1
	E:\test1\one.txt
	E:\test1\test2
		E:\test1\test2\1111.txt
		E:\test1\test2\test22