第三章 文件和流

版权声明：本文为博主原创文章，未经博主允许不得转载 https://blog.csdn.net/Mythology_px/article/details/81952000

File类：对文件系统的操作

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

/*
 * File的使用一：操作文件
 */
public class D1 {
	public static void main(String[] args) throws IOException {
		// 1.实例化File对象
		File file = new File("C:\\java.txt");
		//2.判断文件是否存在
		if(file.exists()){
			System.out.println("文件已存在！！");
			System.out.println("文件删除ing");
			file.delete();
		}else{
			System.out.println("文件不存在！！");
			System.out.println("文件创建ing");
			// createNewFile( )方法会抛checked异常
			file.createNewFile();
		}

	}
}

import java.io.File;

/*
 * File的使用二：操作目录
 */
public class D2 {
	public static void main(String[] args) {
		// 1.File对象实例化
		File file = new File("C:\\Learn");
		// 2.判断目录是否存在
		if(file.exists()){
			System.out.println("目录已存在！！");
			System.out.println("删除目录ing");
			file.delete();
		}else{
			System.out.println("目录不存在！！");
			System.out.println("创建目录ing");
			file.mkdir();
		}
	}
}

import java.io.File;

/*
 * 文件与文件夹的判断
 */
public class D3 {
	public static void main(String[] args) {
		// 1.File对象实例化
		File file = new File("C:\\java.txt");
		
		// 2.1判断是否是文件
		System.out.println("File操作的路径是否是文件:"+file.isFile());
		// 2.2判断是否是文件夹
		System.out.println("File操作的路径是否是文件夹："+file.isDirectory());
	}
}

import java.io.File;

/*
 * File操作文件的方法
 */
public class D4 {
	public static void main(String[] args) {
		// 1.File对象实例化
		File file = new File("C:\\java.txt");
		// 2. 判断文件是否可读
		System.out.println("是否可读？"+file.canRead());
		// 3. 判断文件是否可写
		System.out.println("是否可写？"+file.canWrite());
		// 4. 文件大小
		System.out.println("文件大小："+file.length());
		// 5. 最后一次修改时间
		System.out.println("修改时间"+file.lastModified());
		// 6. 修改文件名称
		File newFile = new File("C:\\java.java");
		file.renameTo(newFile);
		
	}
}

import java.io.File;

/*
 * File操作文件夹的方法
 */
public class D5 {
	public static void main(String[] args) {
		// 1.File对象实例化
		File file = new File("C:\\Learn\\java");
		// 2.获取路径
		System.out.println("获取绝对路径:"+file.getAbsolutePath());
		System.out.println("获取相对路径:"+file.getPath());
		// 3.返回上一级
		System.out.println("文件上一级目录："+file.getParent());
		// 4.获取名称
		System.out.println("获取文件名或者文件夹名称:"+file.getName());
		// 5.获取空间大小
		File space = new File("C:\\");
		System.out.println("总空间："+space.getTotalSpace()/1024/1024/1024+"G");
		System.out.println("剩余空间："+space.getFreeSpace()/1024/1024/1024+"G");
		// 6.获取子文件夹
		File[] list = space.listFiles();
		// 6.1 遍历
		for (File f : list) {
			System.out.println(f.getName());
		}
	}
}

I/O流

定义：如果一个类是用来完成程序和设备之间的数据传输，则这个类有一个特殊的称谓叫流

    流和类的关系：流一定是类，但类不一定是流

分类：

           输入流  输出流

           字节流 字符流

           原始流 包裹流

  常用流的介绍：

      四大基本抽象流

           InputStream       OutputStream

           Reader            Writer

           字节流和字符流的区别：字节流可以处理所有格式的文件；字符流只能处理文本格式的文件

           文件流

           FileInputStream      FileOutputStream

           FileReader            FileWriter

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

/*
 * 字节流：
 * 		文件字节输入流
 */
public class D1 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\java.txt");
		// 2.文件字节输入流
		FileInputStream fis = new FileInputStream(file);
		// FileInputStream fis = new FileInputStream("C:\\java.txt");

		// 3.读入数据

		/************* 方式一：逐字节读入 *************/
		// int data ;
		// while( (data = fis.read())!= -1){
		// char ch = (char) data ;
		// System.out.print(ch);
		// }
		// System.out.println();

		/************* 方式二：字节数组一次性读入 *************/
		// byte[] bs = new byte[fis.available()];
		// fis.read(bs);
		// String str = new String(bs);
		// System.out.println(str);

		/************* 方式三：字节数组逐步读入 *************/
		// byte[] bs = new byte[2];
		// int len = 0;
		// while ((len = fis.read(bs, 0, bs.length)) != -1) {
		// String str = new String(bs,0,len);
		// System.out.print(str);
		// }

		// 4.关闭流
		fis.close();
	}
}

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.Buffer;
import java.util.Scanner;

/*
 * 字节流：
 * 		文件字节输出流
 */
public class D2 {
	public static void main(String[] args) throws IOException {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一句话：");
		String str = input.next();

		// 1.File对象实例化
		File file = new File("C:/java.txt");
		// 2.文件字节输出流
		FileOutputStream fos = new FileOutputStream(file);
		// FileOutputStream fos = new FileOutputStream("C:/java.txt");

		// 3.写出数据
		/************* 方式一：逐字节写出 *************/
		// byte[] buffer = str.getBytes();
		// for (int i = 0; i < buffer.length; i++) {
		// fos.write(buffer[i]);
		// }
		
		/************* 方式二：字节数组写出 *************/
		byte[] buffer = str.getBytes();
		fos.write(buffer);
		

		
		// 4. 刷新关闭输出流
		fos.flush();
		fos.close();
		
	}
}

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

/*
 * FileWriter:字符输出流
 * 		将用户在控制台输入的一句话，保存到磁盘文件中
 */
public class D1 {
	public static void main(String[] args) throws IOException {
		System.out.println("请输入一句你想存起来的话：");
		Scanner input = new Scanner(System.in);
		String str = input.next();
		// 1.File对象实例化
		File file = new File("C:\\secret.txt");
		// 2.创建文件字符输出流
		FileWriter fw = new FileWriter(file);
		// 3.数据传输
		/***********方式一***********/
		////fw.write(c);----以字符单个循环写出
		/***********方式二：字符串***********/
		fw.write(str);
		/***********方式三：字符数组***********/
		//fw.write(str.toCharArray());
		// 4.资源回收
		fw.flush();
		fw.close();
	}
}

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

/*
 * FileReader:文件字符输入流
 * 		将磁盘文件读入在控制台打印
 */
public class D2 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\secret.txt");
		// 2.创建文件字符输入流
		FileReader fr = new FileReader(file);
		// 3.数据传输
		/*********** 方式一 ***********/
		// // fr.read()---循环单个字符读入
		/*********** 方式二 ***********/
		char[] ch = new char[1024];
		int len = 0;
		while ((len = fr.read(ch)) != -1) {
			String str = new String(ch, 0, len);
			System.out.print(str);
		}
		System.out.println();
		// 4.资源回收
		fr.close();
	}
}

           缓冲流

           BufferedInputStream      BufferedOutputStream

           BufferedReader           BufferedWriter

           缓冲流可以提高数据传输的速度

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

/*
 * 缓冲流:实现文件的拷贝
 */
public class D3 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\1.exe");
		File newFile = new File("D:\\1.exe");
		// 2.创建文件字节流
		FileInputStream fis = new FileInputStream(file);
		FileOutputStream fos = new FileOutputStream(newFile);
		// 3.创建字节缓冲流
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		// 4.数据传输
		/***********方式一***********/
		// int data;
		// while((data = bis.read())!=-1){
		// bos.write(data);
		// }
		/***********方式二***********/
		int len ;
		byte[] buffer = new byte[2048];
		while((len = bis.read(buffer)) != -1){
			bos.write(buffer, 0, len);
		}
		
		System.out.println("拷贝成功！！！");
		// 5.资源回收(先用后关)
		bos.flush();
		bos.close();
		bis.close();
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符缓冲流
 * 		将c盘的文本文件拷贝到D盘
 */
public class D3 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\secret.txt");
		File newFile = new File("D:\\secret.txt");
		// 2.创建字符输入流和对应的字符缓冲流
		FileReader fr = new FileReader(file);
		BufferedReader br = new BufferedReader(fr);
		// 3.创建字符输出流和对应的字符缓冲流
		FileWriter fw = new FileWriter(newFile);
		BufferedWriter bw = new BufferedWriter(fw);
		// 4.数据传输
		// 1. br.read()一个字符
		// 2. br.read(cbuf)字符数组
		// 3. br.read(cbuf, off, len)字符数组，起始位置,总长度
		// 4. readLine
		String buffer = null;
		while ((buffer = br.readLine()) != null) {
			bw.write(buffer);
		}
		System.out.println("拷贝成功！！！");
		// 5.资源回收
		bw.flush();
		bw.close();
		br.close();
	}
}

           数据流

           DateInputStream      DateOutputStream

           数据流可以把基本类型数据的二进制直接读入或写出

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 数据流(二进制流):实现图片的拷贝
 */
public class D4 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\QQ.png");
		File newFile = new File("D:\\QQ.png");
		// 2.创建文件字节输入流和对应的二进制字节输入流
		FileInputStream fis = new FileInputStream(file);
		DataInputStream dis = new DataInputStream(fis);
		// 3.创建文件字节输出流和对应的二进制字节输出流
		FileOutputStream fos = new FileOutputStream(newFile);
		DataOutputStream dos = new DataOutputStream(fos);
		// 4.创建缓冲流
		BufferedInputStream bis = new BufferedInputStream(dis);
		BufferedOutputStream bos = new BufferedOutputStream(dos);
		// 5.数据传输
		byte[] buffer = new byte[1024];
		int len = 0;
		while ((len = bis.read(buffer)) != -1) {
			bos.write(buffer, 0, len);
		}
		System.out.println("拷贝成功！！！");
		// 6.资源回收
		bos.flush();
		bos.close();
		bis.close();
	}
}

           

           转化流

           OutputStreamWriter       InputStreamReader

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 *  字节转换流:可以指定编码集
 *  	InputStreamReader:字节输入流转换字符输入流
 */
public class D4 {
	public static void main(String[] args) throws IOException {
		// 1.File对象实例化
		File file = new File("C:\\java.txt");
		// 2.创建字节输入流
		FileInputStream fis = new FileInputStream(file);
		// 3.创建转换流，指定编码集
		InputStreamReader isr = new InputStreamReader(fis, "GBK");
		// 4.缓冲流
		BufferedReader bis = new BufferedReader(isr);
		// 5.数据传输\
		String buffer = null;
		while ((buffer = bis.readLine()) != null) {
			System.out.print(buffer);
		}
		System.out.println();
		// 6.资源回收
		bis.close();
	}
}

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/*
 *  字节转换流:可以指定编码集
 *  	OutputStreamWriter:字节输出流转换字符输出流
 */
public class D5 {
	public static void main(String[] args) throws IOException {
		String str = "人生总是有很多的岔路，前行就好！";
		// 1.File对象实例化
		File file = new File("C:\\java.txt");
		// 2.创建文件输出流
		FileOutputStream fos = new FileOutputStream(file);
		// 3.创建转换流，指定编码集
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		// 4.缓冲流
		BufferedWriter bw  =new BufferedWriter(osw);
		// 5.数据传输
		bw.write(str);
		// 6.资源回收
		bw.flush();
		bw.close();
	}
}

          Print流

          PrintStream       PrintWriter

          Print流可以把基本类型数据格式化后的字符串输出

          

          Object流

          ObjectInputStream    ObjectOutputStream

          Object流可以把一个对象直接写入或读出

import java.io.Serializable;

/*
 * 封装实现的Student类，实现了serializable可序列化接口
 */
public class Student implements Serializable{
	private String name;
	private String sex;
	private int age;
	
	public Student() {
		super();
	}
	
	public Student(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

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

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/*
 * 对象流:
 * 	1.实现serializable接口
 * 	2.Object流
 * 		实现将对象写入磁盘然后读入到程序控制台
 */
public class D6 {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		Student stu1 = new Student("张三", "男", 18);
		// 1.File对象实例化和文件流
		File file = new File(".\\Student.txt");
		/*
		 * 输入输出流的顺序不可颠倒
		 */
		FileOutputStream fos = new FileOutputStream(file);
		FileInputStream fis = new FileInputStream(file);
		// 2.创建Object流
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		ObjectInputStream ois = new ObjectInputStream(fis);
		// 3.数据传输
		// 3.1 写出
		oos.writeObject(stu1);
		// 3.2读入
		Student stu = (Student) ois.readObject();
		
		System.out.println(stu.getName()+"\t"+stu.getSex()+"\t"+stu.getAge());
		// 4.资源回收
		ois.close();
		oos.flush();
		oos.close();
	}
}