字节流输出
package test;
//这个类用来测试 字节输出流
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//总结:
//1、字节流的写出流:两种普通流FileOutputStream 和高级流BufferedOutputStream
//2、效率上来讲:BufferedOutputStream > FileOutputStream
//3、原因: BufferedOutputStream底层维护了一个byte[] 默认大小是8K,减少给磁盘的次数,提高效率
public class test1 {
public static void main(String[] args) {
method();// 普通输出流FileOutputStream
method2();// 高效输出流BufferedOutputStream
}
private static void method2() {
OutputStream out = null;
try {
// 1,创建对象
// OutputStream out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 默认是数据覆盖模式
out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt", true));// 是数据追加模式
// 2,开始写出
out.write(47);
out.write(48);
out.write(49);
} catch (IOException e) {// 捕获大异常
e.printStackTrace();
} finally {//为了保证资源一定会被释放
try {
out.close();// 3,释放资源
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void method() {
OutputStream out = null;
OutputStream out2 = null;
try {
// 1,创建对象
out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 默认是数据覆盖模式
out2 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt", true);// 是数据追加模式
// OutputStream out2 = new FileOutputStream( new File("D:\\iotest\\1.txt") );
// 2,开始写出
out.write(47);
out.write(48);
out.write(49);
} catch (IOException e) {// 捕获大异常
e.printStackTrace();
}finally{
// 3,释放资源
try {
out.close();
out2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流输出
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
//这个类用来测试 字符输出流
//总结
//字符输出流:两种:普通流FileWriter 高效流BufferedWriter
//效率上来讲:BufferedWriter > FileWriter
//原因:BufferedWriter底层维护了一个缓冲数组char[] ,默认大小8K,减少给磁盘的次数,提高效率
public class test2 {
public static void main(String[] args) {
// method();//普通对象FileWriter
method2();//高级流
}
private static void method2() {
Writer out = null ;
try {
//1,创建对象
out = new BufferedWriter ( new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\1.txt",true) ) ;
//2,开始写出
out.write(50);
out.write("信你个鬼啊");//字符流可以写出字符串
out.flush(); //把缓冲区的数据,刷到磁盘里 显示
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//3,释放资源
out.close(); //两个功能:先把数据从缓冲区刷出去 后 释放资源
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void method() {
Writer out = null ;
try {
//1,创建对象
out = new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\1.txt");
//2,开始写出
out.write(49);
out.write("我爱java");//字符流可以写出字符串
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//3,释放资源
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
文件复制
package test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
//这个类用来测试 文件复制
//1、读取源文件
//2、把数据写出到 目标文件中
public class test3 {
public static void main(String[] args) {
File from = new File("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 源文件
File to = new File("C:\\Users\\Administrator\\Desktop\\test\\2.txt");// 目标文件
// copy(from,to);//完成复制 -- 字节流---什么类型的文件都可以操作
copy2(from, to);// 完成复制 -- 字符流--只能操作字符文件
}
// 字符流操作 -- 只能操作字符文件
private static void copy2(File from, File to) {
Reader in = null;
Writer out = null;
try {
// 1、读取源文件 -- 字节流 高效流
in = new BufferedReader(new FileReader(from));
// 2、把数据写出到 目标文件中
out = new BufferedWriter(new FileWriter(to));
// 3、边读边写
int b = 0; // 定义变量,记录读取到的数据
while ((b = in.read()) != -1) {// 只要有数据就一直读
out.write(b);// 读一个写一个
}
} catch (IOException e) {// 捕获大点的异常
e.printStackTrace();
}finally{
// TODO 4、释放资源
try {
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 字节流操作
private static void copy(File from, File to) {
try {
// 1、读取源文件 -- 字节流 高效流
InputStream in = new BufferedInputStream(new FileInputStream(from));
// 2、把数据写出到 目标文件中
OutputStream out = new BufferedOutputStream(new FileOutputStream(to));
// 3、边读边写
int b = 0; // 定义变量,记录读取到的数据
while ((b = in.read()) != -1) {// 只要有数据就一直读
out.write(b);// 读一个写一个
}
// TODO 4、释放资源
in.close();
out.close();
} catch (IOException e) {// 捕获大点的异常
e.printStackTrace();
}
}
}
批量读写
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
//这个类用来测试 文件复制
//1、读取源文件
//2、把数据写出到 目标文件中
public class test4{
public static void main(String[] args) {
File from = new File("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 源文件
File to = new File("C:\\Users\\Administrator\\Desktop\\test\\2.txt");// 目标文件
copy2(from, to);// 完成复制 -- 字符流--只能操作字符文件
}
// 字符流操作 -- 只能操作字符文件
private static void copy2(File from, File to) {
Reader in = null;
Writer out = null;
try {
// 1、读取源文件 -- 字节流 高效流
in = new BufferedReader(new FileReader(from));
// 2、把数据写出到 目标文件中
out = new BufferedWriter(new FileWriter(to));
//批量读写,数组的容量到底多大是比较合适的?8*1024=8K
char[] cs = new char[8*1024] ;
int b = 0; // 定义变量,记录读取到的数据
while ((b = in.read(cs)) != -1) {// read(char[]) --按照数组的容量读取数据--批量读取
out.write(cs,0,b);//write(char[]) --按照数组的容量写出数据-- 批量写出
//write(m,n,o);--m是你要写出的数组名--n是你要从数组的哪个位置开始向后写出--o是你要写出多少数据(有多少写多少)
}
} catch (IOException e) {// 捕获大点的异常
e.printStackTrace();
}finally{
// TODO 4、释放资源
try {
in.close();
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
序列化/反序列化
序列化:把 java 程序中的对象,永久存储到磁盘的过程
ObjectOutputStream
ObjectOutputStream(OutputStream out)
void writeObject(Object obj)
将指定的对象写入 ObjectUtputStream
反序列化: 把磁盘中的已经 序列化 好 的文件,恢复到 java 程序中
ObjectInputStream
ObjectInputStream(InputStream out)
void readObject()
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//这个类用来测试 对象的序列化
public class test5 {
public static void main(String[] args) {
method(); //完成序列化
method2(); //完成反序列化
}
//反序列化:磁盘中 -- > java对象 ---ObjectInputStream
private static void method2() {
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt"));
//反序列化方法
Object obj = in.readObject();
//Student [name=皮皮霞, age=18, score=99.9]
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
//序列化:java对象 -- > 磁盘中---ObjectOutputStream
private static void method() {
try {
//1、创建对象
Student s = new Student("皮皮霞",18,99.9);
ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream( "C:\\Users\\Administrator\\Desktop\\test\\1.txt" ) ) ;
//2、完成序列化,序列化文件我们看不懂!!
out.writeObject(s);
//3、释放资源
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//4、创建学生类 ,如果想要完成序列化,必须实现序列化接口,否则java.io.NotSerializableException
class Student implements Serializable{
//5、实现序列化接口后,要生成唯一的版本号id值作为文件的标志
private static final long serialVersionUID = 1L;
//构造方法
public Student() {}
public Student(String name, int age, double score) {
this.name = name;
this.age = age;
this.score = score;
}
private String name;
private int age;
private double score;
//set()/get()
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
// toString()为了方便查看对象的属性值而不是地址值
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
}
编码转换流
解决 字符流 读写乱码现象
OutputStreamWriter: 转换流,把字节输出流 转成 字符 输出流
继承自 Writer
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String CharsetName)
InputStreamReader: 转换流,把字节读取流 转成 字符 读取流
继承自 Reader
InputStreamReader(InputStream in)
InputStreamReader(InputStream in, String charsetName)
package test;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class test5 {
public static void main(String[] args) {
try {
//1、创建字节流
OutputStream out = new FileOutputStream("D:\\javaStudy\\tedu\\day14\\test\\1.txt");
//2、创建字符流,OutputStreamWriter 用来把字节输出流 转换成 字符输出流
//OutputStreamWriter(m,n)--m是要写出的字节流对象,n是要使用的编码表
Writer out2 = new OutputStreamWriter(out,"gbk") ;
//3、写出字符串
out2.write("大家好,我叫渣渣辉");
//4、释放资源
out2.close();
System.out.println();
InputStream in = new FileInputStream("D:\\javaStudy\\tedu\\day14\\test\\1.txt");
//5、读取时乱码,也可以设置编码表来解决乱码现象
BufferedReader reader = new BufferedReader (new InputStreamReader(in,"gbk") );
//打印读取到的一整行数据
System.out.println( reader.readLine() );
} catch (Exception e) {
e.printStackTrace();
}
}
}