转换流,打印流,序列化,反序列化,文件操作(File)

一 转换流

1.1 分类

输入流	输出流
InputStreamReader	OutputStreamWriter

1.2 特点

 转换流是指将字节流向字符流的转换，主要有InputStreamReader和OutputStreamWriter

       1  InputStreamReader主要是将字节流输入流转换成字符输入流

       2 OutputStreamWriter主要是将字节流输出流转换成字符输出流

1.3 InputStreamReader

分类	方法	描述
构造方法	InputStreamReader(InputStream in) InputStreamReader(InputStream in,Charset cs) InputStreamReader(InputStream in,CharsetDecoder dec) InputStreamReader(InputStream in,String charsetName)	创建一个使用默认字符集的该对象 创建使用给定字符集的该对象 创建使用给定字符集解码器的该对象 创建使用指定字符集该对象

常用方法

void close() String getEncoding() int read() int read(char[] cbuf, int offset, int length) boolean ready()

关闭该流并释放与之关联的所有资源 返回此流使用的字符编码的名称 读取单个字符 将字符读入数组中的某一部分 判断此流是否已经准备好用于读取

代码:

public class IO_01_InputStreamReader {
	public static void main(String[] args) {
		String file="./input.txt";
		//字节流
		try (FileInputStream fis=new FileInputStream(file);
				//转换流
				InputStreamReader isr=new InputStreamReader(fis);
				//缓冲流
				BufferedReader br=new BufferedReader(isr);			
				){
			String temp=null;
			while((temp=br.readLine())!=null){
				System.out.println(temp);
			}
			
		} catch (Exception e) {
			// TODO: handle exception
		}
		
	}
}

二 打印流

2.1特点

1 打印流是输出最方便的类

2 包含字节打印流PrintStream,字符打印流PrintWriter

3 PrintStream是OutputStream的子类,把一个输出流的实例传递到打印流之后,可以更加方便地输出内容，相当于把输出流重新包装一下

4 PrintStream类的print()方法被重载很多次print(int i)、print(boolean b)、print(char c)

代码 1 : 

public class IO_02_PrintStream {
public static void main(String[] args) {
	String file="./input.txt";
	try (
			// 创建字节输出流
			FileOutputStream fos = new FileOutputStream(file);
			// 封装为打印流
			PrintStream ps = new PrintStream(fos);
			){
		// 调用方法进行打印
		ps.println();
		ps.println("你好吗");
		ps.println(false);
		ps.println(123123);
		
		// 使用System自带的打印流,默认打印到控制台
		System.out.println("执行中....");
		// 更改打印位置
		System.setOut(ps);
		// 打印到指定位置,不再打印到控制台
		System.out.println("测试1");
		System.out.println("测试2");
		System.out.println("测试3");
		System.out.println("测试4");
		System.out.println("测试5");
		
	} catch (Exception e) {
		e.printStackTrace();
	}
}
}

功能:将D盘下的a.txt文件内容用打印流方式打印到E盘下的a.txt

代码如下:

package day02;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class IO_03_PrintStream {
	public static void main(String[] args) {
				//创建字节输入流
		try (FileInputStream fis = new FileInputStream("D:/a.txt");
				//创建字符输出流
				FileOutputStream fos = new FileOutputStream("E:/a.txt");
				// 封装为打印流
				PrintStream ps = new PrintStream(fos);) {
			System.setOut(ps);
			byte[] bytes = new byte[fis.available()];
			int count = 0;
			while ((count = fis.read(bytes)) != -1) {
				System.out.println(new String(bytes, 0, count));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("===");
	}
}

三 序列化和反序列化

3.1 概念

1. ObjectInputStream和OjbectOutputSteam

• 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可 以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

1. 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
2. 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
3. ObjectOutputStream和ObjectInputStream不能序列化static和transient修

饰的成员变量

3.2 创建对象方法

1 new 用的最多
2 反射机制
3 clone 克隆,已经过时,被反序列化代替了
4 反序列化

3.3 目的

目的 : 长期存储 , 对象传递

3.4 应用场景

序列化就是将数据对象转换为二进制流,从而可以进行数据持久化和网络传输
如果对象不进行序列化操作,那么没有办法存储和传递
反序列化就是序列化的逆向处理

3.5 过程

数据对象 --> 序列化 --> 二进制流 --> 加密处理 --> 网络传递 --> 解密处理 --> 反序列化 --> 数据对象

某个对象想要被序列化,那么该类必须实现Serializable接口,该接口没有任何方法功能,只是一种标记

代码实现:

1 创建一个对象

package day02;

import java.io.Serializable;

public class User implements Serializable {

	/**
	 * 如果不加 每次更改类,UID就变了,需要重新序列化
	 * 
	 * 目的 : 控制序列化对象的版本,如果新版本兼容旧版本,这个值 就不用改 ,如果不兼容 就把值更改,原来的序列化对象就不能用了
	 * 
	 * 版本号
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	/**
	 * transient : 用它修饰的变量,其属性值不会被序列化,可以把不必要的数据舍弃,提高序列化和反序列化的效率
	 */
	private transient int age;

	public void m1() {
		System.out.println("===");
	}

	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;
	}

	// 8295929167632747574
	// 6221260663931743134
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

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

}

2 对象序列化:

public class IO_04_ObjectOutputStream {
	public static void main(String[] args) throws Exception {
		User user = new User("张三", 18);
		// 创建输出流
		FileOutputStream fos = new FileOutputStream("D:/d");
		// 创建对象流
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		// 写出对象
		oos.writeObject(user);
		// 刷缓存,关闭资源
		oos.flush();
		oos.close();
	}
}

3 反序列化

package day02;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class IO_05_ObjectInputStream {
	public static void main(String[] args)  throws Exception{
      //创建输入流
		FileInputStream fis = new FileInputStream("D:/d");
        // 创建对象流
		ObjectInputStream ois = new ObjectInputStream(fis);
		Object o = ois.readObject();
		System.out.println(o);
		User user = (User)o;
		user.m1();
	}
}

四 文件操作

4.1 特点

1. java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关
2. File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
3. 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
4. File对象可以作为参数传递给流的构造器

4.2 File类构造方法

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

        绝对路径:是一个固定的路径,从盘符开始

        相对路径: 是相对于某个位置开始

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

3 public File(File parent,String child)根据一个父File对象和子文件路径创建File对象

4.3 File使用

1 路径中的每级目录之间用一个路径分隔符隔开

2 路径分隔符和系统有关

        windows和DOS系统默认使用“\”来表示

        UNIX和URL使用“/”来表示

3 Java程序支持跨平台运行,因此路径分隔符要慎用

4 为了解决这个隐患,File类提供了一个常量:public static final String separator

例子:

File file1 = new File("d:\\shangyun\\info.txt");
File file2 = new File("d:" + File.separator + " shangyun " + File.separator + "info.txt");
File file3 = new File("d:/ shangyun ");

4.3 File类常用方法

• public String getAbsolutePath()：获取绝对路径
• public String getPath() ：获取路径
• public String getName() ：获取名称
• public String getParent()：获取上层文件目录路径。若无，返回null
• public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
• public long lastModified() ：获取最后一次的修改时间，毫秒值
• public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
• public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

重命名功能：

• public boolean renameTo(File dest):把文件重命名为指定的文件路径

判断功能：

• public boolean isDirectory()：判断是否是文件目录
• public boolean isFile() ：判断是否是文件
• public boolean exists() ：判断是否存在
• public boolean canRead() ：判断是否可读
• public boolean canWrite() ：判断是否可写
• public boolean isHidden() ：判断是否隐藏

创建删除功能：

• public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
• public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。 如果此文件目录的上层目录不存在，也不创建。
• public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建

注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目 路径下。

• public boolean delete()：删除文件或者文件夹

删除注意事项：

Java中的删除不走回收站。

要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

代码:         

public class IO_06_File_01 {
	public static void main(String[] args) throws IOException {
		// 创建一个文件对象
		File f1 = new File("D:\\18期\\考试");
		// 获取全路径
		System.out.println(f1.getAbsolutePath());
		// 考试 文件名/文件夹名
		System.out.println(f1.getName());
		// 判断是否是文件
		System.out.println(f1.isFile());
		// 判断是否是目录
		System.out.println(f1.isDirectory());
		// D:\18期 父路径
		System.out.println(f1.getParent());
		// 父目录对象
		System.out.println(f1.getParentFile());
		// 判断该目录或该文件 是否存在
		System.out.println(f1.exists());

		f1 = new File("D:/a/b/c");
		// System.out.println(f1.exists());
		if (!f1.exists()) {
			// 递归创建该目录(不创建文件)
			f1.mkdirs();
		}else{
			// 删除c并不是把abc都删除
			System.out.println(f1.delete()+"---");
		}
		
		f1 = new File("D:/a.txt");
		if (!f1.exists()) {
			// 创建文件 , 如果有该文件就不创建了,但是不会创建目录
			// 如果创建了,返回true,如果没创建 返回false
			boolean isCreate = f1.createNewFile();
			System.out.println(isCreate);
		}else{
			// 这里说明有
			// 删除该文件
			f1.delete();
		}
		
		f1 = new File("D:\\a");
		// 获取所有子文件(直接子文件)
		File[] subFile = f1.listFiles();
		for (File file : subFile) {
			System.out.println(file.getName());
		}
	}
}