java初学笔记09-IO流

1.java.io.File类的使用

java.io.File类: 文件和目录路径名的抽象表示形式, 与平台无关
File 能新建、删除、重命名文件和目录, 但File不能访问文件内容本身。如果需要访问文件内容本身, 则需要使用输入/ 输出流。
File对象可以作为参数传递给流的构造函数
File类的常见构造方法:

• public File(String pathname)
  以pathname为路径创建File对象, 可以使绝对路径或者相对路径, 如果pathname是相对路径, 则默认的当前路径在系统属性user.dir中存储。

• public File(String parent, String child)
  以parent为父路径, child为子路径创建File对象。

File的静态属性String separator存储了当前系统的路径分隔符。
在UNIX中, 此字段为’/’, 在Windows中, 为’\’
java中,文件了路径分隔符可以用"/“或者”\"或者"File.separator"表示

import java.io.File;	//File类只能操作文件名和目录,对文件内容本身操作需要使用输入/输出流
import java.io.IOException;

public class TestIO {
	public static void main(String[] args) {
		File f = new File("D:\\work\\text.txt");//对象f就是text.txt文件,存储文件名和目录路径名
		File f4 = new File("D:\\work");//对象f4就是"D:\\work"目录,存储目录(文件夹)名和路径
		//File f2 = new File("D:/work/text.txt");
		//File f2 = new File("D:"+File.separator+"work/text.txt");
		//File f3 = new File("D:","work\\text.txt");//也可以使用(父路径,子路径)表示文件路径,使用相对较少
		
		//注意:"\"在文件中是路径分隔符,但是在java字符中,"\"表示表示转义符,所以路径分隔符要用"\\"或者"/"或者File.separator表示

		System.out.println(f.getName());
		
		File f5 = new File("work\\text.txt");
		System.out.println(f5.getPath());//获得路径
		System.out.println(f5.getAbsolutePath());//获得绝对路径,默认为workspace/Javatest/文件夹下的路径
		
		System.out.println(f5.getAbsoluteFile());//返回一个用当前文件的绝对路径构建的File对象
		System.out.println(f5.getParent());//返回当前文件或者文件夹的父级路径
		f5.renameTo(new File("E:\\workspace\\Javatest\\work\\text2.txt"));//给文件或者文件夹重命名
		System.out.println(f5.exists());//f5已被重命名为新文件,f5不存在
		
		System.out.println(f4.canRead());//判断是否可读
		System.out.println(f4.canWrite());//判断是否可写
		System.out.println(f4.isFile());//判断是否为文件
		System.out.println(f4.isDirectory());//判断是否为文件夹
		System.out.println(f4.lastModified());//获取文件的最后修改时间(返回的是毫秒数)
		System.out.println(f4.length());//返回文件长度(单位为字节数)
		
		if(!f5.exists()) {//判断文件是否存在
			try {
				f5.createNewFile();//创建新的文件
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		f5.delete();//删除文件
		File f6 = new File("D:\\a\\b\\c");
//		f6.mkdir();//在已有目录下创建单层目录,如果使用这个方法创建多层目录,就要一层一层地创建
//		f6.mkdirs();//可以直接创建多层目录
		File f7 = new File("E:\\workspace\\Test");
		String[] flist = f7.list();		//f7.list返回当前文件夹的子集的名称,包括目录和文件,再传递给flist集合
		for (String s : flist ) {		//遍历循环,(输出f7目录下的所有文件文件夹名称)
			System.out.println(s);
		}
		
		File[] fs = f7.listFiles();		//f7.listFiles返回当前文件夹的子集的file对象,包括目录和文件,再传递给fs集合
		for (File s : fs ) {			//遍历循环,(输出f7目录下的所有文件文件夹对象,即路径)
			System.out.println(s);
		}	
	} 
}

递归循环遍历目录下所有文件夹和文件:

public class TestFile {
	public static void main(String[] args) {
		//遍历d盘下的test文件, 把test文件下的所有层级下的目录和文件遍历出来
		//采用递归的方式来实现
		File f8 = new File("E:\\workspace\\Javatest\\src");
		new TestFile().testRecursive(f8);
	}
	 
	/**
	 * 递归遍历文件
	 * @param file
	 */
	public void testRecursive(File file) {//后面的代码循环
		if (file.isFile()) {
			System.out.println(file.getAbsolutePath()+"是文件");
		}else {
			System.out.println(file.getAbsolutePath()+"是文件夹");
			//如果是文件夹,文件夹里可能有文件夹或子文件
			File[] fs = file.listFiles();//获取当前文件夹下的子文件夹或者对象
			if(fs != null && fs.length> 0) {
				for (File ff : fs) {
					testRecursive(ff);	//递归,把ff值传递给file,进行递归循环			
//-------------------------------------------------------------				
//后面的代码会进行重复循环
//					if(ff.isFile()) {
//						System.out.println(file.getAbsolutePath()+"是文件");
//					}else {
//						System.out.println(file.getAbsolutePath()+"是文件夹");
//						//如果是文件夹,文件夹里可能有文件夹或子文件
//						//...
//					}
//-------------------------------------------------------------				
				}
			}
		}
	}
}

2.IO原理及流的分类

1.java IO原理

IO流用来处理设备之间的数据传输。
java程序中, 对于数据的输入/ 输出操作以"流(Stream)"的方式进行
java.io包下提供了各种"流"类和接口, 用以获得不同种类的数据, 并通过标准的方法输入或输出数据。

• 输入input: 读取外部数据(硬盘等存储介质)到程序(内存)中
• 输出output: 将程序(内存)数据输出到(硬盘等存储介质)中

2.流的分类

• 按操作数据单位不同分为: 字节流(8 bit)、字符流(16 bit)
• 按数据流的流向不同分为: 输入流、输出流
• 按流的角色不同分为: 节点流、处理流

java的IO流共涉及40多个类, 实际上非常规则, 都是从如下4个抽象基类派生的。由这四个类派生出来子类名称都是以其父类名作为子类名后缀

(抽象基类)	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

3.文件流

文件流的读写都是基于文件的操作(程序内存与硬盘之间)

文件字节输入流 / 输出流 : FileInputStream / FileOutputStream
文件字符输入流 / 输出流 : FileReader / FileWriter

流在使用完毕后需要进行手动关闭, 采用close()方法
关闭流的时候, 与开启顺序相反, 先开后关

1.文件字节流

文字字节流非常通用, 可以操作字符的文档, 还可以操作任何其他类型文件(如图片、压缩包等等)
文字字节输入流操作:
首先创建文件字节输入流对象

• 创建一个临时存放数据的字节数组, 来接收文件字节输入流
• read()方法 : 读取文件字节流到指定数组
• read()方法 : 读取文件字节流时有一个返回值, 返回值是读取的数据的字节长度, 直到读取完最后一个字节, 还会向后读取一位并返回值-1, 以表示文件被读取完毕
• 结合read()方法与循环结构, 以指定长度的数组通过多次将随机长度的文件读取完毕

文字字节输出流操作:
首先创建文件字节输出流对象

• out.write(str.getBytes());//将一个字符串转化为一个字节数组byte[],再把数据写到内存
• out.flush();//把内存中的数据刷写到硬盘上

文件复制操作, 先输入, 后输出

• 结合read()方法与循环结构, 读取随机长度的文件, 并将其刷写到指定的目录文件, 完成文件复制操作

注意:

• 在写入文件时, 如果目录下有同名文件会被覆盖(默认)
  //public FileOutputStream（String name，boolean append）
  //创建输出流对象时, 逻辑值append默认为false且隐藏, 写入的字节数据覆盖文本原来的内容。
  //将逻辑值改为ture, 即写入数据追加到原来文本的末尾
• 在读取文件时, 如果文件不存在将出现异常

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class TestFileIO {
	public static void main(String[] args) {
		TestFileIO.testFileInputStream();
		TestFileIO.testFileOutputStream();
		TestFileIO.copyFile("E:\\workspace\\Test\\tx2.txt","E:\\workspace\\Test\\tx3.txt");
	}
	
	/**
	 * 这是文件字节输入流FileInputStream
	 */
	public static void testFileInputStream() {
		try {
			FileInputStream  in = new FileInputStream("E:\\workspace\\Test\\tx1.txt");
			
			byte[] b = new byte[3];//字节流,创建一个字节类数组来接收读取的文件的内容
		
//			in.read(b);//读取文件字节输入流in的数据到字节数组b
//			System.out.println(new String(b));//转换成字符串输出
			
			int len = 0;//设置一个读取数据的长度
			while(( len = in.read(b) ) != -1) {
				//in.read()方法有一个返回值,返回值是读取的数据的长度,如果读取到最后一个数据,还会向后读一个,这个时候返回值就是-1
				//也就意味着当in.read()的返回值为-1时,整个文件就读取完毕了
				System.out.println(len);
				System.out.println(new String(b, 0, len));
				//new String(b, 0, len):参数1是缓冲数据的数组,参数2是从数组的哪个位置开始转换字符串,参数3是总共转化几个字节
			}

//			for(int len = 0;len != -1;len = in.read(b)) {
//				System.out.println(len);
//				System.out.println(new String(b, 0, len));
//			}
			
		in.close();//注意: 如果流在使用完毕后一定要关闭
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	/**
	 * 这是文件字节输出流
	 */
	public static void testFileOutputStream() {
		try {
			FileOutputStream out = new FileOutputStream("E:\\workspace\\Test\\tx2.txt");//指定向tx2.txt输出数据
			//public FileOutputStream（String name，boolean append）
			//默认逻辑值append为false,写入的字节数据覆盖文本原来的内容
			//逻辑值为ture, 即写入数据追加到原来文本的末尾FileOutputStream out = new FileOutputStream(inPath,true);
			String str = "551615";
			System.out.println(str.getBytes());//
			out.write(str.getBytes());//把数据写到内存
			out.flush();//把内存中的数据刷写到硬盘上
			out.close();//关闭流
			 
		} catch (Exception e) {
			e.printStackTrace(); 
		}
	}
	/**
	 * 赋值文件到指定位置
	 * @param inpath 文件
	 * @param outpath
	 */
	private static void copyFile(String inpath,String outpath) {
		try {
			FileInputStream  in = new FileInputStream(inpath);//读取的源文件
			FileOutputStream out = new FileOutputStream(outpath);//要复制(写)到的位置
			
			byte[] b = new byte[1];
			
//			while((in.read(b)) != -1) {
//				out.write(b);
//			}
			
			int len = 0;
			while((len = in.read(b)) != -1) {
				out.write(b, 0, len);
				//out.write(b, 0, len);参数1是写的缓冲数组,参数2是从数组的哪个位置开始,参数3是获取的数组的总长度
			}
			
			out.flush();//把写到内存的数据刷写到硬盘
			out.close();
			in.close();
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
}

2.文件字符流

文件字符流只适合操作内容为字符的文件

1.文件字符输入流
读取文件操作步骤:

• 建立一个输入流对象, 将已存在的一个文件加载进流。
  FileReader fr = new FileReader(“Test.txt”);

• 创建一个临时存放数据的字符数组
  char[] ch = new char[1024];

• 调用流对象的读取方法将流中的数据读入到数组中
  fr.read(ch);

2.文件字符输出流:
写入文件操作步骤:

• 建立一个输出流对象, 将需要写入的文件路径加载进流。
  FileWriter fw = new FileWriter(outPath);

• 将要写入文件的字符数据写入内存
  fw.write(text);

• 将内存中的数据刷写到指定目录文件

• fw.flush();

操作与文件字节流基本相似

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

public class TestFileIO {
	public static void main(String[] args) {
		TestFileIO.testFileReader("E:\\workspace\\Test\\tx1.txt"); 
		TestFileIO.testFileWriter("张三李白","E:\\workspace\\Test\\tx4.txt" );
		TestFileIO.testFileCopy("E:\\workspace\\Test\\tx4.txt", "E:\\workspace\\Test\\tx5.txt");
	}
	
	/**
	 * 文件字符输入流
	 * @param inPath
	 */
	public static void  testFileReader(String inPath){
		try {
			FileReader fr = new FileReader(inPath);//创建文件字符输入流的对象
			char[] ch = new char[10];//创建临时存放数据的字符数组
			int len = 0;//定义输入流的读取长度
			while((len=fr.read(ch))!=-1){
				System.out.println(new String(ch,0,len));
			}
			fr.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 文件字符输出流
	 * @param text 输出的内容
	 * @param outPah 输出的文件路径
	 */
	public static void testFileWriter(String text,String outPath) {
		try {
			FileWriter fw = new FileWriter(outPath);
			fw.write(text);
			fw.flush();
			fw.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 字符流拷贝文件,只能操作内容为字符的文件(文本文档.txt)
	 * @param inPath
	 * @param outPath
	 */
	public static void testFileCopy(String inPath,String outPath) {
		try {
			FileReader fr = new FileReader(inPath);
			FileWriter fw = new FileWriter(outPath);
			char[] ch = new char[10];
			
//			int len = 0;
//			while((len = fr.read(ch))!=-1) {
//				fw.write(ch,0,len);
//			}
			
			while((fr.read(ch))!=-1) {
				fw.write(ch);	
			}
			fw.flush();
			fw.close();
			fr.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
}

4.处理流之一: 缓冲流

BufferInputStream / BufferOutputStream / BiufferReader / BufferWriter

数据流的读写都是基于内存的操作
缓冲流是把数据缓冲到内存中

缓冲流的特点:
文件流的读写都是基于文件的操作(程序内存与硬盘之间), 受到硬盘读写速度的制约。
为了提高数据读写的速度, 绕过硬盘, Java API提供了带缓冲功能的流类, 在使用这些流类时, 会创建一个内部缓冲区数组

根据数据操作单位可以把缓冲流分为:

• 缓冲字节流 BufferedInputStream / BufferedOutputStream
• 缓冲字符流 BiufferedReader / BufferedWriter

分别对应文件流的缓冲

缓冲流使用方法:
缓冲流要"套接"在相应的节点流之上, 对读写的数据提供了缓冲的功能, 提高了读写的效率, 同时增加了一些新的方法
对于输出的缓冲流, 写出的数据会先在内存中缓存, 使用flush()方法将内存中的数据写出

因为缓冲流是对内存的读写, 所以要对硬盘中的数据进行读写需要通过文件流, 将包含地址参数的文件流对象传入缓冲流对象, 这就是流的"套接"。

1.缓冲字节流

需要将对应的文件流对象传入缓冲流
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(inPath));

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

public class TestBufferIO {
	public static void main(String[] args) {
		try {
			TestBufferIO.testBufferInputStream();
			TestBufferIO.testBufferOutputStream();
			TestBufferIO.testBufferCopyFile("E:\\workspace\\Javatest\\src\\day20210408\\tt2.txt","E:\\workspace\\Javatest\\src\\day20210408\\tt3.txt");	
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 缓冲字节输入流
	 * BufferInputStream
	 * @throws Exception 
	 */
	public static void testBufferInputStream() throws Exception {//抛出异常
		//文件字节输入流对象
		FileInputStream in = new FileInputStream("E:\\workspace\\Javatest\\src\\day20210408\\tt.txt");
			
		//缓冲字节输入流对象
		BufferedInputStream bin = new BufferedInputStream(in);//把文件流传入缓冲流
		
		byte[] b = new byte[1024];
		int len = 0;
		while((len = bin.read(b))!=-1) {
			System.out.println(new String(b,0,len));
		}
		bin.close();
		in.close();
	}
	/**
	 * 缓冲字节输出流
	 * BufferOutputStream
	 * @throws Exception
	 */
	public static void testBufferOutputStream() throws Exception {
		//文件字节输出流对象
		FileOutputStream out = new FileOutputStream("E:\\workspace\\Javatest\\src\\day20210408\\tt2.txt");
		
		//缓冲字节输入流对象
		BufferedOutputStream bout = new BufferedOutputStream(out);//把文件流传入缓冲流
		String s = "hello world";
		bout.write(s.getBytes());
		bout.flush();
		bout.close();
		out.close();
	}
	public static void testBufferCopyFile(String inPath,String outPath) throws Exception {
	
		//缓冲字节输入流对象
		BufferedInputStream bin = new BufferedInputStream(new FileInputStream(inPath));//把文件流传入缓冲流

		//缓冲字节输入流对象
		BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(outPath));//把文件流传入缓冲流
		byte[] b = new byte[10];
		int len = 0;
		while((len=bin.read(b))!=-1) {
			bout.write(b,0,len);
		}
		bout.flush();
		bout.close();
		bin.close();
	}
}

2.缓冲字符流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class TestBufferIO {
	public static void main(String[] args) {
		try {
			TestBufferIO.testBufferedReader();
			TestBufferIO.testBufferWriter();
			TestBufferIO.testBufferCopy("E:\\workspace\\Javatest\\src\\day20210408\\tt3.txt","E:\\workspace\\Javatest\\src\\day20210408\\tt4.txt");	
		} catch (Exception e) {
			e.printStackTrace();
		}
	}	
	/**
	 * 缓冲字符输入流
	 * @throws Exception
	 */
	public static void testBufferedReader() throws Exception {
		FileReader fr = new FileReader("E:\\workspace\\Javatest\\src\\day20210408\\tt2.txt");
		BufferedReader br = new BufferedReader(fr);
		char[] ch = new char[2];
		int len = 0;
		while ((len=br.read(ch))!=-1) {
			System.out.println(new String(ch,0,len));
		}
		br.close();
		fr.close();
	}
	/**
	 * 缓冲字符输出流
	 * @throws Exception
	 */
	public static void testBufferWriter() throws Exception {
		FileWriter fw = new FileWriter("E:\\workspace\\Javatest\\src\\day20210408\\tt3.txt",true);
		BufferedWriter bw = new BufferedWriter(fw);
		bw.write("张三李四");
		bw.flush();
		bw.close();
		fw.close();
	}
	/**
	 * 缓冲字符复制文件
	 * @param inPath
	 * @param outPath
	 * @throws Exception
	 */
	public static void testBufferCopy(String inPath, String outPath) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader(inPath));
		BufferedWriter bw = new BufferedWriter(new FileWriter(outPath));
		char[] ch = new char[10];
		for(int len=0;len!=-1;len=br.read(ch)) {
			bw.write(new String(ch,0,len));
		}
		bw.flush();
		bw.close();
		br.close();
	}
}

5.处理流之二: 转换流

应用场景:
当字节流的数据都是字符时, 转换成字符流操作更高效
转换流提供了在字节流和字符流之间的转换

Java API提供了两个转换流:
InputStreamReader / OutputStreamWriter

InputStreamReader：将输入的字节流转换为字符流输入。
OutputStreamWriter：将输出的字符流转换为字节流的输出。

以输入流为例:
InputStreamReader 用于将字节流中读取到的字节按指定字符集解码成字符。需要和 InputStream “套接”。

构造方法
例:
InputStreamReader(InputStream in)
public InputStreamReader(InputStream in, String charsetName)
Reader isr = new InputStreamReader(System.in, “UTF-8”)
//参数1是字节流,参数2是编码,把字节流对象转换成字符流对象输入

//txt和java文件常用有三种编码
//ISO8859-1, 西欧编码, 是纯英文编码, 不适应汉字
//GBK和UTF-8, 两种编码适用于中文和英文, 一般使用UTF-8编码

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

public class TestIOStreamRW {
	public static void main(String[] args) throws Exception {
		TestIOStreamRW.testInputStreamReader();//主方法里调用相应方法才能执行
		TestIOStreamRW.testOutputStreamWriter();
	}
	/**
	 * 转换输入流
	 * 注意: 在转化字符流的时候,设置的字符集编码
	 * 要与读取文件的编码一致,否则出现乱码
	 * @throws Exception 
	 */
	public static void testInputStreamReader() throws Exception {
		FileInputStream fin = new FileInputStream("E:\\workspace\\Javatest\\src\\day20210409\\tt.txt");
		//把字节流转换为字符流
		InputStreamReader in = new InputStreamReader(fin,"GBK");//参数1是字节流,参数2是编码格式
//		InputStreamReader in = new InputStreamReader(fin,"UTF-8");//与读取编码GBK(默认)不一致,会出现乱码
		char[] c = new char[100];
		int len;
		while((len=in.read(c))!=-1) {
			System.out.println(new String(c,0,len));
		}
		in.close();
		fin.close();
	}
	/**
	 * 转换输出流
	 * 注意:保证转化文件的编码与读取文件的编码一致,避免乱码
	 * @throws Exception
	 */
	public static void testOutputStreamWriter() throws Exception{
		OutputStreamWriter out  = new OutputStreamWriter(new FileOutputStream("E:\\workspace\\Javatest\\src\\day20210409\\tt2.txt",true),"GBK");
		out.write("你是男是女是男是女\n");
		out.flush();
		out.close();
	}
}

6.处理流之三: 标准输入 / 输出流

• System.in 和 System.out 分别代表了系统标准的输入和输出设备
• 默认输入设备是键盘, 默认输出设备是显示器
• System.in 是标准输入流对象, 它的类型是 InputStream(字节输入流), 是System类下的一个静态变量
• System.out 的类型是 PrintStream, PrintStream是OutputStream(字节输出流)的子类 FilterOutputStream的子类
• 标准输入流一般用 readLine() 方法按行读取数据

**标准输入 / 输出流 的使用基本与文件字节流类似

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;

public class TestSystemIO {
	public static void main(String[] args) {
		try {
//			TestSystemIO.testSystemIn();
			TestSystemIO.testSystemInOut("E:\\workspace\\Javatest\\src\\day20210409\\tt3.txt");
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 标准的输入流
	 * @throws Exception
	 */
	public static void testSystemIn() throws Exception {
		//创建一个接收键盘输入数据的输入流,字节流转换为字符流
		InputStreamReader insr = new InputStreamReader(System.in);//参数是InputStream对象
		//把字符输入流传入缓冲字符输入流
		BufferedReader bin = new BufferedReader(insr);
		String str;//定义一个临时接收数据的字符串
		while((str=bin.readLine())!=null) {
			System.out.println(str);
		}
		bin.close();
		insr.close();
	}
	/**
	 * 把输入内容写到指定txt文件中
	 * 接收到over即结束
	 * @throws Exception
	 */
	public static void testSystemInOut(String outPath) throws Exception {
		//创建一个接收键盘输入数据的输入流
		InputStreamReader insr = new InputStreamReader(System.in);//参数是InputStream对象
		//把输入流传入缓冲流
		BufferedReader bin = new BufferedReader(insr);
		//创建一个输出流
		BufferedWriter bw = new BufferedWriter(new FileWriter(outPath,true));
		String str;//定义一个临时接收数据的字符串
		while((str=bin.readLine())!=null) {//**流的值在每次读取调用后,下次会读取流的下一位数据
			if(str.equals("over") ) {//引用对象判断其值是否相等,要用equals()方法,而不是"=="或"!="
				System.out.println("输入结束");
			}else {
				bw.write(str+'\n');//不是"over",则写入str接收的字符串
				System.out.println(str+"已输入");
			}
		}	
		bw.flush();
		bw.close();
		insr.close();
	}	
}

7.打印流(了解)

PrintStream / PrintWriter
在整个IO包中, 打印流是输出信息最方便的类。
PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法, 用于多种数据类型的输出

• PrintStream和PrintWriter的输出不会抛出异常
• PrintStream和PrintWriter有自动flush功能
• System.out返回的是PrintStream的实例

8.数据流(了解)

DataInputStream / DataOutputStream

为了方便地操作java语言的基本数据类型的数据, 可以使用数据流。
数据流有两个类:
DataInputStream 和 DataOutputStream
分别"套接"在 InputStream 和 OutputStream 节点流上

DataInputStream中的方法:

• boolean readBoolean()
• char readChar()
• byte readByte()
• short readShort()
• int readInt()
• long radLong()
• String readUTF()
• void readFully(byte[] b)

DataInputStream中的方法(同上,read改为write):

注意: 用数据输入流读取数据输出流写到文件中的数据时, 要保证数据类型一致

9.处理流之六: 对象流

ObjectInputStream / ObjectOutputStream
用于存储和读取对象的处理流

应用场景:
对象的持久化——保存对象到硬盘
对象的网络传输

对象序列化机制允许把内存中的java对象转换成平台无关的二进制流, 从而允许把这种二进制流持久地保存在磁盘上, 或通过网络进行传输。当其他程序获取了这种二进制流, 就可以恢复成原来的java对象。

序列化是 RMI (Remote Method Invoke - 远程方法调用) 过程的参数和返回值都必须实现的机制, 而 RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础。

如果需要让某个对象支持序列化, 则必须让其类是可序列化的, 为了让某个类是可序列化的, 该类必须实现如下两个接口之一:

• Serializable
• Externalizable

对象的序列化 / 反序列化

• 序列化(Serialize): 用ObjectOutputStream类将一个java对象写入IO流中
• 反序列化(Deserialize): 用ObjectInputStream类从IO流中恢复该java对象
• ObjectOutputStream和ObjectInputStream不能序列化 static (类的属性) 和 transient 修饰的成员变量

1.对象的序列化

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量
private static final long serialVersionUID;
serialVersionUID用来表明类的不同版本间的兼容性
如果类没有显示定义这个静态变量, 它的值是Java运行环境根据类的内部细节自动生成的。若类的源代码作了修改, serialVersionUID 可能发生变化。一般进行显示声明。
显示定义serialVersionUID的用途

• 希望类的不同版本对序列化兼容, 因此需确保类的不同版本具有相同的serialVersionUID
• 不希望类的不同版本对序列化兼容, 因此需请确保类的不同版本具有不同的serialVersionUID

语句结构:

	ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(ttpath));//定义对象的输出流,把对象序列化后的流放到指定文件中
	Person p = new Person();
	out.writeObject(p);
	out.flush();
	out.close();

2.对象的反序列化

语句结构:

	ObjectInputStream in = new ObjectInputStream(new FileInputStream(ttpath));
	Object obj = in.readObject();//反序列化为Object类对象
	Person p = (Person) obj;//将obj向下转型,造型为Person类对象

注意:对象的序列化和反序列化所使用的类要严格一致,包名、类名、类结构等等

示例:
1.要序列化的对象的类需要实现Serializable接口

import java.io.Serializable;

/**
 * 可以序列化和反序列化的对象
 * @author chenyao
 * 实现Serializable或者Externalizable
 */
public class Person implements Serializable{
	/**
	 * 一个表示序列化版本标识符的静态变量
	 * 用来表明类的不同版本间的兼容性
	 */
	private static final long serialVersionUID = 1L;
	String name;
	int age;
}

2.对象的序列化和反序列化

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 序列化与反序列化
 * 注意:对象的序列化和反序列化所使用的类要严格一致,包名、类名、类结构等等都要一致
 * @author chenyao
 *
 */
public class TestSerial {
	public static void main(String[] args) {
		try {
			TestSerial.testSerialize();
			TestSerial.testDeserialize();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 对象的序列化
	 * @throws Exception 
	 */
	public static void testSerialize() throws Exception {
		String ttpath = "E:\\workspace\\Javatest\\src\\day20210410\\tt.txt";
		//定义对象的输出流,把对象序列化后的流放到指定文件中
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(ttpath));
		//要序列化的对象
		Person p = new Person();
		p.name = "张三";
		p.age = 18;
		
		out.writeObject(p);
		out.flush();
		out.close();
	}
	/**
	 * 对象的反序列化
	 * @throws Exception
	 */
	public static void testDeserialize() throws Exception{
		String ttpath = "E:\\workspace\\Javatest\\src\\day20210410\\tt.txt";
		//定义对象的输入流
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(ttpath));
		Object obj = in.readObject();//反序列化为Object类对象
		Person p = (Person) obj;//再进行造型,向下转型为Person类对象
		System.out.println(p.name);
		System.out.println(p.age);
		in.close();
	}
}

10.随机存取文件流

RandomAccessFile类
支持"随机访问"的方式, 是指程序可以直接跳到文件的任意位置来读、写文件。

• 支持只访问文件的部分内容
• 可以向已存在的文件后追加内容
• 从文件中间或开头写入, 会覆盖原有的内容

RadomAccessFile 对象包含一个记录指针, 用以表示当前读写处的位置。
RadomAccessFile 类对象可以自由移动记录指针:

• long getFilePointer(): 获取文件记录指针的当前位置
• void seek(long pos): 将文件记录指针定位到pos位置

构造器:

• public RandomAccessFile(File file,String mode);
• public RandomAccessFile(String name,String mode);

创建RadomAccessFile类实例需要指定一个mode参数, 该参数指定RadomAccessFile 的访问模式:(常用"r"和"rw")

• “r”: 打开文件仅仅是为了读取数据，如果尝试调用任何写入数据的操作都会造成返回IOException错误信息的问题。
• “rw”: 打开文件用于读写两种操作，如果文件本身并不存在，则会创建一个全新的文件。
• “rwd”: 打开文件用于读写两种操作，这点和”rw“的操作完全一致，但是只会在cache满或者调用RandomAccessFile.close()的时候才会执行内容同步操作。
• “rws”: 在"rwd"的基础上对内容同步的要求更加严苛，每write修改一个byte都会直接修改到磁盘中。

import java.io.RandomAccessFile;

public class TestRandom {
	public static void main(String[] args) {
		try {
			TestRandom.testRadomAccessFileRead();
			TestRandom.testRadomAccessFileWriter();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 随机读取文件流
	 */
	public static void testRadomAccessFileRead() throws Exception {
		String path = "E:\\workspace\\Javatest\\src\\day20210410\\tt2.txt";
		RandomAccessFile ran = new RandomAccessFile(path,"rw");
//		参数1是文件路径,参数2是指定的访问模式:
//		 - "r":		打开文件仅仅是为了读取数据，如果尝试调用任何写入数据的操作都会造成返回IOException错误信息的问题。
//		 - "rw":	打开文件用于读写两种操作，如果文件本身并不存在，则会创建一个全新的文件。
//		 - "rwd":	打开文件用于读写两种操作，这点和”rw“的操作完全一致，但是只会在cache满或者调用RandomAccessFile.close()的时候才会执行内容同步操作。
//		 - "rws":	在"rwd"的基础上对内容同步的要求更加严苛，每write修改一个byte都会直接修改到磁盘中。
//		常用"r"和"rw"
		
		ran.seek(9);//将文件记录指针定位到指定位置,默认为0。
		//注意文档中,字母数字占1个Byte(字节),汉字占2个Byte(定位到汉字第二个字节位置会乱码),换行符占用2个Byte
		System.out.println(ran.getFilePointer());//获取文件记录指针的当前位置
		byte[] b = new byte[100];
		int len = 0;
		while((len = ran.read(b))!=-1) {
			System.out.println(new String(b,0,len));
		}
		ran.close();
	}
	/**
	 * 随机写入文件流
	 */
	public static void testRadomAccessFileWriter() throws Exception{
		String path = "E:\\workspace\\Javatest\\src\\day20210410\\tt2.txt";
		RandomAccessFile ran = new RandomAccessFile(path,"rw");
		ran.seek(6);
//		ran.seek(0);				特殊:0代表从文件开头写入
//		ran.seek(ran.length());			ran.length()代表从文件末端写入
		ran.write("你的".getBytes());//转换成byte数组,写入会覆盖原有内容
		ran.close();
	}
}

小结

流是用来处理数据的
处理数据时, 首先明确数据源, 以及数据目的地

• 数据源可以是文件, 也可以是键盘
• 数据的目的地可以是文件、显示器、以及其他设备

而流只是在帮助数据进行传输, 并对传输的数据进行处理, 比如过滤处理, 转换处理等