1.字符流输入流输出流,实现文本文件的复制
package top.oneluckyguy.thread;
import org.junit.Test;
import java.io.*;
/**
* @author Liu Qingfeng
* @create 2020-12-18----21:30
*/
public class FileReaderWritertest {
public static void main(String[] args) {
File file = new File("hello.txt");//相较于当前工程下
System.out.println(file.getAbsolutePath());
}
/*
将文件读入到程序中,并输出到控制台。
知识点:
1.read()的理解,返回读入的一个字符,如果到达文件末尾就返回-1
2.异常的处理:为了保证流的资源一定关闭,最好使用try_catch_finally来捕获异常。
* */
@Test
public void testFileReader() {
FileReader fileReader = null;
try {
// 1.实例化File类的对象,并指明要操作的文件
File file = new File("src//top//oneluckyguy//pro//hello.txt");//相较于当前Module下
// 2.提供具体的流
fileReader = new FileReader(file);
// 3.数据的读入
//read()返回读入的一个字符,如果达到文件末尾,返回-1
/* 方式一
int data = fileReader.read();
while(data != -1){
System.out.println((char)(data));
data = fileReader.read();
}*/
//方式二
int data;
while((data = fileReader.read()) != -1){
System.out.println((char)data);
}
}catch (IOException e){
e.printStackTrace();
}finally {
//4.流的关闭
if (fileReader != null){
try {
fileReader.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
@Test
public void testFileReader1() throws IOException {
FileReader fileReader = null;
try {
//1.File类的实例化
File file = new File("src//top//oneluckyguy//pro//hello.txt");
//2.FileReader流的实例化
fileReader = new FileReader(file);
//3.读入的操作
//read(char[] cbuffer):返回每次读入cbuffer数组中的字符个数,如果达到文件末尾就返回-1
char[] cbuffer = new char[5];
int len;
while ((len = fileReader.read(cbuffer)) != -1 ){
//方式一
// 如果是len.length输出为helloworld123ld,123会把world中的前三个字母覆盖,但是后三个不会覆盖,还是输出
/*for (int i = 0; i < len; i++) {//这里是小于len不是小于len.length。
System.out.println(cbuffer[i]);
}*/
//方式二
String string = new String(cbuffer,0,len);//如果这里不加0和len也会出现上面的错误
System.out.println(string);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileReader != null){
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
* 从内存中写出数据到硬盘的文件里
* */
@Test
public void testFileWriter() {
FileWriter fileWriter = null;
try {
// 1.提供File类的对象指明要写出的文件
File file = new File("src//top//oneluckyguy//pro//hello1.txt");
// 2.提供FileWriter的对象,用于数据的写出
fileWriter = new FileWriter(file,true);//加上true表示在原有文件上追加内容
// 3.写出操作
fileWriter.write("I have a dream\n");
fileWriter.write("You are beautiful");
// 4.流的关闭
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileWriter != null){
fileWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
* 实现文件的复制
* */
@Test
public void testImgWriter(){
FileWriter fileWriter = null;
FileReader fileReader = null;
try {
// 1.创建File对象,指明要对如和写出的文件
File fileR = new File("src//top//oneluckyguy//pro//2.png");
File fileW = new File("src//top//oneluckyguy//pro//3.png");
// 2.创建输入流和输出流的对象
fileReader = new FileReader(fileR);
fileWriter = new FileWriter(fileW);
// 3.数据的读入和写出操作
char[] cbuffer = new char[5];
int len;
while ((len = fileReader.read(cbuffer)) != -1){
for (int i = 0; i < len; i++) {
fileWriter.write(cbuffer[i]);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileWriter != null)
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fileReader != null)
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.字节流输入输出流实现图片复制
package top.oneluckyguy.io;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author Liu Qingfeng
* @create 2020-12-19----15:11
* 测试FileInputStream 和FileOutputStream的使用
* 结论:
* 对于文本文件使用字符流处理(.txt .doc .c .cpp .java)
* 对于非文本文件使用字节流处理(视频 音频 .ppt)
*/
public class FileInputOutputStreamTest {
//使用字节流处理文本文件是可能出现乱码的
@Test
public void testFileInputStream(){
FileInputStream fileInputStream = null;
try {
//1.造文件
File file = new File("hello.txt");
//2.造流
fileInputStream = new FileInputStream(file);
//3.读数据
byte[] cbuffer = new byte[5];
int len = 0;
while((len = fileInputStream.read(cbuffer)) != -1){
String str = new String(cbuffer,0,len);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileInputStream != null){
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void testInputOutputStream(){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
//1.造文件
File fileI = new File("2.png");
File fileO = new File("3.png");
//2.造流
fileInputStream = new FileInputStream(fileI);
fileOutputStream = new FileOutputStream(fileO);
//3.读写的过程
byte[] buffer = new byte[5];
int len;
while((len = fileInputStream.read(buffer)) != -1){
fileOutputStream.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fileOutputStream != null){
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fileInputStream != null){
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//指定路径下文件的复制
public void copyFile(String srcPath,String destPath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
//1.造文件
File fileI = new File(srcPath);
File fileO = new File(destPath);
//2.造流
fileInputStream = new FileInputStream(fileI);
fileOutputStream = new FileOutputStream(fileO);
//3.读写的过程
byte[] buffer = new byte[1024];
int len;
while((len = fileInputStream.read(buffer)) != -1){
fileOutputStream.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fileOutputStream != null){
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fileInputStream != null){
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void testCopyFile(){
long start = System.currentTimeMillis();
copyFile("2.png","4.png");
long end = System.currentTimeMillis();
System.out.println("复制花费的时间:"+ (end - start));
}
}
3.缓冲流实现文件复制,速度与节点流比较是否更快。
package top.oneluckyguy.io;
import org.junit.Test;
import java.io.*;
/**
* @author Liu Qingfeng
* @create 2020-12-19----16:44
*/
/*
* 实现非文本文件的复制
* */
public class BufferedTest {
public void BufferedStreamTest (String srcPath,String destPath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
//1.造文件
File filei = new File(srcPath);
File fileo = new File(destPath);
//2.造节点流
fileInputStream = new FileInputStream(filei);
fileOutputStream = new FileOutputStream(fileo);
// 3.造缓冲流
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//4.操作
byte[] buffer= new byte[1024];
int len;
while((len = bufferedInputStream.read(buffer)) != -1){
bufferedOutputStream.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//5.关闭流
if (fileInputStream != null){
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fileOutputStream != null){
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void fileBufferedCopyTest(){
long start = System.currentTimeMillis();
BufferedStreamTest("2.png","4.png");
long end = System.currentTimeMillis();
System.out.println("复制花费的时间:"+ (end - start));
}
}
4.转换流的使用
InputStreamReader
OutputStreamwriter
package top.oneluckyguy.io;
import org.junit.Test;
import java.io.*;
/**
* @author Liu Qingfeng
* @create 2020-12-19----20:39
* 处理流二:
* 1.转换流:输入字符流
* InputStreamReader 将一个字节的输入流转换为字符的输入流
* OutputStreamWriter 将一个字符的输出流转化为字节的输出流
* 2.作用:提供字节流与字符流之间的转换
* 3.解码: 字节 字节数组----->字符数组 字符串
* 编码: 字符数组 字符串----->字节 字节数组
* 4.字符集
*
*
*/
public class InputStreamReaderTest {
@Test
public void test(){
InputStreamReader inputStreamReader = null;
try {
File file = new File("hello.txt");
FileInputStream fileInputStream = new FileInputStream(file);
inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");
char[] cbuffer = new char[5];
int len;
while((len = inputStreamReader.read(cbuffer)) != -1){
String str = new String(cbuffer,0,len);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStreamReader != null){
try {
inputStreamReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
* 综合使用InputStreamReader 和OutputStreamWriter
* 把utf-8文件以utf-8格式读入以gbk格式输出
* */
@Test
public void testAll(){
InputStreamReader inputStreamReader = null;
OutputStreamWriter outputStreamWriter = null;
try {
File fileI = new File("hello.txt");
File fileO = new File("rehello.txt");
FileInputStream fileInputStream = new FileInputStream(fileI);
FileOutputStream fileOutputStream = new FileOutputStream(fileO);
inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
outputStreamWriter = new OutputStreamWriter(fileOutputStream,"gbk");
char[] cbuffer = new char[5];
int len;
while((len = inputStreamReader.read(cbuffer)) != -1){
outputStreamWriter.write(cbuffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStreamReader != null){
try {
inputStreamReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outputStreamWriter != null){
try {
outputStreamWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5.对象流
1.对String字符串进行序列化和反序列化的输入输出
package top.oneluckyguy.objectIO;
import org.junit.Test;
import java.io.*;
/**
* @author Liu Qingfeng
* @create 2020-12-20----15:29
* 对象流的使用:
* 1.ObjectInputStream和ObjectOutputStream
* 2.作用:用于存储和读取基本数据类型数据或对象的处理流,
* 3.要想一个Java对象是可序列化的,需要满足相应的要求:详见Person类
*/
public class ObjectInputOutputStreamTest {
/*
* 序列化过程,将内存中的Java对象保存到磁盘中或者通过网络传播出去
* 使用ObjectOutputStram实现
* */
@Test
public void testObjectOutputStream(){
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream("hello.data"));
objectOutputStream.writeObject(new String("坂井泉水"));
objectOutputStream.flush();//把缓存中的数据刷新出去
} catch (IOException e) {
e.printStackTrace();
} finally {
if (objectOutputStream != null){
try {
objectOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
* 反序列化,将磁盘文件中的对象还原为内存中的一个Java对象
* 需要使用ObjectInputStream
* */
@Test
public void testObjectInputStream(){
ObjectInputStream objectInputStream = null;
String str = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream("hello.data"));
Object obj = objectInputStream.readObject();
str = (String) obj;
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (objectInputStream != null){
try {
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.对Objec对象的序列化和反序列化
①对象类
package top.oneluckyguy.objectIO;
import java.io.Serializable;
/**
* @author Liu Qingfeng
* @create 2020-12-20----15:51
*/
public class Person implements Serializable {
//这里如果不写UID系统会自动给你配一个UID,你序列化时用的UID必须和反序列化的UID一样
//必须指定UID,如果不指定,对当前类修改的时候就会变化
public static final long serialVersionUID = 12L;
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public Person() {
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
②处理流
package top.oneluckyguy.objectIO;
import org.junit.Test;
import java.io.*;
/**
* @author Liu Qingfeng
* @create 2020-12-20----15:29
* 对象流的使用:
* 1.ObjectInputStream和ObjectOutputStream
* 2.作用:用于存储和读取基本数据类型数据或对象的处理流,
* 3.要想一个Java对象是可序列化的,需要满足相应的要求:详见Person类
* 1.需要实现接口:Serializable
* 2.当前类需要提供一个全局常量serialVersionUID
* eg: public static final long serialVersionUID = -2228226523704288112L;
* 3.除了当前Person类需要实现Serializable接口外还要保证其内部所有属性也必须是可序列化的。
* (默认情况下,基本数据类型都是可序列化的,同时String类型也是可序列化的)
* (如果Person类中有一个别的类Man作为Person类的参数,那么这个类Man也要可序列化实现Serializable接口和提供一个UID(这个UID和Person的不同))。
* 补充:
* ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
* (不会报编译错误,但是数据不会保存。)
*/
public class ObjectInputOutputStreamTest {
/*
* 序列化过程,将内存中的Java对象保存到磁盘中或者通过网络传播出去
* 使用ObjectOutputStram实现
* */
@Test
public void testObjectOutputStream(){
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream("hello.data"));
objectOutputStream.writeObject(new String("坂井泉水"));
objectOutputStream.flush();//把缓存中的数据刷新出去
objectOutputStream.writeObject(new Person("大黑摩季",18));
objectOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (objectOutputStream != null){
try {
objectOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
* 反序列化,将磁盘文件中的对象还原为内存中的一个Java对象
* 需要使用ObjectInputStream
* */
@Test
public void testObjectInputStream(){
ObjectInputStream objectInputStream = null;
String str = null;
Person person = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream("hello.data"));
Object obj = objectInputStream.readObject();
str = (String) obj;
Object objects = objectInputStream.readObject();
person = (Person) objects;
System.out.println(str);
System.out.println(person);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (objectInputStream != null){
try {
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}