目录
第一章 Properties类
1.1 Properties类介绍
Properties类表示了一个持久的属性集合。Properties可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。特点：
1、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型(<T>), 键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。
方法：
load(InputStream) 把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中
load(Reader)
store(OutputStream,commonts)把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对文件的注释。
stroe(Writer,comments);
代码演示：
/*
* 使用Properties集合,存储键值对
* setProperty等同与Map接口中的put
* setProperty(String key, String value)
* 通过键获取值, getProperty(String key)
*/
public static void function(){
Properties pro = new Properties();
pro.setProperty("a", "1");
pro.setProperty("b", "2");
pro.setProperty("c", "3");
System.out.println(pro);
String value = pro.getProperty("c");
System.out.println(value);
//方法stringPropertyNames,将集合中的键存储到Set集合,类似于Map接口的方法keySet
Set<String> set = pro.stringPropertyNames();
for(String key : set){
System.out.println(key+"..."+pro.getProperty(key));
}
}运行结果：
1.2 读取文件中的数据，并保存到集合
需求：从属性集文件pro.properties 中取出数据，保存到集合中
过程分析：
1. 创建集合 //Properties pro = new Properties();
2. 创建流对象 //FileReader fr = new FileReader("d:\\pro.properties");
3. 把流所对应文件中的数据,读取到集合中. // pro.load(fr);
load(InputStream) 把指定流所对应的文件中的数据，读取出来，保存到Properties集合中
load(Reader)
4. 关闭流 //fr.close();
5. 显示集合中的数据 //System.out.println(pro);
pro.properties文件内容：
代码演示：
/*
* Properties集合特有方法 load
* load(InputStream in)
* load(Reader r)
* 传递任意的字节或者字符输入流
* 流对象读取文件中的键值对,保存到集合
*/
public static void function_1()throws IOException{
//1.创建集合
Properties pro = new Properties();
//2.创建流对象
FileReader fr = new FileReader("d:\\pro.properties");
//3.读取数据。调用集合的方法load,传递字符输入流
pro.load(fr);
//4.关闭流
fr.close();
//5.显示数据
System.out.println(pro);
}运行结果：
1.3 将集合中内容存储到文件
需求：使用Properties集合，完成把集合内容存储到IO流所对应文件中的操作
过程分析：
1. 创建Properties集合 //Properties pro = new Properties();
2. 添加元素到集合 // pro.setProperty("name", "zhangsan");
3. 创建流 // FileWriter fw = new FileWriter("d:\\pro1.properties");
4. 把集合中的数据存储到流所对应的文件中 //pro.store(fw, "");
store(Writer,comments)
store(OutputStream,commonts)
把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表注释
5. 关闭流 // fw.close();
注意：参数commonts注释不能写中文，若写中文自动转换为Unicode字符了
/*
* Properties集合的特有方法store
* store(OutputStream out)
* store(Writer w)
* 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
*/
public static void function_2()throws IOException{
Properties pro = new Properties();
pro.setProperty("name", "zhangsan");
pro.setProperty("age", "31");
pro.setProperty("email", "123456789@163.com");
FileWriter fw = new FileWriter("d:\\pro1.properties");
//键值对,存回文件,使用集合的方法store传递字符输出流
pro.store(fw, "");
fw.close();
}运行结果：
代码合集：
package day25.demo1;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/*
* 集合对象Properties类,继承Hashtable,实现Map接口
* 可以和IO对象结合使用,实现数据的持久存储
*/
public class PropertiesDemo {
public static void main(String[] args)throws IOException {
function_1();
}
/*
* Properties集合的特有方法store
* store(OutputStream out)
* store(Writer w)
* 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
*/
public static void function_2()throws IOException{
Properties pro = new Properties();
pro.setProperty("name", "zhangsan");
pro.setProperty("age", "31");
pro.setProperty("email", "123456789@163.com");
FileWriter fw = new FileWriter("d:\\pro1.properties");
//键值对,存回文件,使用集合的方法store传递字符输出流
pro.store(fw, "");
fw.close();
}
/*
* Properties集合特有方法 load
* load(InputStream in)
* load(Reader r)
* 传递任意的字节或者字符输入流
* 流对象读取文件中的键值对,保存到集合
*/
public static void function_1()throws IOException{
Properties pro = new Properties();
FileReader fr = new FileReader("d:\\pro.properties");
//调用集合的方法load,传递字符输入流
pro.load(fr);
fr.close();
System.out.println(pro);
}
/*
* 使用Properties集合,存储键值对
* setProperty等同与Map接口中的put
* setProperty(String key, String value)
* 通过键获取值, getProperty(String key)
*/
public static void function(){
Properties pro = new Properties();
pro.setProperty("a", "1");
pro.setProperty("b", "2");
pro.setProperty("c", "3");
System.out.println(pro);
String value = pro.getProperty("c");
System.out.println(value);
//方法stringPropertyNames,将集合中的键存储到Set集合,类似于Map接口的方法keySet
Set<String> set = pro.stringPropertyNames();
for(String key : set){
System.out.println(key+"..."+pro.getProperty(key));
}
}
}
第二章 序列化流与反序列化流
反序列化流：用于从流中读取对象的操作流 ObjectInputStream。
序列化流：用于向流中写入对象的操作流 ObjectOutputStream。
特点：用于操作对象（类似Person）。可以将对象写入到文件中，也可以从文件中读取对象。
因为写入可能是文字也可能是其他，因此用字节流的子类ObjectInputStream。
2.1 对象序列化流ObjectOutputStream
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。
注意：只能将支持 java.io.Serializable 接口的对象写入流中
静态成员不可被序列化，因为静态成员属于类的共享成员，不属于对象。
代码演示：
Person类：
package day25.demo1;
import java.io.Serializable;
public class Person implements Serializable{
public String name;
public int age;
/*transient阻止成员变量序列化*/
//类,自定义了序列号,编译器不会计算序列号
private static final long serialVersionUID = 1478652478456L;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
/*
* ObjectOutputStream
* 构造方法: ObjectOutputStream(OutputSteam out)
* 传递任意的字节输出流
* void writeObject(Object obj)写出对象的方法
*/
public static void writeObject() throws IOException{
//1,明确存储对象的文件。创建字节输出流,封装文件
FileOutputStream fos = new FileOutputStream("d:\\person.txt");
//2，给操作文件对象加入写入对象功能。创建写出对象的序列化流的对象,构造方法传递字节输出流
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person p = new Person("lisi",25);
//3，调用了写入对象的方法。调用序列化流的方法writeObject,写出对象
oos.writeObject(p);
//关闭资源。
oos.close();
}
2.2 对象反序列化流ObjectInputStream
ObjectInputStream 从流读取出Java 对象，是对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。支持 java.io.Serializable接口的对象才能从流读取，但是Serializable内无具体代码。
反序列化代码演示：
/*
* ObjectInputStream
* 构造方法:ObjectInputStream(InputStream in)
* 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
* Object readObject() 读取对象
*/
public static void readObject() throws IOException, ClassNotFoundException{
//1,定义流对象关联存储了对象文件。
FileInputStream fis = new FileInputStream("d:\\person.txt");
//2,建立用于读取对象的功能对象。创建反序列化流,构造方法中,传递字节输入流
ObjectInputStream ois = new ObjectInputStream(fis);
//调用反序列化流的方法 readObject()读取对象
Object obj =ois.readObject();
System.out.println(obj);
ois.close();
}代码总和：
Person类：
package day25.demo1;
import java.io.Serializable;
public class Person implements Serializable{
public String name;
public int age;
/*transient阻止成员变量序列化*/
//类,自定义了序列号,编译器不会计算序列号
private static final long serialVersionUID = 1478652478456L;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
package day25.demo1;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
* IO流对象,实现对象Person序列化,和反序列化
* ObjectOutputStream 写对象,实现序列化
* ObjectInputStream 读取对象,实现反序列化
*/
public class ObjectStreamDemo {
public static void main(String[] args)throws IOException, ClassNotFoundException {
writeObject();
readObject();
}
/*
* ObjectInputStream
* 构造方法:ObjectInputStream(InputStream in)
* 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
* Object readObject() 读取对象
*/
public static void readObject() throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream("d:\\person.txt");
//创建反序列化流,构造方法中,传递字节输入流
ObjectInputStream ois = new ObjectInputStream(fis);
//调用反序列化流的方法 readObject()读取对象
Object obj =ois.readObject();
System.out.println(obj);
ois.close();
}
/*
* ObjectOutputStream
* 构造方法: ObjectOutputStream(OutputSteam out)
* 传递任意的字节输出流
* void writeObject(Object obj)写出对象的方法
*/
public static void writeObject() throws IOException{
//创建字节输出流,封装文件
FileOutputStream fos = new FileOutputStream("d:\\person.txt");
//创建写出对象的序列化流的对象,构造方法传递字节输出流
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person p = new Person("lisi",25);
//调用序列化流的方法writeObject,写出对象
oos.writeObject(p);
oos.close();
}
}
若Person类中，将age定义为static静态成员，输出的就为零。
原因在于：静态变量属于类，是类的共享数据，不属于对象。因此对象序列化若遇到静态变量则不能执行。即静态不能序列化。
2.3 序列化接口
当一个对象要能被序列化，这个对象所属的类必须实现Serializable接口。否则会发生异常NotSerializableException异常。
同时当反序列化对象时，如果对象所属的class文件在序列化之后进行的修改，那么进行反序列化也会发生异常InvalidClassException。例如：Person.class被删除，也会抛出此异常。
发生常InvalidClassException异常的原因如下：
- 该类（此例为Person类）的序列版本号与从流中读取的类描述符的版本号不匹配（即序列号冲突问题，后面详细讲）
- 该类包含未知数据类型
- 该类没有可访问的无参数构造方法
没有方法的接口，被称为标记型接口。
Serializable为标记接口。该接口给需要序列化的类，提供了一个序列版本号。serialVersionUID. 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
序列号冲突问题：
报错信息如下：
上面引发的是序列号冲突问题，原因在于：
分析图解：
序列号冲突的文字说明：
一个类只要实现了 serialVersion接口，就会产生一个序列号。写文件的同时，序列号也写入Person.txt文档了。读文件（反序列）的时候读取Person.txt序列号，与Person.class的序列号做对比，如果相同则读成功，否则读取（反序列）失败。
若此时再修改Person文件（将age从private改为public），重新编译，将生成一个新的序列号（678910）。若此时不写Person.txt文档，直接读取文件。此时Person.txt文档中的序列号还保存为之前的1234567，但与Person.class的序列号（新生成的678910）做对比，不相同，因此抛出异常。这就是序列号冲突问题。
解决序列号冲突问题，需要设置一个不变的序列号。
//类,自定义了序列号,编译器不会计算序列号
private static final long serialVersionUID = 1478652478456L;
2.4 瞬态关键字transient
当一个类的对象需要被序列化时，某些属性不需要被序列化，因此Java提供了关键字transient。只要被transient修饰了，序列化时这个属性就不会被序列化了。
同时静态修饰也不会被序列化，因为序列化是把对象数据进行持久化存储，而静态的属于类加载时的数据，不会被序列化。
private transient int age;
/*transient阻止成员变量序列化*/
第三章 打印流
3.1打印流的概述
打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
打印流根据流的分类：
- 字节打印流 PrintStream
- 字符打印流 PrintWriter
方法：
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作。
package day25.demo1;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流
* PrintStream
* PrintWriter
* 打印流的特点:
* 1. 此流不负责数据源,只负责数据目的
* 2. 为其他输出流,添加功能
* 3. 永远不会抛出IOException
* 但是,可能抛出别的异常
*
* 两个打印流的方法,完全一致
* 构造方法,就是打印流的输出目的端
* PrintStream
* 构造方法,接收File类型,接收字符串文件名,接收字节输出流OutputStream
* PrintWriter
* 构造方法,接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer
*
*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
function_3();
}
/*
* 打印流,可以开启自动刷新功能
* 满足2个条件:
* 1. 输出的数据目的必须是流对象
* OutputStream Writer
* 2. 必须调用println,printf,format三个方法中的一个,启用自动刷新
*/
public static void function_3()throws IOException{
//File f = new File("XXX.txt");
FileOutputStream fos = new FileOutputStream("c:\\5.txt");
PrintWriter pw = new PrintWriter(fos,true);
pw.println("i");
pw.println("love");
pw.println("java");
pw.close();
}
/*
* 打印流,输出目的,是流对象
* 可以是字节输出流,可以是字符的输出流
* OutputStream Writer
*/
public static void function_2() throws IOException{
// FileOutputStream fos = new FileOutputStream("c:\\3.txt");
FileWriter fw = new FileWriter("c:\\4.txt");
PrintWriter pw = new PrintWriter(fw);
pw.println("打印流");
pw.close();
}
/*
* 打印流,输出目的,String文件名
*/
public static void function_1() throws FileNotFoundException{
PrintWriter pw = new PrintWriter("c:\\2.txt");
pw.println(3.5);
pw.close();
}
/*
* 打印流,向File对象的数据目的写入数据
* 方法print println 原样输出
* write方法走码表
*/
public static void function() throws FileNotFoundException{
File file = new File("c:\\1.txt");
PrintWriter pw = new PrintWriter(file);
pw.println(true);
pw.write(100);
pw.close();
}
}
3.2 打印流完成数据自动刷新
可以通过构造方法，完成文件数据的自动刷新功能
构造方法：
开启文件自动刷新写入功能
public PrintWriter(OutputStream out, boolean autoFlush)
public PrintWriter(Writer out, boolean autoFlush) //true表示自动刷新
package day25.demo1;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流实现文本复制
* 读取数据源 BufferedReader+File 读取文本行
* 写入数据目的 PrintWriter+println 自动刷新
*/
public class PrintWriterDemo1 {
public static void main(String[] args) throws IOException{
BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("d:\\a.txt"),true);
String line = null;
while((line = bfr.readLine())!=null){
pw.println(line);
}
pw.close();
bfr.close();
}
}
第四章 commons-IO
4.1 导入classpath
加入classpath的第三方jar包内的class文件才能在项目中使用。
导入方法：
- 创建lib文件夹
- 将commons-io.jar拷贝到lib文件夹
- 右键点击commons-io.jar，Build Path→Add to Build Path
添加源码路径：
4.2 FilenameUtils
这个工具类是用来处理文件名（译者注：包含文件路径）的，他可以轻松解决不同操作系统文件名称规范不同的问题
常用方法：
getExtension(String path)：获取文件的扩展名；
getName()：获取文件名；
isExtension(String fileName,String ext)：判断fileName是否是ext后缀名；
package day25.demo1;
import org.apache.commons.io.FilenameUtils;
public class Commons_IODemo {
public static void main(String[] args) {
function_1();
}
/*
* FilenameUtils类的方法
* static boolean isExtension(String filename,String extension)
* 判断文件名的后缀是不是extension
*/
public static void function_2(){
boolean b = FilenameUtils.isExtension("Demo.java", "Java");
System.out.println(b);//区分大小写
}
/*
* FilenameUtils类的方法
* static String getName(String filename)
* 获取文件名
*/
public static void function_1(){
String name = FilenameUtils.getName("c:\\windows.1232");
System.out.println(name);//windows.1232
}
/*
* FilenameUtils类的方法
* static String getExtension(String filename)
* 获取文件名的扩展名
*/
public static void function(){
String name = FilenameUtils.getExtension("c:\\name.lalal");
System.out.println(name);//lalal,获得小数点后的，不管是什么内容
}
}
4.3 FileUtils
提供文件操作（移动文件，读取文件，检查文件是否存在等等）的方法。
常用方法：
readFileToString(File file)：读取文件内容，并返回一个String；
writeStringToFile(File file，String content)：将内容content写入到file中；
copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制
copyFile(File srcFile,File destFile);文件夹复制
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
public class Commons_IODemo1 {
public static void main(String[] args)throws IOException {
function_3();
}
/*
* FileUtils工具类方法
* static void copyDirectoryToDirectory(File src,File desc)
* 复制文件夹
*/
public static void function_3() throws IOException{
FileUtils.copyDirectoryToDirectory(new File("d:\\demo"), new File("c:\\"));
}
/*
* FileUtils工具类的方法
* static void copyFile(File src,File desc)
* 复制文件
*/
public static void function_2() throws IOException{
FileUtils.copyFile(new File("c:\\k.jpg"),new File("d:\\k.jpg"));
}
/*
* FileUtils工具类的方法
* static void writeStringToFile(File src,String date)
* 将字符串直接写到文件中
*/
public static void function_1() throws IOException{
FileUtils.writeStringToFile(new File("c:\\b.txt"),"我爱Java编程");
}
/*
* FileUtils工具类的方法
* static String readFileToString(File src)读取文本,返回字符串
*/
public static void function() throws IOException{
String s = FileUtils.readFileToString(new File("c:\\a.txt"));
System.out.println(s);
}
}
第五章 总结
字节流
字节输入流 InputStream
FileInputStream 操作文件的字节输入流
BufferedInputStream高效的字节输入流
ObjectInputStream 反序列化流
字节输出流 OutputStram
FileOutputStream 操作文件的字节输出流
BufferedOutputStream 高效的字节输出流
ObjectOuputStream 序列化流
PrintStream 字节打印流
字符流
字符输入流 Reader
FileReader 操作文件的字符输入流
BufferedReader 高效的字符输入流
InputStreamReader 输入操作的转换流(把字节流封装成字符流)
字符输出流 Writer
FileWriter 操作文件的字符输出流
BufferedWriter 高效的字符输出流
OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)
PrintWriter 字符打印流
方法：
读数据方法：
read() 一次读一个字节或字符的方法
read(byte[] char[]) 一次读一个数组数据的方法
readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
readObject() 从流中读取对象(ObjectInputStream特有方法)
写数据方法：
write(int) 一次写一个字节或字符到文件中
write(byte[] char[]) 一次写一个数组数据到文件中
write(String) 一次写一个字符串内容到文件中
writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
newLine() 写一个换行符号(BufferedWriter类特有方法)
向文件中写入数据的过程
1. 创建输出流对象
2. 写数据到文件
3. 关闭输出流
从文件中读数据的过程
1. 创建输入流对象
2. 从文件中读数据
3. 关闭输入流
文件复制的过程
1. 创建输入流（数据源）
2.创建输出流（目的地）
3. 从输入流中读数据
4. 通过输出流，把数据写入目的地
5. 关闭流
File类
方法
获取文件名称 getName()
获取文件绝对路径 getAbsolutePath()
获取文件大小 length()
获取当前文件夹中所有File对象 File[] listFiles()
判断是否为文件 isFile()
判断是否为文件夹 isDirectory()
创建文件夹 mkdir() mkdirs()
创建文件 createNewFile()
异常
try..catch…finally捕获处理异常
throws 声明异常
throw 抛出异常对象
异常的分类
编译期异常 Exception
|- 运行期异常 RuntimeException
注意：
编译期异常，必须处理，不然无法编译通过
运行期异常，程序运行过程中，产生的异常信息
Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合
方法
load( InputStream in ) 从流所对应的文件中，读数据到集合中
load( Reader in ) 从流所对应的文件中，读数据到集合中
store( OutputStream out , String message ) 把集合中的数据，写入到流所对应的文件中
store( Writer out , String message) 把集合中的数据，写入到流所对应的文件中
实现文件内容的自动追加
构造方法
FileOutputStream(File file, boolean append)
FileOutputStream(String fileName, boolean append)
FileWriter(File, boolean append)
FileWriter(String fileName, boolean append)
实现文件内容的自动刷新
构造方法
PrintStream(OutputStream out, boolean autoFlush)
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush)
Commons-IO
方法
readFileToString(File file)：读取文件内容，并返回一个String；
writeStringToFile(File file，String content)：将内容content写入到file中；
copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制
copyFileToDirectory (File srcFile,File destFile);文件复制
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
