网站的建设与设计论文,石景山周边网站建设,有哪些微信开发公司,建筑公司简介模板免费下载⼀、File类
概念#xff1a;代表物理盘符中的⼀个⽂件或者⽂件夹。
常见方法#xff1a; 方法名 描述 createNewFile() 创建⼀个新文件。 mkdir() 创建⼀个新⽬录。 delete() 删除⽂件或空⽬录。 exists() 判断File对象所对象所代表的对象是否存在。 getAbsolute…⼀、File类
概念代表物理盘符中的⼀个⽂件或者⽂件夹。
常见方法 方法名 描述 createNewFile() 创建⼀个新文件。 mkdir() 创建⼀个新⽬录。 delete() 删除⽂件或空⽬录。 exists() 判断File对象所对象所代表的对象是否存在。 getAbsolutePath() 获取⽂件的绝对路径。 getName() 取得名字。 getParent() 获取⽂件/⽬录所在的⽬录。 isDirectory() 是否是⽬录。 isFile() 是否是⽂件。 length() 获得⽂件的⻓度。 listFiles() 列出⽬录中的所有内容
示例
//⽂件的相关操作
File f new File(d:/aaa/bbb.java);
System.out.println(⽂件绝对路径:f.getAbsolutePath());
System.out.println(⽂件构造路径:f.getPath());
System.out.println(⽂件名称:f.getName());
System.out.println(⽂件⻓度:f.length()字节);//创建⽂件 createNewFile()
File filenew File(d:\\file.txt);
//System.out.println(file.toString());
if(!file.exists()) {boolean bfile.createNewFile();System.out.println(创建结果:b);
}
System.out.println(是否时⽂件:file.isFile());//⽂件夹的相关操作
File f2 new File(d:/aaa);
System.out.println(⽬录绝对路径:f2.getAbsolutePath());
System.out.println(⽬录构造路径:f2.getPath());
System.out.println(⽬录名称:f2.getName());
System.out.println(⽬录⻓度:f2.length());//遍历⽂件夹
File dir2new File(d:\\图⽚);
String[] filesdir2.list();
System.out.println(--------------------------------);
for (String string : files) {System.out.println(string);
}
FileFilter接口
FileFilter⽂件过滤器接⼝
boolean accept(File pathname)。
当调⽤File类中的listFiles()⽅法时⽀持传⼊FileFilter接⼝接⼝实现类对获取⽂件进⾏过滤只有满足条件的⽂件的才可出现在listFiles()的返回值中。
示例
public class DiGuiDemo {public static void main(String[] args) {File f new File(d:\\QF\\test);printDir(dir);}public static void printDir(File dir) {// 匿名内部类⽅式,创建过滤器⼦类对象File[] files dir.listFiles(new FileFilter() {Overridepublic boolean accept(File pathname) {return pathname.getName().endsWith(.java)||pathname.isDirectory();}});// 循环打印for (File file : files) {if (file.isFile()) {System.out.println(⽂件名: file.getAbsolutePath());} else {printDir2(file);}}}
}
⼆、什么是IO
⽣活中你肯定经历过这样的场景。当你编辑⼀个⽂本⽂件忘记了ctrls 可能⽂件就⽩⽩编辑了。当你电脑上插⼊⼀个U盘可以把⼀个视频拷⻉到你的电脑硬盘⾥。那么数据都是在哪些设备上的呢键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输可以看做是⼀种数据的流动按照流动的⽅向以内存为基准分为输⼊input 和输出output 即流向内存是输⼊流流出内存的输出流。
Java中I/O操作主要是指使⽤java.io包下的内容进⾏输⼊、输出操作。输⼊也叫做读取数据输出也叫做作写出数据。
三、IO分类
按照流的流向分可以分为输入流和输出流
按照操作单元划分可以划分为字节流和字符流
按照流的角色划分为节点流和处理流。
Java Io流共涉及40多个类这些类看上去很杂乱但实际上很有规则而且彼此之间存在非常紧密的联系
Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。
InputStream/Reader: 所有的输入流的基类前者是字节输入流后者是字符输入流。
OutputStream/Writer: 所有输出流的基类前者是字节输出流后者是字符输出流。
按操作方式分类结构图 按操作对象分类结构图 四、字节流
⼀切皆为字节
⼀切⽂件数据(⽂本、图⽚、视频等)在存储时都是以⼆进制数字的形式保存都⼀个⼀个的字节那么传输时⼀样如此。所以字节流可以传输任意⽂件数据。在操作流的时候我们要时刻明确⽆论使⽤什么样的流对象底层传输的始终为⼆进制数据。
字节输出流
java.io.OutputStream抽象类是表示字节输出流的所有类的超类将指定的字节信息写出到⽬的地。它定义了字节输出流的基本共性功能⽅法。
public void close() 关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b)将 b.length字节从指定的字节数组写⼊此输出流。
public void write(byte[] b, int off, int len) 从指定的字节数组写⼊ len字节从偏移量 off开始输出到此输出流。
public abstract void write(int b) 将指定的字节输出流。
FileOutputStream类
构造⽅法
public FileOutputStream(File file)创建⽂件输出流以写⼊由指定的 File对象表示的⽂件。
public FileOutputStream(String name) 创建⽂件输出流以指定的名称写⼊⽂件。
1、写出字节write(int b) ⽅法每次可以写出⼀个字节数据
2、写出字节数组write(byte[] b)每次可以写出数组中的数据
3、写出指定⻓度字节数组write(byte[] b, int off, int len) ,每次写出从off索引开始len个字节
示例 // 使⽤File对象创建流对象
File file new File(a.txt);
FileOutputStream fos new FileOutputStream(file);
// 使⽤⽂件名称创建流对象
FileOutputStream fos new FileOutputStream(b.txt);
// 使⽤⽂件名称创建流对象
FileOutputStream fos new FileOutputStream(fos.txt);
// 写出数据虽然参数为int类型四个字节但是只会保留⼀个字节的信息写出
fos.write(97); // 写出第1个字节
fos.write(98); // 写出第2个字节
fos.write(99); // 写出第3个字节
// 关闭资源
fos.close();
// 使⽤⽂件名称创建流对象
FileOutputStream fos new FileOutputStream(fos.txt);
// 字符串转换为字节数组
byte[] b 你好中国.getBytes();
// 写出字节数组数据
fos.write(b);
// 关闭资源
fos.close();
// 使⽤⽂件名称创建流对象
FileOutputStream fos new FileOutputStream(fos.txt);
// 字符串转换为字节数组
byte[] b abcde.getBytes();
// 写出从索引2开始2个字节。索引2是c两个字节也就是cd。
fos.write(b,2,2);
// 关闭资源
fos.close();
字节输⼊流
java.io.InputStream抽象类是表示字节输⼊流的所有类的超类可以读取字节信息到内存中。它定义了字节输⼊流的基本共性功能⽅法。
public void close() 关闭此输⼊流并释放与此流相关联的任何系统资源。
public abstract int read() 从输⼊流读取数据的下⼀个字节。
public int read(byte[] b) 从输⼊流中读取⼀些字节数并将它们存储到字节数组 b中 。
FileInputStream类
构造⽅法
FileInputStream(File file) 通过打开与实际⽂件的连接来创建⼀个 FileInputStream 该⽂件
由⽂件系统中的 File对象 file命名。
FileInputStream(String name) 通过打开与实际⽂件的连接来创建⼀个 FileInputStream 该
⽂件由⽂件系统中的路径名 name命名。
1、读取字节read⽅法每次可以读取⼀个字节的数据提升为int类型读取到⽂件末尾返回-1
2、使⽤字节数组读取read(byte[] b)每次读取b的⻓度个字节到数组中返回读取到的有效字节个数读取到末尾时返回-1
示例
// 使⽤File对象创建流对象
File file new File(a.txt);
FileInputStream fos new FileInputStream(file);
// 使⽤⽂件名称创建流对象
FileInputStream fos new FileInputStream(b.txt);
// 使⽤⽂件名称创建流对象
FileInputStream fis new FileInputStream(read.txt);
// 读取数据返回⼀个字节
int read fis.read();
System.out.println((char) read);
read fis.read();
System.out.println((char) read);
read fis.read();
System.out.println((char) read);
read fis.read();
System.out.println((char) read);
read fis.read();
System.out.println((char) read);
// 读取到末尾,返回-1
read fis.read();
System.out.println( read);
// 关闭资源
fis.close();
// 使⽤⽂件名称创建流对象
FileInputStream fis new FileInputStream(read.txt);
// 定义变量保存数据
int b
// 循环读取
while ((b fis.read())!-1) {System.out.println((char)b);
}
// 关闭资源
fis.close();
// 使⽤⽂件名称创建流对象.
FileInputStream fis new FileInputStream(read.txt); // ⽂件中为abcde
// 定义变量作为有效个数
int len
// 定义字节数组作为装字节数据的容器
byte[] b new byte[2];
// 循环读取
while (( len fis.read(b))!-1) {// 每次读取后,把数组的有效字节部分变成字符串打印System.out.println(new String(b0len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
综合案例图⽚复制
//1创建流
//1.1⽂件字节输⼊流
FileInputStream fisnew FileInputStream(d:\\001.jpg);
//1.2⽂件字节输出流
FileOutputStream fosnew FileOutputStream(d:\\002.jpg);
//2⼀边读⼀边写
byte[] bufnew byte[1024];
int count0;
while((countfis.read(buf))!-1) {fos.write(buf,0,count);
}
//3关闭
fis.close();
fos.close();
System.out.println(复制完毕);
五、字符流
字符输⼊流
java.io.Reader 抽象类是表示⽤于读取字符流的所有类的超类可以读取字符信息到内存中。它定义了字符输⼊流的基本共性功能⽅法。
public void close() 关闭此流并释放与此流相关联的任何系统资源。
public int read() 从输⼊流读取⼀个字符。
public int read(char[] cbuf) 从输⼊流中读取⼀些字符并将它们存储到字符数组cbuf中 。
FileReader类
构造方法
FileReader(File file) 创建⼀个新的 FileReader 给定要读取的File对象。
FileReader(String fileName) 创建⼀个新的 FileReader 给定要读取的⽂件的名称。
构造时使⽤系统默认的字符编码和默认字节缓冲区。
1. 字符编码字节与字符的对应规则。Windows系统的中⽂编码默认是GBK编码表。idea中UTF-8
2. 字节缓冲区⼀个字节数组⽤来临时存储字节数据。
示例
// 使⽤File对象创建流对象
File file new File(a.txt);
FileReader fr new FileReader(file);
// 使⽤⽂件名称创建流对象
FileReader fr new FileReader(b.txt);
// 使⽤⽂件名称创建流对象
FileReader fr new FileReader(read.txt);
// 定义变量保存有效字符个数
int len
// 定义字符数组作为装字符数据的容器
char[] cbuf new char[2];
// 循环读取
while ((len fr.read(cbuf))!-1) {System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
字符输出流
java.io.Writer 抽象类是表示⽤于写出字符流的所有类的超类将指定的字符信息写出到⽬的地。
它定义了字符输出流的基本共性功能⽅法。
void write(int c) 写⼊单个字符。
void write(char[] cbuf) 写⼊字符数组。
abstract void write(char[] cbuf, int off, int len) 写⼊字符数组的某⼀部分,off数组的开始索引,len写的字符个数。
void write(String str) 写⼊字符串。
void write(String str, int off, int len) 写⼊字符串的某⼀部分,off字符串的开始索引,len写的字符个数。
void flush() 刷新该流的缓冲。
void close() 关闭此流但要先刷新它。
FileWriter类
FileWriter(File file) 创建⼀个新的 FileWriter给定要读取的File对象。
FileWriter(String fileName) 创建⼀个新的 FileWriter给定要读取的⽂件的名称。
构造时使⽤系统默认的字符编码和默认字节缓冲区。
1、写出字符 write(int b) ⽅法每次可以写出⼀个字符数据
2、写出字符数组 write(char[] cbuf) 和 write(char[] cbuf, int off, int len) 每次可以写出字符数组中的数据⽤法类似FileOutputStream
3、写出字符串 write(String str) 和 write(String str, int off, int len)每次可以写出字符串中的数据更为⽅便
因为内置缓冲区的原因如果不关闭输出流⽆法写出字符到⽂件中。但是关闭的流对象是⽆法继续写出数据的。如果我们既想写出数据⼜想继续使⽤流就需要flush ⽅法了。
// 使⽤File对象创建流对象
File file new File(fw.txt);
FileWriter fw new FileWriter(file);
// 使⽤⽂件名称创建流对象
FileWriter fw new FileWriter(fw.txt);
// 使⽤⽂件名称创建流对象
FileWriter fw new FileWriter(fw.txt);
// 写出数据
fw.write(97); // 写出第1个字符
fw.write(b); // 写出第2个字符
fw.write(C); // 写出第3个字符
fw.write(30000); // 写出第4个字符中⽂编码表中30000对应⼀个汉字。
/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区并未保存到⽂件。
*/
// fw.close();
// 使⽤⽂件名称创建流对象
FileWriter fw new FileWriter(fw.txt);
// 写出数据通过flush
fw.write(刷); // 写出第1个字符
fw.flush();
fw.write(新); // 继续写出第2个字符写出成功
fw.flush();
// 写出数据通过close
fw.write(关); // 写出第1个字符
fw.close();
fw.write(闭); // 继续写出第2个字符,【报错】java.io.IOException: Stream
closed
fw.close();
// 使⽤⽂件名称创建流对象
FileWriter fw new FileWriter(fw.txt);
// 字符串转换为字节数组
char[] chars 你好中国.toCharArray();
// 写出字符数组
fw.write(chars);
// 写出从索引2开始2个字节。索引2是中两个字节也就是中国。
fw.write(b,2,2); //中国
// 关闭资源
fos.close();
// 使⽤⽂件名称创建流对象
FileWriter fw new FileWriter(fw.txt);
// 字符串
String msg 你好中国;
// 写出字符数组
fw.write(msg); //你好中国
// 写出从索引2开始2个字节。索引2是中两个字节也就是中国。
fw.write(msg,2,2); // 中国
// 关闭资源
fos.close();
六、缓冲流
概述
缓冲流,也叫⾼效流是对4个基本的 FileXxx 流的增强所以也是4个流按照数据类型分类
字节缓冲流 BufferedInputStream BufferedOutputStream
字符缓冲流 BufferedReader BufferedWriter
缓冲流的基本原理是在创建流对象时会创建⼀个内置的默认大小的缓冲区数组通过缓冲区读写减少系统IO次数从⽽提⾼读写的效率。
字节缓冲流
构造⽅法
public BufferedInputStream(InputStream in) 创建⼀个 新的缓冲输⼊流。
public BufferedOutputStream(OutputStream out) 创建⼀个新的缓冲输出流。
示例
// 创建字节缓冲输⼊流
BufferedInputStream bis new BufferedInputStream(new
FileInputStream(bis.txt));
// 创建字节缓冲输出流
BufferedOutputStream bos new BufferedOutputStream(new
FileOutputStream(bos.txt));
效率PK
基本流示例
public static void main(String[] args) {// 记录开始时间long start System.currentTimeMillis();// 创建流对象try (FileInputStream fis new FileInputStream(jdk8.exe);FileOutputStream fos new FileOutputStream(copy.exe)){// 读写数据int b;while ((b fis.read()) ! -1) {fos.write(b);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end System.currentTimeMillis();System.out.println(普通流复制时间:(end - start) 毫秒);}
缓冲流示例
public static void main(String[] args) {// 记录开始时间long start System.currentTimeMillis();// 创建流对象try (BufferedInputStream bis new BufferedInputStream(newFileInputStream(jdk8.exe));BufferedOutputStream bos new BufferedOutputStream(newFileOutputStream(copy.exe));){// 读写数据//int b;//while ((b bis.read()) ! -1) {//bos.write(b);//}// 读写数据int len;byte[] bytes new byte[8*1024];while ((len bis.read(bytes)) ! -1) {bos.write(bytes, 0 , len);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end System.currentTimeMillis();System.out.println(缓冲流复制时间:(end - start) 毫秒);}
字符缓冲流
构造方法
public BufferedReader(Reader in) 创建⼀个 新的缓冲输⼊流。
public BufferedWriter(Writer out) 创建⼀个新的缓冲输出流。
示例
// 创建字符缓冲输⼊流
BufferedReader br new BufferedReader(new FileReader(br.txt));
// 创建字符缓冲输出流
BufferedWriter bw new BufferedWriter(new FileWriter(bw.txt));
特有方法
字符缓冲流的基本⽅法与普通字符流调⽤⽅式⼀致不再阐述我们来看它们具备的特有⽅法。
BufferedReader public String readLine() : 读⼀⾏⽂字。
BufferedWriter public void newLine() : 写⼀⾏⾏分隔符,由系统属性定义符号。
示例1
// 创建流对象
BufferedReader br new BufferedReader(new FileReader(in.txt));
// 定义字符串,保存读取的⼀⾏⽂字
String line null;
// 循环读取,读取到最后返回null
while ((line br.readLine())!null) {System.out.print(line);System.out.println(------);
}
// 释放资源
br.close();
示例2
// 创建流对象
BufferedWriter bw new BufferedWriter(new FileWriter(out.txt));
// 写出数据
bw.write(hello);
// 写出换⾏
bw.newLine();
bw.write(world);
bw.newLine();
bw.write(!);
bw.newLine();
// 释放资源
bw.close();
七、转换流
在IDEA中使⽤ FileReader 读取项⽬中的⽂本⽂件。由于IDEA的设置都是默认的 UTF-8编码所以没有任何问题。但是当读取Windows系统中创建的⽂本⽂件时由于Windows系统的默认是GBK编码就会出现乱码。
示例
public class ReaderDemo {public static void main(String[] args) throws IOException {FileReader fileReader new FileReader(E:\\File_GBK.txt);int read;while ((read fileReader.read()) ! -1) {System.out.print((char)read);}fileReader.close();}
}
输出结果那么如何读取GBK编码的⽂件呢 InputStreamReader类
转换流 java.io.InputStreamReader 是Reader的⼦类是从字节流到字符流的桥梁。它读取字节并使⽤指定的字符集将其解码为字符。它的字符集可以由名称指定也可以接受平台的默认字符集。
构造方法
InputStreamReader(InputStream in) : 创建⼀个使⽤默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建⼀个指定字符集的字符流。
示例
// 定义⽂件路径,⽂件为gbk编码
String FileName E:\\file_gbk.txt;
// 创建流对象,默认UTF8编码
InputStreamReader isr new InputStreamReader(new
FileInputStream(FileName));
// 创建流对象,指定GBK编码
InputStreamReader isr2 new InputStreamReader(new
FileInputStream(FileName) , GBK);
// 定义变量,保存字符
int read;
// 使⽤默认编码字符流读取,乱码
while ((read isr.read()) ! -1) {System.out.print((char)read); // Һ
}
isr.close();
// 使⽤指定编码字符流读取,正常解析
while ((read isr2.read()) ! -1) {System.out.print((char)read);// ⼤家好
}
isr2.close();
OutputStreamWriter类
转换流 java.io.OutputStreamWriter 是Writer的⼦类是从字符流到字节流的桥梁。使⽤指定
的字符集将字符编码为字节。它的字符集可以由名称指定也可以接受平台的默认字符集。
构造⽅法
OutputStreamWriter(OutputStream in) : 创建⼀个使⽤默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName) : 创建⼀个指定字符集的字符流。
示例
// 定义⽂件路径
String FileName out.txt;
// 创建流对象,默认UTF8编码
OutputStreamWriter osw new OutputStreamWriter(new
FileOutputStream(FileName));
// 写出数据
osw.write(你好); // 保存为6个字节
osw.close();
// 定义⽂件路径
String FileName2 out2.txt;
// 创建流对象,指定GBK编码
OutputStreamWriter osw2 new OutputStreamWriter(new
FileOutputStream(FileName2),GBK);
// 写出数据
osw2.write(你好);// 保存为4个字节
osw2.close();
⼋、序列化
概述
Java 提供了⼀种对象序列化的机制。⽤⼀个字节序列可以表示⼀个对象该字节序列包含该 对象的数据 、 对象的类型 和 对象中存储的属性 等信息。字节序列写出到⽂件之后相当于⽂件中持久保存了⼀个对象的信息。
反之该字节序列还可以从⽂件中读取回来重构对象对它进⾏反序列化。 对象的数据 、 对象的类型 和 对象中存储的数据信息都可以⽤来在内存中创建对象。
ObjectOutputStream类
java.io.ObjectOutputStream 类将Java对象的原始数据类型写出到⽂件,实现对象的持久存储。
序列化操作
⼀个对象要想序列化必须满⾜两个条件: 必须实现Serializable接⼝。 必须保证其所有属性均可序列化。(transient修饰为临时属性不参与序列化)
写出对象⽅法 public final void writeObject (Object obj) : 将指定的对象写出。
示例
public class Employee implements java.io.Serializable {public String name;public String address;public transient int age; // transient瞬态修饰成员,不会被序列化public void addressCheck() {System.out.println(Address check : name -- address);}
}
public class SerializeDemo{public static void main(String [] args) {Employee e new Employee();e.name zhangsan;e.address guangzhou;e.age 20;try {// 创建序列化流对象ObjectOutputStream out new ObjectOutputStream(newFileOutputStream(employee.txt));// 写出对象out.writeObject(e);// 释放资源out.close();fileOut.close();System.out.println(序列化完成); // 姓名地址被序列化年龄没有被序列化。} catch(IOException i) {i.printStackTrace();}}
}
ObjectInputStream类
ObjectInputStream反序列化流将之前使⽤ObjectOutputStream序列化的原始数据恢复为对象。
反序列化操作
如果能找到⼀个对象的class⽂件我们可以进⾏反序列化操作调⽤ ObjectInputStream 读取对象的⽅法
public final Object readObject () : 读取⼀个对象。
public class DeserializeDemo {public static void main(String [] args) {Employee e null;try {// 创建反序列化流FileInputStream fileIn new FileInputStream(employee.txt);ObjectInputStream in new ObjectInputStream(fileIn);// 读取⼀个对象e (Employee) in.readObject();// 释放资源in.close();fileIn.close();}catch(IOException i) {// 捕获其他异常i.printStackTrace();return;}catch(ClassNotFoundException c) {// 捕获类找不到异常System.out.println(Employee class not found);c.printStackTrace();return;}// ⽆异常,直接打印输出System.out.println(Name: e.name); // zhangsanSystem.out.println(Address: e.address); // beiqingluSystem.out.println(age: e.age); // 0}
}
注意 对于JVM可以反序列化对象它必须是能够找到class⽂件的类。如果找不到该类的class⽂件则抛出⼀个ClassNotFoundException 异常。 当JVM反序列化对象时能找到class⽂件但是class⽂件在序列化对象之后发⽣了修改那么反序列化操作也会失败抛出⼀个 InvalidClassException 异常。 发⽣这个异常的原因,该类的序列版本号与从流中读取的类描述符的版本号不匹配 ,serialVersionUID 该版本号的⽬的在于验证序列化的对象和对应类是否版本匹配。 serialVersionUID是⼀个⾮常重要的字段因为 Java 的序列化机制是通过在运⾏时判断类的 serialVersionUID来验证版本⼀致性的。在进⾏反序列化时JVM 会把传来的字节流中的 serialVersionUID与本地相应实体类的serialVersionUID进⾏⽐较如果相同就认为是⼀致的可 以进⾏反序列化否则就会出现序列化版本不⼀致的异常。 ⼀般来说定义serialVersionUID的⽅式有两种分别为 采⽤默认的1L具体为private static final long serialVersionUID 1L; 在可兼容的前提下可以保留旧版本号如果不兼容或者想让它不兼容就⼿⼯递增版本号。 1-2-3..... 根据类名、接⼝名、成员⽅法及属性等来⽣成⼀个64位的哈希字段例如 private static final long serialVersionUID XXXL; 这种⽅式适⽤于这样的场景 开发者认为每次修改类后就需要⽣成新的版本号不想向下兼容操作就是删除原有serialVesionUid 声明语句再⾃动⽣成⼀下。 第⼆种能够保证每次更改类结构后改变版本号但还是要⼿⼯去⽣成 public class Employee implements java.io.Serializable {// 加⼊序列版本号private static final long serialVersionUID 1L;public String name;public String address;// 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.public int eid;public void addressCheck() {System.out.println(Address check : name -- address);}
}
九、Properties属性类
常用方法
public Object setProperty(String key, String value) 保存⼀对属性。
public String getProperty(String key) 使⽤此属性列表中指定的键搜索属性值。
public SetString stringPropertyNames() 所有键的名称的集合。
public void load(InputStream inStream) 从字节输⼊流中读取键值对。
示例1
// 创建属性集对象
Properties properties new Properties();
// 添加键值对元素
properties.setProperty(filename, a.txt);
properties.setProperty(length, 123);
properties.setProperty(location, D:\\a.txt);
// 打印属性集对象
System.out.println(properties);
// 通过键,获取属性值
System.out.println(properties.getProperty(filename));
System.out.println(properties.getProperty(length));
System.out.println(properties.getProperty(location));
// 遍历属性集,获取所有键的集合
SetString strings properties.stringPropertyNames();
// 打印键值对
for (String key : strings ) {System.out.println(key -- properties.getProperty(key));
}
示例2
// 创建属性集对象
Properties pro new Properties();
// 加载⽂本中信息到属性集
pro.load(new FileInputStream(read.txt));
// 遍历集合并打印
SetString strings pro.stringPropertyNames();
for (String key : strings ) {System.out.println(key -- pro.getProperty(key));
}
小贴士⽂本中的数据必须是键值对形式可以使⽤空格、等号、冒号等符号分隔。
