File类
概述:
它是文件和目录名的抽象表示
文件和目录可以通过File封装成对象
对于File而言,其实封装的并不是一个真正的文件,仅仅只是一个路径名而已。它可以是存在的,也可以是不存在的。
File类的构造方法
//1.File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File f1 = new File("E:\\file\\java.txt");
//文件中并没有java.txt文件所以这里仅仅是抽象类型的表现形式
System.out.println(f1);
//2.File(String parent,String child) 从父路径名字符串和子路径名字符串创建新的File实例
File f2 = new File("E:\\file", "java.txt");
System.out.println(f2);
//3.File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的File实例
File f3 = new File("E:\\file");
File f4 = new File(f3, "java.txt");
System.out.println(f4);
File类的创建方法
方法名 | 说明 |
public boolean createNewFile() | 当具有该名称的文件不存在时,创建一个由该抽象路径名命名的新空文件 |
public boolean mkdir() | 创建由此抽象路径名命名的目录 |
public boolean mkdirs() | 创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录 |
注意事项:
创建的是文件还是文件夹是由方法最终确定的,并不能通过构造器中的参数来确定;
在同一个目录中不能出现同名的文件和目录名即使一个是文件一个是目录;
如不指明路径,默认创建在与模块同级目录下
绝对路径和相对路径的区别
相对路劲:相对路径就是指由这个文件所在的路径引起的跟其它文件(或文件夹)的路径关系。
绝对路径:完整的路径名,不需要任何其他信息就可以定位它所表示的文件。例如:E:\itcast\java.txt
删除功能:
public boolean delete()删除由此抽象路径名表示的文件或目录
注意事项:删除目录时,如果目录里有内容(不管是文件还是目录),则无法直接删除目录
递归
递归指的是方法定义中调用方法本身的现象
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
递归的最小子问题:终止条件
注意事项:
递归一定要有出口。否则内存溢出
递归虽然有出口,但是递归的次数也不宜过多。否则内存溢出
StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
IO流
IO流概述和分类
IO流介绍
IO:输入/输出(Input/Output)
流:是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输
IO流就是用来处理设备间数据传输问题的。常见的应用:文件复制;文件上传;文件下载
IO流的分类
按照数据的流向
输入流:读数据
输出流:写数据
按照数据类型来分
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流
IO流的使用场景
如果操作的是纯文本文件,优先使用字符流
如果操作的是图片、视频、音频等二进制文件。优先使用字节流
如果不确定文件类型,优先使用字节流。字节流是万能的流
字节流
字节流抽象基类:
InputStream字节输入流的所有类的超类
OutputStream字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀
字节输出流:
FileOutputStream(String name):创建文件输出流以指定的名称写入文件
字节流写数据的三种方式
FileOutputStream(String name):创建文件输出流以指定的名称写入文件
字节流写数据的方法
void write(int b) 一次写一个字节数据
void write(byte[] b) 一次写一个字节数组数据
void write(byte[] b, int off, int len)一次写一个字节数组的部分数据
在字节流写数据时该如何进行换行?
windows:\r\n
linux:\n
mac:\r
示例代码:
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("file\\fos.txt",true);
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\r\n".getBytes());
}
//释放资源
fos.close();
}
在字节流写数据如何实现追加写入?
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ,则字节将写入文件的末尾而不是开头
FileOutputStream fos = new FileOutputStream("file\\fos.txt",true);
字节流读数据
1.一次读一个字节数据
示例代码:
public static void main(String[] args) throws IOException {
//创建字节输入流对象
//FileInputStream(String name)
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
int by;
while ((by=fis.read())!=-1) {
System.out.print((char)by);
}
//释放资源
fis.close();
}
2.一次读一个字节数组数据
示例代码:
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
byte[] bys = new byte[1024]; //1024及其整数倍
int len;
while ((len=fis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
//释放资源
fis.close();
}
3.字节流复制文本文件
思想:
复制文本文件,其实就把文本文件的内容从一个文件中读取出来(数据源),然后写入到另一个文件中(目的地)
数据源:
E:\file\a.txt --- 读数据 --- InputStream --- FileInputStream
目的地:
file\a.txt --- 写数据 --- OutputStream --- FileOutputStream
代码实现:
public static void main(String[] args) throws IOException {
//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗外.txt");
//读写数据,复制文本文件(一次读取一个字节,一次写入一个字节)
/*int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}*/
//读写数据,复制文本文件(一次读取一个字节数组,一次写入一个字节数组)
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1) {
fos.write(bys,0,len);
}
//释放资源
fos.close();
fis.close();
}
注意事项:
所有关于IO流的操作最后都需要释放资源
void close()
关闭此文件输出流
释放与此流相关联的任何系统资源
字节缓冲流
介绍:
BufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
构造方法:
方法名 | 说明 |
BufferedOutputStream(OutputStream out) | 创建字节缓冲输出流对象 |
BufferedInputStream(InputStream in) | 创建字节缓冲输入流对象 |
比较基本字节流一次读写一个字节、基本字节流一次读写一个字节数组、字节缓冲流一次读写一个字节以及字节缓冲流一次读写一个字节数组,他们之间的速度
代码实现:
public class CopyAviDemo {
public static void main(String[] args) throws IOException {
//开始时间
long startTime = System.currentTimeMillis();
method1();
method2();
method3();
method4();
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("总耗时 "+(endTime-startTime)+"毫秒" +(endTime-startTime)/60);
}
private static void method1() throws IOException {
//1.基本字节流一次读一个字节 总耗时 469203毫秒
//读文件
FileInputStream fis = new FileInputStream("D:\\file\\VID_20230121_170455.mp4");
//写文件
FileOutputStream fos = new FileOutputStream("E:\\file\\视频\\基本字节流一次读一个字节.mp4");
//复制文件
int by;//保存文件的字节(一个)
while ((by= fis.read()) != -1) {
fos.write(by);
}
//关闭资源
fos.close();
fis.close();
}
private static void method2() throws IOException {
//2.基本字节流一次读一组字节 总耗时 848毫秒
FileInputStream fis = new FileInputStream("D:\\file\\VID_20230121_170455.mp4");
FileOutputStream fos = new FileOutputStream("E:\\file\\视频\\基本字节流一次读一组字节.mp4");
//复制文件
byte[] bytes = new byte[1024];
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//关闭资源
fos.close();
fis.close();
}
private static void method3() throws IOException {
//3.字节缓冲流(一次读一个) 总耗时 3725毫秒
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\file\\VID_20230121_170455.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\file\\视频\\字节缓冲流(一次一个).mp4"));
int by;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}
private static void method4() throws IOException {
//4.字节缓冲流(一次读一数组) 总耗时 238毫秒
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\file\\VID_20230121_170455.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\file\\视频\\字节缓冲流(一次一数组).mp4"));
byte[] bytes = new byte[1024];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
}
bos.close();
bis.close();
}
}
字符流
为什么有了字节流这样万能的流还要使用字符流呢?
字符流的介绍
由于字节流操作中文不是特别的方便,所以Java就提供字符流
字符流 = 字节流 + 编码表
中文的字节存储方式
用字节流复制文本文件时,文本文件也会有中文,但是没有问题,原因是最终底层操作会自动进行字节拼接成中文,如何识别是中文的呢?
汉字在存储的时候,无论选择哪种编码存储,第一个字节都是负数
编码表
什么是字符集?
是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等
l计算机要准确的存储和识别各种字符集符号,就需要进行字符编码,一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等
常见的字符集
ASCII字符集:
lASCII:是基于拉丁字母的一套电脑编码系统,用于显示现代英语,主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)
基本的ASCII字符集,使用7位表示一个字符,共128字符。ASCII的扩展字符集使用8位表示一个字符,共256字符,方便支持欧洲常用字符。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等
GBXXX字符集:
GBK:最常用的中文码表。是在GB2312标准基础上的扩展规范,使用了双字节编码方案,共收录了21003个汉字,完全兼容GB2312标准,同时支持繁体汉字以及日韩汉字等
Unicode字符集:
UTF-8编码:可以用来表示Unicode标准中任意字符,它是电子邮件、网页及其他存储或传送文字的应用 中,优先采用的编码。互联网工程工作小组(IETF)要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
编码规则:
128个US-ASCII字符,只需一个字节编码
拉丁文等字符,需要二个字节编码
大部分常用字(含中文),使用三个字节编码
其他极少使用的Unicode辅助字符,使用四字节编码
字符串中的编码解码问题
相关方法:
方法名 | 说明 |
byte[] getBytes() | 使用平台的默认字符集将该 String编码为一系列字节 |
byte[] getBytes(String charsetName) | 使用指定的字符集将该 String编码为一系列字节 |
String(byte[] bytes) | 使用平台的默认字符集解码指定的字节数组来创建字符串 |
String(byte[] bytes, String charsetName) | 通过指定的字符集解码指定的字节数组来创建字符串 |
示例代码:
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//定义一个字符串
String s = "中国";
byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
byte[] bys1 = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
byte[] bys2 = s.getBytes("GBK"); //[-42, -48, -71, -6]
System.out.println(Arrays.toString(bys));
System.out.println(Arrays.toString(bys1));
System.out.println(Arrays.toString(bys2));
String ss = new String(bys);
String ss1 = new String(bys,"UTF-8");
String ss2 = new String(bys,"GBK");
System.out.println(ss);
System.out.println(ss1);
System.out.println(ss2);
}
}
效果图:
![](https://i-blog.csdnimg.cn/blog_migrate/f7822fe9df7f1b7a02f6811bb35d19b5.png)
IDEA中默认使用UTF-8编码集
字符流中的编码解码问题
字符流中和编码解码问题相关的两个类
InputStreamReader:是从字节流到字符流的桥梁
它读取字节,并使用指定的编码将其解码为字符
它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集
OutputStreamWriter:是从字符流到字节流的桥梁
是从字符流到字节流的桥梁,使用指定的编码将写入的字符编码为字节
它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集
构造方法:
方法名 | 说明 |
InputStreamReader(InputStream in) | 使用默认字符编码创建InputStreamReader对象 |
InputStreamReader(InputStream in,String chatset) | 使用指定的字符编码创建InputStreamReader对象 |
OutputStreamWriter(OutputStream out) | 使用默认字符编码创建OutputStreamWriter对象 |
OutputStreamWriter(OutputStream out,String charset) | 使用指定的字符编码创建OutputStreamWriter对象 |
代码演示:
public class ConversionStreamDemo {
public static void main(String[] args) throws IOException {
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"GBK");
osw.write("中国");
osw.close();
//InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"),"GBK");
//一次读取一个字符数据
int ch;
while ((ch=isr.read())!=-1) {
System.out.print((char)ch);
}
isr.close();
}
}
字符流写数据的5种方式
void write(int c) | 写一个字符 |
void write(char[] cbuf) | 写入一个字符数组 |
void write(char[] cbuf, int off, int len) | 写入字符数组的一部分 |
void write(String str) | 写一个字符串 |
void write(String str, int off, int len) | 写一个字符串的一部分 |
刷新和关闭的方法
方法名 | 说明 |
flush() | 刷新流,之后还可以继续写数据 |
close() | 关闭流,释放资源,但是在关闭之前会先刷新流。一旦关闭,就不能再写数据 |
字符流读数据的2种方式
方法名 | 说明 |
int read() | 一次读一个字符数据 |
int read(char[] cbuf) | 一次读一个字符数组数据 |
字符缓冲流
介绍
BufferedWriter:将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入,可以指定缓冲区大小,或者可以接受默认大小。默认值足够大,可用于大多数用途
BufferedReader:从字符输入流读取文本,缓冲字符,以提供字符,数组和行的高效读取,可以指定缓冲区大小,或者可以使用默认大小。 默认值足够大,可用于大多数用途
构造方法:
方法名 | 说明 |
BufferedWriter(Writer out) | 创建字符缓冲输出流对象 |
BufferedReader(Reader in) | 创建字符缓冲输入流对象 |
特有功能:
BufferedWriter:
方法名 | 说明 |
void newLine() | 写一行行分隔符,行分隔符字符串由系统属性定义 |
BufferedReader:
方法名 | 说明 |
String readLine() | 读一行文字。 结果包含行的内容的字符串,不包括任何行终止字符如果流的结尾已经到达,则为null |
IO特殊操作流
标准输入、输出流
System类中有两个静态的成员变量
public static final InputStream in:标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
public static final PrintStream out:标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
输出语句的本质:是一个标准的输出流
PrintStream ps = System.out;
PrintStream类有的方法,System.out都可以使用
字节打印流
打印流分类
字节打印流:PrintStream
字符打印流:PrintWriter
打印流的特点
只负责输出数据,不负责读取数据
永远不会抛出IOException
有自己的特有方法
字节打印流
PrintStream(String fileName):使用指定的文件名创建新的打印流
使用继承父类的方法写数据,查看的时候会转码;使用自己的特有方法写数据,查看的数据原样输出
可以改变输出语句的目的地
public static void setOut(PrintStream out):重新分配“标准”输出流
字符打印流
造房方法:
方法名 | 说明 |
PrintWriter(String fileName) | 使用指定的文件名创建一个新的PrintWriter,而不需要自动执行刷新 |
PrintWriter(Writer out, boolean autoFlush) | 创建一个新的PrintWriter out:字符输出流 autoFlush: 一个布尔值,如果为真,则println , printf ,或format方法将刷新输出缓冲区 |
对象序列化流
对象序列化介绍
对象序列化:就是将对象保存到磁盘中,或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象,该字节序列包含:对象的类型、对象的数据和对象中存储的属性等信息
字节序列写到文件之后,相当于文件中持久保存了一个对象的信息
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化
对象序列化流: ObjectOutputStream
将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取(重构)对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流,则可以在另一个主机上或另一个进程中重构对象
构造方法
方法名 | 说明 |
ObjectOutputStream(OutputStream out) | 创建一个写入指定的OutputStream的ObjectOutputStream |
序列化对象的方法
方法名 | 说明 |
void writeObject(Object obj) | 将指定的对象写入ObjectOutputStream |
示例代码:
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws IOException {
//ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\file\\oos.txt"));
//创建对象
Student s = new Student("林冲",30);
//void writeObject(Object obj):将指定的对象写入ObjectOutputStream
oos.writeObject(s);
//释放资源
oos.close();
}
}
注意事项:
一个对象要想被序列化,该对象所属的类必须必须实现Serializable 接口
Serializable是一个标记接口,实现该接口,不需要重写任何方法,仅是说明该类可以被序列化
对象反序列化流
对象反序列化流: ObjectInputStream
ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
构造方法
方法名 | 说明 |
ObjectInputStream(InputStream in) | 创建从指定的InputStream读取的ObjectInputStream |
反序列化对象的方法
方法名 | 说明 |
Object readObject() | 从ObjectInputStream读取一个对象 |
示例代码:
public class ObjectInputStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\file\\oos.txt"));
//Object readObject():从ObjectInputStream读取一个对象
Object obj = ois.readObject();
Student s = (Student) obj;
System.out.println(s.getName() + "," + s.getAge());
ois.close();
}
}
serialVersionUID&transient
序列化中出现的问题:
用对象序列化流序列化了一个对象后,假如我们修改了对象所属的类文件,读取数据会不会出问题呢?
会出问题,会抛出InvalidClassException异常
如果出问题了,如何解决呢?
重新序列化
给对象所属的类加一个serialVersionUID
private static final long serialVersionUID = 42L;
transient
如果一个对象中的某个成员变量的值不想被序列化,又该如何实现呢?
给该成员变量加transient关键字修饰,该关键字标记的成员变量不参与序列化过程
示例代码
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// write();
read();
}
//反序列化
private static void read() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
Object obj = ois.readObject();
Student s = (Student) obj;
System.out.println(s.getName() + "," + s.getAge());
ois.close();
}
//序列化
private static void write() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
Student s = new Student("林青霞", 30);
oos.writeObject(s);
oos.close();
}
}
class Student implements Serializable {
private static final long serialVersionUID = 42L;
private String name;
// private int age;
//给该成员变量加transient关键字修饰,该关键字标记的成员变量不参与序列化过程
private transient int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Properties集合
Properties作为Map集合的使用
Properties介绍
是一个Map体系的集合类
Properties可以保存到流中或从流中加载
属性列表中的每个键及其对应的值都是一个字符串
Properties基本使用:
public class PropertiesDemo01 {
public static void main(String[] args) {
//创建集合对象
//Properties<String,String> prop = new Properties<String,String>(); //错误
Properties prop = new Properties();
//存储元素
prop.put("itheima001", "林青霞");
prop.put("itheima002", "张曼玉");
prop.put("itheima003", "王祖贤");
//遍历集合
Set<Object> keySet = prop.keySet();
for (Object key : keySet) {
Object value = prop.get(key);
System.out.println(key + "," + value);
}
}
}
Properties作为Map集合的特有方法:
方法名 | 说明 |
Object setProperty(String key, String value) | 设置集合的键和值,都是String类型,底层调用 Hashtable方法 put |
String getProperty(String key) | 使用此属性列表中指定的键搜索属性 |
Set<String> stringPropertyNames() | 从该属性列表中返回一个不可修改的键集,其中键及其对应的值是字符串 |
Properties和IO流相结合的方法
和IO流结合的方法
方法名 | 说明 |
void load(InputStream inStream) | 从输入字节流读取属性列表(键和元素对) |
void load(Reader reader) | 从输入字符流读取属性列表(键和元素对) |
void store(OutputStream out, String comments) | 将此属性列表(键和元素对)写入此 Properties表中,以适合于使用 load(InputStream)方法的格式写入输出字节流 |
void store(Writer writer, String comments) | 将此属性列表(键和元素对)写入此 Properties表中,以适合使用 load(Reader)方法的格式写入输出字符流 |
一个小案例
案例需求
编写一个小程序,记录程序运行的次数,满足5次后,给出提示,试用次数已到,请注册!
分析:
1.将配置文件封装成File对象,判断文件是否存在,不存在则自己创建
2.需要计数器;
3.计数器的值,生命周期要比应用程序的生命周期要长,需要对计数器的值进行持久化。
count = 1,里面存储的应该是键值方式,Map集合,要和设备上的数据关联,需要IO技术。
集合 + IO = Properties。
代码实现:
public class Demo02Special {
public static void main(String[] args) throws IOException{
//1.将配置文件封装成File对象,判断文件是否存在,不存在则自己创建
File file = new File("E:\\file\\java\\number.txt");
if (!file.exists()) {
file.createNewFile();
}
//2.计数器
Properties pro = new Properties();
pro.setProperty("次数","count");
pro.setProperty("count", String.valueOf(0));
//读取计数器文件信息,并将其存储在Properties集合中
FileReader fr = new FileReader(file.getPath());
//输出
pro.load(fr);
FileWriter fw = new FileWriter(file);
//写入
pro.store(fw,null);
//3.计数器的值,生命周期要比应用程序的生命周期要长,需要对计数器的值进行持久化(将数据保存在文件内)。
String s = pro.getProperty("count");
int count = Integer.parseInt(s);
if (count > 5) {
System.out.println("试用次数已到,请注册!");
} else {
count++;
pro.setProperty("count",String.valueOf(count));
FileWriter fw1 =new FileWriter(file.getPath());
pro.store(fw1,null);
fw.close();
}
}
}