输出流:OutputStream和Writer为基类
输入流:InputStream和Reader为基类
读取
package cn.pojo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo {
public static void main(String[] args) {
readByte();
readArr();
}
/**
* 读取字节
*/
public static void readByte() {
// 1、明确源数据源
File f = new File("F:\\1\\余文佳\\1.txt");
// 2、构建输入流对象
InputStream ins = null;
try {
ins = new FileInputStream(f);
int i;
// 3、 读取文件字符
while ((i = ins.read()) != -1) {
System.out.println("i=" + i); // 输出为转化的ascii码值
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ins != null) {
try {
ins.close();
} catch (Exception e) {
e.printStackTrace();}
}
}
}
// 2、使用缓冲数组的方法读取文件内容,提高效率
public static void readArr() {
// 1、明确源数据源
File f = new File("F:/1/余文佳/1.txt");
// 2、构建流的对象
InputStream ins = null;
try {
ins = new FileInputStream(f);
// 3、声明缓冲数组
int i; // 表示读取了多少个字符到数组中
byte[] bt = new byte[5]; // 字节缓冲数组
// 4、读取数据到数组中
while ((i = (ins.read(bt))) != -1) {
for (int j = 0; j < i; j++) {
System.out.print((char) bt[j]);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭流
try {
if (ins != null) {
ins.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
写入
public final class OutputStreamDemo {
public static void main(String[] args) {
// 1、明确目标数据源
File f = new File("E:/java48/java48.txt");
// 判断文件是否存在,否则创建
if (!f.exists()) {
f.getParentFile().mkdirs();// 先创建目录
try {
f.createNewFile();// 再创建文件 此处需要处理异常,
} catch (Exception e) {
e.printStackTrace();
}
}
// 2、构建输出流对象(通过子类实例化父类的对象)
OutputStream outs = null ; // 首先准备好一个输出的对象
try {
outs = new FileOutputStream(f) ; // 构造方法 ,实例化,此处需要处理异常
// 执行写入文件的操作
String st = "java48班" ; // 创建字符串
byte[] bt = st.getBytes(); // 只能输出byte数组,所以将字符串变为byte数组
// 使用String st.getByte();方法
outs.write(bt); // 将内容输出,保存文件
outs.flush(); // 刷新输出流
System.out.println("写入成功!"); // 若(文件夹必须存在)没有文件,会创建文件然后写入;若文件已有相同内容,则直接覆盖
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4、关闭资源
if (outs != null) {
try {
outs.close(); // 此处也要处理异常
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
利用读写流 实现文件的复制
public class Demo {
// 检查文件是否存在,否则创建
public static void checkFile(File file) {
if (!file.exists()) {
file.getParentFile().mkdirs();// 创建多级目录
try {
file.createNewFile();// 创建文件,此处需要处理异常
System.out.println("创建文件成功!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// 明确源文件和目标文件
File o = new File("E:/java48/java48.txt");// 源文件
File t = new File("E:/java48/新建.txt");// 目标文件
checkFile(t);// 这里仅仅检查了目标文件
// 构建输入、输出流对象
InputStream ins = null; // 输入的对象
OutputStream outs = null; // 输出的对象
// 进行实例化,需要处理异常
try {
ins = new FileInputStream(o);// 源文件作为输入对象--->若要拼接后面加上true
outs = new FileOutputStream(t);// 目标文件作为输出对象--->若要拼接后面加上true
// 创建缓冲数组
byte[] b = new byte[1024];
int len = 0;
// 执行边读边写操作
while ((len = ins.read(b)) != -1) {
outs.write(b, 0, len);
}
// 刷新输出流
outs.flush();
// 至此复制成功
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭流(先开的后关)
try {
if (outs != null) {// 为了避免空指针异常,进行判空
outs.close();
}
if (ins != null) {
ins.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
对象序列化流
对象序列化:就是将对象保存到磁盘中,或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象,该字节序列包含:对象的类型、对象的数据和对象中存储的属性等信息
字节序列写到文件之后,相当于文件中持久保存了一个对象的信息
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化
总的理解就是序列化是把一个对象存入文件中,而反序列化就是把文件中序列化的对象读取出来。
对象的写入 需要实现序列化接口
public class Student implements Serializable {
}
测试类
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws IOException {
//ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
//创建对象
Student s = new Student("林青霞",30);
//void writeObject(Object obj):将指定的对象写入ObjectOutputStream
oos.writeObject(s);
//释放资源
oos.close();
}
}
反序列化
public class ObjectInputStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
//Object readObject():从ObjectInputStream读取一个对象
Object obj = ois.readObject();
Student s = (Student) obj;
System.out.println(s.getName() + "," + s.getAge());
ois.close();
}
}
综合案例
(1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,生成空参有参构造,set和get方法,toString方法
(2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
(3)将存有6个学员信息的ArrayList集合对象写入到D:\\StudentInfo.txt文件中
(4)读取D:\\StudentInfo.txt文件中的ArrayList对象
(5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
(6)将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\\StudentInfo.txt文件中(写入格式:张三-男-25)
————————————————
//学生类
package IO.Work;
import java.io.Serializable;
public class Stduent implements Serializable {
private String name;
private String gender;
private int age;
public Stduent() {
}
public Stduent(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Stduent{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
'}';
}
}
public class inputAndOutput {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ArrayList<Stduent> array = new ArrayList<Stduent>();
InPut(array);
writerToFile(array);
readArrayList(array);
removeAndSort(array);
writerArrayList(array);
}
//将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\\Student.txt文件中
private static void writerArrayList(ArrayList<Stduent> array) throws IOException {
PrintWriter pw = new PrintWriter(new FileWriter("leveleight\\src\\IO\\paper\\Stduent"));
//遍历集合
for (Stduent stduent : array) {
pw.print(stduent);
}
pw.close();
}
//对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
private static ArrayList<Stduent> removeAndSort(ArrayList<Stduent> array) {
//创建TreeSet集合对象使用比较器排序,去重
TreeSet<Stduent> ts = new TreeSet<Stduent>(new Comparator<Stduent>() {
@Override
public int compare(Stduent s1, Stduent s2) {
int num = s1.getAge() - s2.getAge();
return num;
}
});
ts.addAll(array);
array.clear();
array.addAll(ts);
System.out.println("去重排序后:");
for (Stduent st : array) {
System.out.println(st);
}
return array;
}
//读取StudentInfo.txt文件中的ArrayList对象
private static ArrayList<Stduent> readArrayList(ArrayList<Stduent> array) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("leveleight\\src\\IO\\paper\\StudentInfo.txt"));
Object obj = ois.readObject();
Stduent s = (Stduent) obj;
System.out.println("原始数据" + s.getName() + "," + s.getGender() + "," + s.getAge());
ois.close();
return array;
}
//将存有6个学员信息的ArrayList集合对象写入到StudentInfo.txt文件中
private static void writerToFile(ArrayList<Stduent> array) throws IOException {
//由于Stduent是一个对象,那么存入文件就需要使用对象序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("leveleight\\src\\IO\\paper\\StudentInfo.txt", true));
oos.writeObject(array);
oos.close();
}
//键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
//创建键盘录入方法体
private static void InPut(ArrayList<Stduent> array) {
Scanner sc = new Scanner(System.in);
String[] strArr = new String[3];
System.out.println("请输入六个学员信息!");
for (int i = 0; i < 6; i++) {
System.out.println("请输入第" + (i + 1) + "个学生的信息(格式:xxx,男,25)");
strArr = sc.next().split(",");//,,
array.add(new Stduent(strArr[0], strArr[1], Integer.parseInt(strArr[2])));
}
}
}