JavaSE04

/**
 * 缓冲流的缓冲区操作
 * 将缓冲流连接在文件流可以提高效率
 * 缓冲流实际上本质就是进行块读写，无论我们是使用缓冲流进行何种读写方式，最终
 * 都会被缓冲流转换为块读写形式通过文件流进行实际操作
 * 
 * 缓冲流内部维护了一个8K的字节流数组，用于块读写操作。
 * 
 * BufferedInputStream:输入缓冲流
 * BufferedOutputStream:输出缓冲流
 * 
 * 缓冲流提供了一个强制写出数据的方法：flush();
 * @author 臻冉
 *
 */
public class Buffer_FlushDemo {
	public static void main(String[] args) throws Exception {
		//文件输出流
		FileOutputStream fos = new FileOutputStream("bos.txt",true);
		//文件输出缓冲流
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		//String str = "人生最痛苦的就是在不懂爱情的年龄选择了爱情";
		String str = "，在懂得爱情的年龄下遇到了不能在一起的爱情";
		byte[] bytes = str.getBytes("UTF-8");
		bos.write(bytes);
		System.out.println("写入完毕！");
		//bos.flush();强制将当前缓冲区数据写出
		bos.close();//缓冲流close()时会调用flush();
		
	}
	
}

package day04;

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

/**
 * 利用文件缓冲流来复制Mp3
 * @author 臻冉
 *
 */
public class Buffered_CopyMp3 {
	public static void main(String[] args) throws Exception {
		//输入流
		FileInputStream fis = new FileInputStream("C:/Users/臻冉/Desktop/韩甜甜 - 你的答案 (现场)(片段).mp3");
		BufferedInputStream bis = new BufferedInputStream(fis);
		
		//输出流
		FileOutputStream fos = new FileOutputStream("C:/Users/臻冉/Desktop/韩甜甜 - 你的答案 (现场)(复制).mp3");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		
		int len=-1;
		long time1 = System.currentTimeMillis();
		while((len=bis.read())!=-1){
			bos.write(len);
			bos.flush();
		}
		long time2 = System.currentTimeMillis();
		System.out.println("复制完毕!");
		System.out.println("耗时"+(time2-time1));
		bis.close();
		bos.close();
		
		
	}
}

package day04;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * 文件缓冲流读取
 * @author 臻冉
 *
 */
public class Buffered_ReadDemo {
	public static void main(String[] args) throws Exception {
		FileInputStream fis = new FileInputStream("bos.txt");
		BufferedInputStream bis = new BufferedInputStream(fis);
		byte[] data = new byte[200];
		int len = fis.read(data);
		String str = new String(data,0,len,"UTF-8");
		System.out.println(str);
		bis.close();
		
	}
}

package day04;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

/**
 * 缓冲字符输入流
 * BufferedReader
 * @author 臻冉
 *
 */
public class BufferReaderDemo {
	public static void main(String[] args) throws Exception {
		//输入字节流
		//FileInputStream fis = new FileInputStream("pw2.txt");
		
		//输入转换流
		//InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
		
		//输入字符流
		//BufferedReader br = new BufferedReader(isr);
		
		BufferedReader br = new BufferedReader(
				new InputStreamReader(
						new FileInputStream("pw2.txt"),"UTF-8")
				);
		
		
		
		/*
		 * BufferedReader提供了String readLine()方法；
		 * 连续读取若干字符，直到读取到换行符尾部，然后将换行符之前
		 * 读取的字符以一个字符串形式返回。
		 * 注意，返回字符串中不含有最后读到的换行符
		 * 若返回值为null，则表示读到末尾
		 */
		
		String line = null;			//每一行读到的数据
		while((line = br.readLine())!=null){
			System.out.println(line);
		}
		
	}
}

package day04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * 文件输入流
 * 
 * @author 臻冉
 *
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws Exception {
		FileInputStream fis = new FileInputStream("fos.txt");
		byte[] bytes = new byte[200];
		int len = fis.read(bytes);
		/*
		 * new String(bytes,0,len,"UTF-8");
		 * bytes:读取bytes数组；
		 * 0：从下标0开始读取
		 * len:截止到实际读取到的字节量
		 * “UTF-8”:以“UTF-8"编码读取
		 */
		String str = new String(bytes,0,len,"UTF-8");
		System.out.println(str);
		fis.close();
	}
}

package day04;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * 追加操作，若文件有数据则全部保留，从该文件末尾追加内容
 *  FileOutputStream(String path,boolean append)
 *  FileOutputStream(File file,boolean append)
 *  boolean append:是否在文件末尾追加数据，默认是false;
 * @author 臻冉
 *
 */
public class FileOutputStream02 {
	public static void main(String[] args) throws Exception {
		FileOutputStream fos = new FileOutputStream("fos.txt",true);
		String str = "，坏的人给你经历,最差的人给你教训，最好的人给你回忆";
		byte[] data = str.getBytes("utf-8");
		fos.write(data);
		fos.close();
		System.out.println("输入完毕！");
	}
}

package day04;

import java.io.File;
import java.io.FileOutputStream;
import java.io.UnsupportedEncodingException;

/**
 *  java io
 *  java提供了标准的IO操作，即输入和输出：
 *  IO的作用是可以让我们的程序与外界进行数据交换，比如网络读写数据，读取键盘数据，写入文件数据等等
 *  标准的IO 根据将功能按照方向划分
 *  输入：从外界到程序中的过程，这是“读”的过程；
 *  输出：从程序发送至外界的过程，这是“写”的过程；
 *  
 *  学习IO 的重点：理解流连接操作，通过应用流链接，按照需要组合高级流与低级流，完成读写操作；
 *  流分为：节点流（低级流），处理流（高级流）；
 *  
 *  节点流：实际链接程序与另一端的管道，负责在两端之间传送数据，注意：读写一定是建立在结点流基础上进行的。
 *  处理流，不能独立存在，可以链接在其他流上，处理流自带某种对数据的加工操作，所以数据流经该流会对这些数据
 *  进行处理，这样可以简化我们队数据的处理操作。
 *  
 *  java.io.InputStream
 *  所有字节输入流的父类，是一个抽象类，规定了所有字节输入流，必须具备读取字节的方法；
 *  
 *  java.io.OutputStream
 *  所有字节输出流的父类，是一个抽象类，规定了所有字节输出流，必须具备写出字节的方法。
 *  
 *  文件流：是一套低级流，作用是读写文件数据；
 *  
 *  文件流和RandomAccessFile的对比：
 *   1.论功能是一致，都是用来读写文件数据；
 *   2.RAF对于文件即可读也可写，但是文件流不行，文件输入流只用来读文件数据，文件输出流用来向文件中写入数据；
 *   3.流的特点是顺序读写操作，即：读写是不会回退的，RAF是随机读写操作，因为依靠指针位置进行读写，所以可以通过操作
 *   指针对文件任意位置随意读写。
 *  
 *  
 *  向文件中写出一行字符串
 *  
 *  文件输出流支持两种模式：
 *  1.覆盖写操作，即：若写出的文件有数据，则将原有的数据全部删除，将本次通过写出的内容作为文件数据。
 *  FileOutputStream(String path)
 *  FileOutputStream(File file)
 *  2.追加操作，若文件有数据则全部保留，从该文件末尾追加内容
 *  FileOutputStream(String path,boolean append)
 *  FileOutputStream(File file,boolean append)
 *  
 * @author 臻冉
 *
 */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		//方式一
		//FileOutputStreamDemo fos = new FileOutputStreamDemo();
		//方式二
		//File file = new File("fos.txt");
		//FileOutputStream fos = new FileOutputStream(file);
		
		FileOutputStream fos = new FileOutputStream("fos.txt");
		String str = "永远不要去责怪你生命中的任何人，好的人给你快乐";
		byte[] data = str.getBytes("UTF-8");
		//fos提供写入的方法write(byte[] data)
		fos.write(data);
		System.out.println("写入完毕！");
		fos.close();
	}

}

package day04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

/**
 * 利用转换流读取字符
 * 
 * @author 臻冉
 *
 */
public class InputStreamReaderDemo {
	public static void main(String[] args) throws Exception {
		//输入字节流
		FileInputStream fis = new FileInputStream("osw.txt");
		/*byte[] b = new byte[50];
		fis.read(b);
		System.out.println(new String(b,"UTF-8"));*/
		
		
		
		//转换输入流
		InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
		/*char[] c= new char[50];
		int n = isr.read(c);		//实际读到的字符量
		System.out.println(n);
		String str = new String(c,0,n);
		System.out.println(str);*/
		
		/*int d = isr.read();
		System.out.println((char)d);					//读取的是低16位*/		
		int len = -1;
		while((len=isr.read())!=-1){
			System.out.print((char)len);
		}
		
		isr.close();
		
		
	}
}

package day04;

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

/**
 * 使用对象输入流完成对象“反序列化”
 */
public class ObjectInputStreamDemo {
	public static void main(String[] args) throws Exception {
		//字节输入流
		FileInputStream fis = new FileInputStream("person.obj");
		
		//对象输入流
		ObjectInputStream ois = new ObjectInputStream(fis);
		
		//ObjectInputStream 提供readObject()返回Object
		//Object object = ois.readObject();
		Person person = (Person)ois.readObject();//反序列化
		System.out.println(person);
		ois.close();
	}
}

package day04;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 对象流
 * 对象流是一对高级流，可以方便我们将java中任何对象进行读写操作
 * 
 * java.io.ObjectOutputSteam
 * 对象输出流，可以将对象转换为一组字节写出
 * 
 * java.io.ObjectInputSteam
 * 对象输入流，可以读取一组字节将其还原为对象，前提是读取
 * 这组字节应当是对象输出流将一个对象转换的字节
 * @author 臻冉
 *
 */
public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		p.setName("隔壁老王");
		p.setAge(88);
		p.setSex('男');
		//字节输出流
		FileOutputStream fos = new FileOutputStream("person.obj");
		//对象输出流
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		
		/*
		 * 将给定的对象转换为一组字节后写出
		 * oos.writer方法在当前案例中经过了两个流
		 * 首先：
		 * oos:将给定的对象p转化为一组字节，这个过程称为对象序列化
		 * fos:oos将对象转换为字节后将这组字节交给fos写入文件，将数据
		 * 写入文件等于写入到硬盘中做长久保存，这个过程成为数据持久化
		 */
		//Object bs = oos.writeObject(obj);
		oos.writeObject(p);
		System.out.println("输入完毕！");
		oos.close();
	}
}

package day04;

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

/**
 * 
 * @author 臻冉
 *
 */
public class ObjectOutputStreamTransientDemo {
	public static void main(String[] args) throws Exception{
		/*Teacher t = new Teacher();
		t.setAge(20);
		t.setName("小王");
		String[] other = {"打篮球","踢足球"};
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.obj"));
		oos.writeObject(t);
		System.out.println("输入完毕！");
		oos.close();*/
		
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.obj"));
		Teacher t = (Teacher)ois.readObject();//反序列化
		System.out.println(t);
		ois.close();
	}
}

package day04;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 字符流
 * java将流按照读写单位划分为字节流和字符流
 * InputStream和OutputStream是所有字节流父类
 * 而java.io.Reader和java.io.Writer是字符流的父类
 * 
 * 字符流只是方便我们读写字符，底层本质还是读写字节，只是字节和字符的转换
 * 工作交给了转换流来完成；
 * 
 * 转换流：
 * java.io.InputStreamReader
 * java.io.OutputStreamWriter
 * 
 * java提供的其他高级字符流都有一个特点就是只能连接在其他字符流上，但是通常低级流都是
 * 字节流。这个就导致字符流不能直接搭配字节流使用，但是转换流例外；它们本身就是字符流，
 * 而他们又可以连接字节流，所以在实际开发中当我们使用高级的字符流时，通常与字节流连接
 * 时需要使用转换流，它起到了“呈上启下”的作用，也 就是“将字符转换字节”的功能
 * 
 * @author 臻冉
 *
 */
public class OutputStreamWriterDemo {
	public static void main(String[] args) throws Exception {
		//输出字节流
		FileOutputStream fos = new FileOutputStream("osw.txt");
		//输出转换流
		/*
		 * OutputStreamWriter构造方法中OutputStreamWriter(OutoutStream out)
		 * InputStreamReader(InputStream in)
		 * 
		 * OutputStreamWriter(OutputStream out,String charset)
		 * InputStreamReader(InputStream  in, String charset)
		 * charset:编码格式
		 * 
		 */
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		String str = "终有弱水替沧海";
		osw.write(str);
		osw.write(",再把相思寄巫山");
		System.out.println("写入完毕！");
		osw.close();
	}
}

package day04;

import java.io.Serializable;
/**
 * Serializable
 * ObjectOutputStream在对象进行序列化时有一个要求，就是需要序列化的对象
 * 所述的类型必须实现Serizalizable接口，其作用是作为可序列化的标识
 * 
 * 实现该接口不需要重写任何方法，其只是作为序列化的标识
 * 
 * @author 臻冉
 *
 */
public class Person implements Serializable {
	/**
	 * serivalVersionID作用：序列化是为了保持版本的兼容性即
	 * 在升级时，反序列化仍保持对象的唯一性：
	 * 生成方式有两种：
	 * 一个是默认的1L，比如private static final long seriaVersionUID=1L;
	 * 一个是根据类型，接口名，成员方法及属性等来生成一个64位的哈西字段，比如：
	 * private static final long serivalUID = -7580762681801403029L;
	 */
	private static final long serialVersionUID = -7580762681801403029L;
	private String name;
	private int age;
	private char sex;
	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;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}

package day04;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

/**
 * 缓冲字符流
 * java.io.BufferedWriter
 * java.io.BufferedReader
 * 
 * java.io.PrintWriter带有自行刷新的缓冲字符流输出流（经常用）
 * 
 * @author 臻冉
 *
 */
public class PrintWriterDemo {
	public static void main(String[] args) throws Exception {
		/*
		 * 向文本文件pe.txt中写出三行字符串
		 * PW直接提供了向文件中写入字符串的构造方法
		 * PrintWriter(String path)
		 * PrintWriter(File file)
		 * PrintWriter(Writer writer,Boolean autoFlush)//自动刷新功能
		 * PrintWriter(String path,String charset)
		 * charset:编码格式
		 * writer:转换流
		 * autoFlush：自动进行刷新，注意使用println方法有效
		 * 
		 * PrintWriter的构造方法中若第一个参数为流，那么就支持
		 * 一个重载构造方法，允许再传入一个boolean值类型的参数，
		 * 若该值为true，则具有自动行刷新，也就是每当使用println()方法
		 * 写出一行字符串后就会自动flush
		 */
		PrintWriter pe = new PrintWriter("pe.txt","UTF-8");
		pe.println("如果你不努力，你的父母就要更加努力");
		pe.print("如果你不勤奋的，你的孩子就更要努力");
		pe.println("如果你不辛苦 ，你的另一半就要更加辛苦");
		System.out.println("写完完毕！");
		pe.flush();//强制输出
	}
}

package day04;

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * 在流连接中使用PW
 * 
 * PrintWriter(Writer writer,Boolean autoFlush)
 * 
 * @author 臻冉
 *
 */
public class PrintWriterDemo02 {
	public static void main(String[] args) throws Exception {
		/*//输出字节流
		FileOutputStream fos = new FileOutputStream("pw2.txt");
		
		//输出转换流
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		
		//输出缓冲字符流
		BufferedWriter br = new BufferedWriter(osw);
		
		//字符流
		PrintWriter pw = new PrintWriter(br,true);*/
		
		PrintWriter pw = new PrintWriter(
				new BufferedWriter(
						new OutputStreamWriter(
								new FileOutputStream("pw2.txt"),"UTF-8")
						),true);
		pw.println("不要把山那边想的很美好");
		pw.println("，等你翻山越岭回来，你会觉得这边更好");
		System.out.println("写入完毕！");
		
		
	}
}

package day04;

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

/**
 * 利用字符复制文件
 * @author 臻冉
 *
 */
public class PwCopyDemo {
	public static void main(String[] args) throws Exception {
		BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("C:/Users/臻冉/Desktop/小丁/益康特/笔记/3第三阶段-JavaSE/day01/day01_02.png"),"UTF-8"));
		
		PrintWriter pw =new PrintWriter(
				new BufferedWriter(
						new OutputStreamWriter(
								new FileOutputStream("C:/Users/臻冉/Desktop/小丁/益康特/笔记/3第三阶段-JavaSE/day01/day01_02(复制).png"),"UTF-8")));
		String line = null;
		while((line=br.readLine())!=null){
			pw.println(line);
		}
		System.out.println("复制完毕！");
		br.close();
		pw.close();
	}
}

```java
package day04;

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

/**
 * 利用字符复制文件
 * @author 臻冉
 *
 */
public class PwCopyDemo {
	public static void main(String[] args) throws Exception {
		BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("C:/Users/day01/day01_02.png"),"UTF-8"));
		
		PrintWriter pw =new PrintWriter(
				new BufferedWriter(
						new OutputStreamWriter(
								new FileOutputStream("C:/Users/day01/day01_02(复制).png"),"UTF-8")));
		String line = null;
		while((line=br.readLine())!=null){
			pw.println(line);
		}
		System.out.println("复制完毕！");
		br.close();
		pw.close();
	}
}

package day04;

import java.io.Serializable;
import java.util.Arrays;

/**
 * transient属性
 * 一个声明为瞬态的属性将不会被对象序列化写到文件中
 * 瞬态的属性用于把不需要序列化的属性忽略掉，这样可以到达对象文件“减肥”的目的。
 * 注意：序列化时就要“减肥（瘦身）”才能正确读取数据，被“减肥”的属性没有值
 * @author 臻冉
 *
 */
public class Teacher implements Serializable {
	private String name;
	private int age;
	private transient String[] other;
	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;
	}
	public String[] getOther() {
		return other;
	}
	public void setOther(String[] other) {
		this.other = other;
	}
	@Override
	public String toString() {
		return "Teacher [name=" + name + ", age=" + age + ", other=" + Arrays.toString(other) + "]";
	}
	
}