慕课网_文件传输基础——Java IO流

第1章 文件的编码

1-1 文件的编码 (15:07)

第2章 File 类的使用

2-1 File 类常用 API 介绍 (10:50)

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

public class FileDemo {
	public static void main(String[] args) {
		File file = new File("E:\helloworld\java");
		System.out.println(file.exists());// 判断文件/文件夹是否存在

		if (!file.exists()) {
			file.mkdirs();// 创建目录
		} else {
			file.delete();
		}

		// 是否是一个目录
		System.out.println(file.isDirectory());

		// 是否是一个文件
		System.out.println(file.isFile());

		File file2 = new File("E:\helloworld\1.txt");
		if (file2.exists()) {
			try {
				file2.createNewFile();// 创建文件
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			file2.delete();
		}

		System.out.println(file);// file.toString()的内容
		System.out.println(file.getAbsolutePath());
		System.out.println(file.getName());
		System.out.println(file.getParent());
	}
}

2-2 遍历目录 (10:26)

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

//列出File的一些常用操作比如过滤、遍历等操作

class FileUtils1 {
	/*
	 * 列出制定目录下（包括其子目录）的所有文件
	 */
	public static void listDirectory(File dir) throws IOException {
		if (!dir.exists()) {
			throw new IllegalArgumentException("目录：" + dir + "不存在");
		}
		if (!dir.isDirectory()) {
			throw new IllegalArgumentException(dir + "不是目录");
		}
		String[] filenames = dir.list();// 返回的是字符串数组 直接子的名称，不包含子目录下的内容
		for (String string : filenames) {
			System.out.println(dir + "\" + string);
		}
	}
}

class FileUtils2 {
	/*
	 * 列出制定目录下（包括其子目录）的所有文件
	 */
	public static void listDirectory(File dir) throws IOException {
		if (!dir.exists()) {
			throw new IllegalArgumentException("目录：" + dir + "不存在");
		}
		if (!dir.isDirectory()) {
			throw new IllegalArgumentException(dir + "不是目录");
		}
		// 如果要遍历子目录下的内容就需要构造成File对象做递归操作，File提供了直接返回File对象的API
		File[] files = dir.listFiles();// 返回的是直接子目录（文件）的对象
		if (files != null && files.length > 0) {
			for (File file : files) {
				if (file.isDirectory()) {
					listDirectory(file);
				} else {
					System.out.println(file);
				}
			}
		}
	}
}

public class FileUtilTest {
	public static void main(String[] args) throws IOException {
		FileUtils2.listDirectory(new File("E:\kms"));
	}
}

第3章 RandomAccessFile类的使用

3-1 RandomAccessFile基本操作 (17:16)

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;

/*
 * java.io.File类用于表示文件（目录）
 * File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问
 * 
 * RandomAccessFile java提供的对文件内容的访问，既可以读文件，也可以写文件。
 * RandomAccessFile支持随机访问文件，可以访问文件的任意位置。
 * 
 * (1)java文件模型
 * 在硬盘上的文件是byte byte byte存储的，是数据的集合
 * 
 * (2)打开文件
 * 有两种模式"rw"（读写）"r"（只读）
 * RandomAccessFile raf=new RandomAccessFile(file,"rw");
 * 文件指针，打开文件时指针在开头pointer=0;
 * 
 * (3)写文件
 * raf.write(int);只写一个字节（后8位），同时指针指向下一个位置，准备再次写入
 * 
 * (4)读文件
 * int b=raf.read();读一个字节
 * 
 * (5)文件读写完成以后一定要关闭（Oracle官方说明）
 */

public class RafDemo {
	public static void main(String[] args) throws IOException {
		File demo = new File("demo");
		if (!demo.exists()) {
			demo.mkdirs();
		}

		File file = new File(demo, "raf.dat");
		if (!file.exists()) {
			file.createNewFile();
		}

		RandomAccessFile raf = new RandomAccessFile(file, "rw");

		// 指针的位置
		System.out.println(raf.getFilePointer());
		raf.write('A');// 只写了一个字节
		
		System.out.println(raf.getFilePointer());
		raf.write('B');

		int i = 0x7fffffff;
		// 用write方法每次只能写一个字节，如果要把i写进去就得写4次
		raf.write(i >>> 24);// 高8位
		raf.write(i >>> 16);
		raf.write(i >>> 8);
		raf.write(i);
		System.out.println(raf.getFilePointer());

		// 可以直接写一个int
		raf.writeInt(i);

		String s = "中";
		byte[] gbk = s.getBytes("gbk");
		raf.write(gbk);
		System.out.println(raf.length());

		// 读文件，必须吧指针移到头部
		raf.seek(0);
		// 一次性读取，把文件中的内容都读到字节数组中
		byte[] buf = new byte[(int) raf.length()];
		raf.read(buf);
		System.out.println(Arrays.toString(buf));

		String s1 = new String(buf, "gbk");
		System.out.println(s1);

		for (byte b : buf) {
			System.out.println(Integer.toHexString(b & 0xff) + " ");
		}

		raf.close();
	}
}

第4章 字节流

4-1 字节流之文件输入流FileInputStream-1 (15:09)

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

/*
 * IO流（输入流、输出流）
 * 字节流、字符流
 * 1.字节流
 * 1)InputStream、OutputStream
 * InputStream抽象了应用程序读取数据的方式
 * OutputStream抽象了应用程序写出数据的方式
 * 2)EOF=end 读到-1就读到结尾
 * 3)输入流基本方法
 * int b=in.read();
 * in.read(byte[] buf);
 * in.read(byte[] buf,int start,int size);
 * 4)输出流基本方法
 * out.write(int b);写出一个byte到流，b的低8位
 * out.write(byte[] buf);将buf字节数组都写入到流
 * out.write(byte[] buf,int start,int size);
 * 5)FileInputStream具体实现了在文件上读取数据
 */

public class IOUtil {
	/*
	 * 读取指定文件内容，按照16进制输出到控制台 并且每输出10个byte换行
	 */
	public static void main(String[] args) {
		try {
			IOUtil.printHex("E:\helloworld\1.txt");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void printHex(String fileName) throws IOException {
		FileInputStream in = new FileInputStream(fileName);
		int b;
		int i = 1;
		while ((b = in.read()) != -1) {
			if (b <= 0xf) {
				System.out.print("0");
			}
			System.out.print(Integer.toHexString(b) + " ");
			if (i++ % 10 == 0) {
				System.out.println();
			}
		}
		in.close();
	}
}

4-2 字节流之文件输入流FileInputStream-2 (08:40)

4-3 字节流之文件输出流FileOutputStream (13:24)

4-4 字节流之数据输入输出流 (11:08)

4-5 字节缓冲流 (17:54)

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

/*
 * BufferedInputStream&BufferedOutputStream
 * 这两个流类位IO提供了带缓冲区的操作，一般打开文件进行写入
 * 或读取操作时，都会加上缓冲，这种流模式提供了IO的性能
 * 从应用程序中把输入放入文件，相当于将一缸水导入到另一个缸水中
 * FileOutputStream->write()方法相当于一滴一滴地把水转移过去
 * DataOutputStream->writeXxx()方法会方便一些，相当于一瓢一瓢把水转移过去
 * BufferedOutputStream->write()方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另一个缸中，性能提高
 */

public class IOUtil {
	public static void main(String[] args) {

		try {
			long start = System.currentTimeMillis();
			IOUtil.copyFileByBuffer(new File("E:\helloworld\1.txt"), new File("E:\helloworld\2.txt"));
			long end = System.currentTimeMillis();
			System.out.println(end - start);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void copyFileByBuffer(File srcFile, File destFile) throws IOException {
		if (!srcFile.exists()) {
			throw new IllegalArgumentException("文件：" + srcFile + "不存在");
		}
		if (!srcFile.isFile()) {
			throw new IllegalArgumentException(srcFile + "不是文件");
		}
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
		int c;
		while ((c = bis.read()) != -1) {
			bos.write(c);
			bos.flush();// 刷新缓冲区
		}
		bos.close();
		bis.close();
	}
}

第5章 字符流

5-1 字节字符转换流 (18:09)

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

/*
 * 字符流
 * 1)编码问题
 * 2)认识文本和文本文件
 * java的文本（char）是16位无符号整数，是字符的Unicode编码（双字节编码）
 * 文件是byte byte byte...的数据序列
 * 文本文件是文本（char）序列按照某种编码方案（utf-8,utf-16be,gbk）序列化位byte的存储结构
 * 3)字符流（Reader Writer）
 * 字符的处理，一次处理一个字符
 * 字符的底层仍然是基本的字节序列
 * 字符流的基本实现
 * InputStreamReader完成byte流解析为char流，按照编码解析
 * OutputStreamWriter提供char流到byte流，按照编码处理
 */

public class IsrAndOswDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream in = new FileInputStream("E:\helloworld\1.txt");
		InputStreamReader isr = new InputStreamReader(in, "utf-8");// 默认项目的编码

		FileOutputStream out = new FileOutputStream("E:\helloworld\2.txt");
		OutputStreamWriter osw = new OutputStreamWriter(out, "utf-8");

		char[] buffer = new char[8 * 1024];
		int c;
		/*
		 * 批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放入buffer.length个 返回的是读到的字符的个数
		 */
		while ((c = isr.read(buffer, 0, buffer.length)) != -1) {
			String s = new String(buffer, 0, c);
			System.out.print(s);
			osw.write(buffer, 0, c);
			osw.flush();
		}
		osw.close();
		isr.close();
	}
}

5-2 字符流之文件读写流 (05:56)

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FrAndFwDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("E:\helloworld\1.txt");
		FileWriter fw = new FileWriter("E:\helloworld\2.txt", true);// true追加
		char[] buffer = new char[2048];
		int c;

		while ((c = fr.read(buffer, 0, buffer.length)) != -1) {
			fw.write(buffer, 0, c);
			fw.flush();
		}

		fw.close();
		fr.close();
	}
}

5-3 字符流的过滤器 (10:25)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/*
 * BufferedReader->readLine一次读一行
 * BufferedWriter/PrintWriter->写一行
 */

public class BrAndBwOrPwDemo {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\helloworld\1.txt")));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\helloworld\2.txt")));
		PrintWriter pw = new PrintWriter("E:\helloworld\3.txt");
		String line;

		while ((line = br.readLine()) != null) {
			System.out.println(line);// 一次读一行，并不能识别换行
			bw.write(line);
			// 单独写出换行操作
			bw.newLine();// 换行操作
			bw.flush();

			pw.println(line);
			pw.flush();
		}

		bw.close();
		pw.close();
		br.close();
	}
}

第6章 对象的序列化和反序列化

6-1 序列化基本操作 (10:30)

6-2 transient及ArrayList源码分析 (12:41)

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

/*
 * 对象的序列化，反序列化
 * 1)对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化
 * 
 * 2)序列化流（ObjectOutputStream），是过滤流-writeObject
 * 反序列化（ObjectInputStream）-readObject
 * 
 * 3)序列化接口（Serializable）
 * 对象必须实现序列化接口，才能进行序列化，否则将出现异常
 * 这个接口，没有任何方法，只是一个标准
 * 
 * 4)transient关键字
 * 	private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
 *  private void readObject(java.io.ObjectInputStream s) throws java.io.IOException,ClassNotFoundException
 *  
 *  java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用transient关键字标记的成员变量不参与序列化过程。
 */

public class ObjectSeriaDemo {
	public static void main(String[] args) throws Exception, IOException {
		// 1.序列化
		String file = "E:\helloworld\1.txt";
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
		Student student1 = new Student("10001", "张三", 20);
		System.out.println(student1);
		oos.writeObject(student1);
		oos.flush();
		oos.close();

		// 2.反序列化
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		Student student2 = (Student) ois.readObject();
		System.out.println(student2);
		ois.close();
	}
}

class Student implements java.io.Serializable {// 需要序列化的类必须implements java.io.Serializable
	private String stuno;
	private String stuname;
	transient private int stuage;// 该元素不会进行jvm默认的序列化，也可以自己完成这个元素的序列化

	public String getStuno() {
		return stuno;
	}

	@Override
	public String toString() {
		return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage=" + stuage + "]";
	}

	public Student(String stuno, String stuname, int stuage) {
		super();
		this.stuno = stuno;
		this.stuname = stuname;
		this.stuage = stuage;
	}

	public Student() {
		super();
	}

	public void setStuno(String stuno) {
		this.stuno = stuno;
	}

	public String getStuname() {
		return stuname;
	}

	public void setStuname(String stuname) {
		this.stuname = stuname;
	}

	public int getStuage() {
		return stuage;
	}

	public void setStuage(int stuage) {
		this.stuage = stuage;
	}

	private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
		s.defaultWriteObject();// 把jvm能默认序列化的元素进行序列化操作
		s.writeInt(stuage);// 自己完成stuage的序列化
	}

	private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
		s.defaultReadObject();// 把jvm能默认反序列化的元素进行反序列化操作
		this.stuage = s.readInt();// 自己完成stuage的反序列化操作
	}
}

6-3 序列化中子父类构造函数问题 (11:43)