长沙3合1网站建设价格,哈尔滨市学府头道街52号,怎样建设自己的网站的视频,怎么做推销产品的网站目录
Java缓冲流
BufferedReader和BufferedWriter类
Java随机流
Java数组流
字节数组流
ByteArrayInputStream流的构造方法#xff1a;
ByteArrayOutputStream流的构造方法#xff1a;
字符数组流
Java数据流
Java对象流
Java序列化与对象克隆
扩展小知识#x…目录
Java缓冲流
BufferedReader和BufferedWriter类
Java随机流
Java数组流
字节数组流
ByteArrayInputStream流的构造方法
ByteArrayOutputStream流的构造方法
字符数组流
Java数据流
Java对象流
Java序列化与对象克隆
扩展小知识
Java使用Scanner解析文件
使用默认分隔标记解析文件
使用正则表达式作为分隔标记解析文件
Java文件对话框
Java带进度条的输入流
Java文件锁 Java缓冲流
缓冲流是Java中的一种流它可以提供缓冲区来提高读写数据的效率。缓冲流可以将数据先暂时存储在内存中的缓冲区中然后再一次性地写入或读取减少了频繁的磁盘或网络操作从而提高了读写数据的速度。
缓冲流可以起到以下作用
提高读写效率缓冲流可以减少磁盘或网络操作的次数将数据先存储在内存中的缓冲区中再一次性地写入或读取从而提高了读写数据的效率。 提供了额外的功能缓冲流还提供了一些额外的功能如支持字符编码转换、支持行操作等。
在Java中常见的缓冲流有
BufferedInputStream它是对InputStream的包装提供了缓冲区来提高读取数据的效率。它可以一次读取多个字节到缓冲区中然后逐个字节地从缓冲区中读取减少了频繁的磁盘或网络操作。使用BufferedInputStream可以提高读取大量数据的效率。BufferedOutputStream它是对OutputStream的包装提供了缓冲区来提高写入数据的效率。它可以将数据先写入缓冲区中然后一次性地写入到目标输出流中减少了频繁的磁盘或网络操作。使用BufferedOutputStream可以提高写入大量数据的效率。BufferedReader它是对Reader的包装提供了缓冲区来提高读取字符数据的效率。它可以一次读取多个字符到缓冲区中然后逐个字符地从缓冲区中读取减少了频繁的磁盘或网络操作。使用BufferedReader可以提高读取大量字符数据的效率。BufferedWriter它是对Writer的包装提供了缓冲区来提高写入字符数据的效率。它可以将字符数据先写入缓冲区中然后一次性地写入到目标输出流中减少了频繁的磁盘或网络操作。使用BufferedWriter可以提高写入大量字符数据的效率。
这些缓冲流都是对字节流或字符流的包装可以通过构造方法将字节流或字符流传入缓冲流中然后通过缓冲流进行读写操作。
BufferedReader和BufferedWriter类
在Java中我们把BufferedReader和BufferedWriter类创建的对象称为缓冲输入输出流二者增强了读写文件的能力。比如Sudent.txt是一个学生名单每个姓名占一行。如果我们想读取名字那么每次必须读取一行使用FileReader流很难完成这样的任务因为我们不清楚一行有多少个字符FileReader类没有提供读取一行的方法。
Java提供了更高级的流BufferedReader流和BufferedWriter流二者的源和目的地必须是字符输入流和字符输出流。因此如果把文件字符输入流作为BufferedReader流的源把文件字符输出流作为BufferedWriter流的目的地那么BufferedReader和BufferedWriter类创建的流将比字符输入流和字符输出流有更强的读写能力。比如BufferedReader流就可以按行读取文件。
BufferedReader类和BufferedWriter的构造方法分别是
BufferedReader(Reader in);
BufferedWriter(Writer out);
可以把BufferedReader和BufferedWriter称为上层流把它们指向的字符流称为底层流Java采用缓存技术将上层流和底层流连接。底层字符输入流首先将数据读入缓存BufferedReader流再从缓存读取数据BufferedWriter流将数据写入缓存底层字符输出流会不断地将缓存中的数据写入到目的地。当BufferedWriter流调用flush()刷新缓存或调用close()方法关闭时即使缓存没有溢出底层流也会立刻将缓存的内容写入目的地。
注意关闭输出流时要首先关闭缓冲输出流然后关闭缓冲输出流指向的流即先关闭上层流再关闭底层流。在编写代码时只需关闭上层流那么上层流的底层流将自动关闭。
例如
由英语句子构成的文件a.txt如下每句占一行
hello
I like you
no yes
要求按行读取a.txt并在该行的后面加上该英语句子中含有的单词数目然后再将该行写入到一个名字为b.txt的文件中代码如下
import java.io.*;
import java.util.*;
public class Main {public static void main(String args[]) {File fRead new File(a.txt);File fWrite new File(b.txt);try {Writer out new FileWriter(fWrite);BufferedWriter bufferWrite new BufferedWriter(out);Reader in new FileReader(fRead);BufferedReader bufferRead new BufferedReader(in);String str;while((str bufferRead.readLine()) !null) {StringTokenizer fenxi new StringTokenizer(str);int count fenxi.countTokens();str str句子中单词个数:count;bufferWrite.write(str);bufferWrite.newLine();}bufferWrite.close();out.close();in new FileReader(fWrite);bufferRead new BufferedReader(in);String s null;System.out.println(fWrite.getName()内容:);while((sbufferRead.readLine()) !null) {System.out.println(s);}bufferRead.close();in.close();}catch(IOException e) {System.out.println(e.toString());}}
}
运行结果如下
b.txt内容:
hello句子中单词个数:1
I like you句子中单词个数:3
no yes句子中单词个数:2
Java随机流
RandomAccessFile类创建的流称做随机流与前面的输入、输出流不同的是RandomAccessFile类既不是InputStream类的子类也不是OutputStream类的子类。但是RandomAccessFile类创建的流的指向既可以作为流的源也可以作为流的目的地换句话说当准备对一个文件进行读写操作时创建一个指向该文件的随机流即可这样既可以从这个流中读取文件中的数据也可以通过这个流写入数据到文件。
注意由于RandomAccessFile是线程安全的你可以同时打开多个RandomAccessFile对象来读取同一个文件。但是请注意如果你在多个线程中同时读取文件可能会导致数据不一致或其他问题。
以下是RandomAccessFile类的两个构造方法
RandomAccessFile(String name,String mode)参数name用来确定一个文件名给出创建的流的源也是流目的地。参数mode取r(只读)或rw(可读写)决定创建的流对文件的访问权利。RandomAccessFile(File file,String mode)参数file是一个File对象给出创建的流的源也是流目的地。参数mode取r(只读)或rw(可读写)决定创建的流对文件的访问权利。
注意RandomAccessFile流指向文件时不刷新文件。
RandomAccessFile类中有一个方法seek(long a)用来定位RandomAccessFile流的读写位置其中参数a确定读写位置距离文件开头的字节个数。另外流还可以调用getFilePointer()方法获取流的当前读写位置。RandomAccessFile流对文件的读写比顺序读写更为灵活。
RandomAccessFile流的常用方法如下
方法说明close()关闭文件getFilePointer()获取当前读写的位置length()获取文件的长度read()从文件中读取一个字节的数据readBoolean()从文件中读取一个布尔值0代表false其他值代表truereadByte() 从文件中读取一个字节 readChar()从文件中读取一个字符(2个字节)readDouble()从文件中读取一个双精度浮点值(8 个字节)readFloat()从文件中读取一个单精度浮点值(4个字节)readFully(byte b[ ])读b.length字节放入数组b完全填满该数组readInt()从文件中读取一个int值(4个字节)readLine()从文件中读取一个文本行readLong()从文件中读取一个长型值(8个字节)readShort()从文件中读取一个短型值(2个字节)readUnsignedByte()从文件中读取一个无符号字节(1个字节)readUnsignedShort()从文件中读取一个无符号短型值(2个字节)readUTF()从文件中读取一个UTF字符串seek(long position)定位读写位置setLength(long newlength)设置文件的长度skipBytes(int n)在文件中跳过给定数量的字节write(byte b[])写b.length个字节到文件writeBoolean(boolean v)把一个布尔值作为单字节值写入文件writeByte(int v)向文件写入一个字节writeBytes(String s)向文件写入一个字符串writeChar(char c)向文件写入一个字符writeChars(String s)向文件写入一个作为字符数据的字符串writeDouble(double v)向文件写入一个双精度浮点值writeFloat(float v)向文件写入一个单精度浮点值writeInt(int v)向文件写入一个int值writeLong(long v)向文件写入一个长型int值writeShort(int v)向文件写入一个短型int值writeUTF(String s)写入一个UTF字符串
注意RandomAccessFile流的readLine()方法在读取含有非ASCⅡ字符的文件时比如含有汉字的文件会出现“乱码”现象。因此需要把readLine()读取的字符串用“iso-8859-1”编码重新编码存放到byte数组中然后再用当前机器的默认编码将该数组转化为字符串操作如下
读取 String str in.readLine(); 用“iso-8859-1”重新编码 byte b[] str.getBytes(iso-8859-1); 使用当前机器的默认编码将字节数组转化为字符串 String content new String(b); 如果机器的默认编码是“GB2312”那么 String content new String(b); 等同于 String content new String(b,GB2312);
随机流代码示例
import java.io.*;
public class Main {public static void main(String args[]) {RandomAccessFile inAndOut null;int data[] {1,2,3,4,5,6,7,8,9,10};try {inAndOut new RandomAccessFile(a.txt,rw);for(int i0;idata.length;i) {inAndOut.writeInt(data[i]);}for(long i data.length-1;i0;i--) {inAndOut.seek(i*4);System.out.printf(\t%d,inAndOut.readInt());/*一个int型数据占4个字节inAndOut从文件的第36个字节读取最后面的一个整数每隔4个字节往前读取一个整数*/}inAndOut.close();}catch(IOException e) {}}
}
Java数组流
我们要知道流的源和目的地除了可以是文件以外还可以是计算机内存。
字节数组流
字节数组输入流ByteArrayInputStream和字节数组输出流ByteArrayOutputStream分别使用字节数组作为流的源和目的地。
ByteArrayInputStream流的构造方法
ByteArrayInputStream(byte[] buf);
ByteArrayInputStream(byte[] buf,int offset,int length);
第一个构造方法构造的字节数组流的源是参数buf指定的数组的全部字节单元。
第二个构造方法构造的字节数组流的源是buf指定的数组从offset处按顺序取的length个字节单元。
字节数组输入流调用public int read();方法可以顺序地从源中读出一个字节该方法返回读出的字节值调用public int read(byte[] b,int off,int len);方法可以顺序地从源中读出参数len指定的字节数并将读出的字节存放到参数b指定的数组中参数off指定数组b存放读出字节的起始位置该方法返回实际读出的字节个数如果未读出字节read方法返回-1。
ByteArrayOutputStream流的构造方法
ByteArrayOutputStream();
ByteArrayOutputStream(int size);
第一个构造方法构造的字节数组输出流指向一个默认大小为32字节的缓冲区如果输出流向缓冲区写入的字节个数大于缓冲区时缓冲区的容量会自动增加。
第二个构造方法构造的字节数组输出流指向的缓冲区的初始大小由参数size指定如果输出流向缓冲区写入的字节个数大于缓冲区时缓冲区的容量会自动增加。
字节数组输出流调用public void write(int b);方法可以顺序地向缓冲区写入一个字节调用public void write(byte[ ] b,int off,int len);方法可以将参数b中指定的len个字节顺序地写入缓冲区参数off指定从b中写出的字节的起始位置调用public byte[ ] toByteArray();方法可以返回输出流写入到缓冲区的全部字节。
字符数组流
与字节数组流对应的是字符数组流CharArrayReader类和CharArrayWriter类字符数组流分别使用字符数组作为流的源和目标。
例如使用数组流向内存(输出流的缓冲区)写入“mid-autumn festival”和“中秋快乐”然后再从内存读取曾写入的数据
import java.io.*;public class Main {public static void main(String args[]) {try {// 创建一个字节数组输出流ByteArrayOutputStream outByte new ByteArrayOutputStream();// 将字节内容 mid-autumn festival 写入字节数组输出流byte [] byteContent mid-autumn festival .getBytes();outByte.write(byteContent);// 创建一个字节数组输入流并将字节数组输出流的内容传递给它ByteArrayInputStream inByte new ByteArrayInputStream(outByte.toByteArray());// 创建一个与字节数组输出流长度相同的字节数组byte backByte [] new byte[outByte.toByteArray().length];// 从字节数组输入流中读取内容到 backByte 数组中inByte.read(backByte);// 将 backByte 数组转换为字符串并打印出来System.out.println(new String(backByte));// 创建一个字符数组输出流CharArrayWriter outChar new CharArrayWriter();// 将字符内容 中秋快乐 写入字符数组输出流char [] charContent 中秋快乐.toCharArray();outChar.write(charContent);// 创建一个字符数组输入流并将字符数组输出流的内容传递给它CharArrayReader inChar new CharArrayReader(outChar.toCharArray());// 创建一个与字符数组输出流长度相同的字符数组char backChar [] new char [outChar.toCharArray().length];// 从字符数组输入流中读取内容到 backChar 数组中inChar.read(backChar);// 将 backChar 数组转换为字符串并打印出来System.out.println(new String(backChar));}catch(IOException exp) {// 处理可能发生的 IOException 异常exp.printStackTrace();}}
}
Java数据流
DataInputStream和DataOutputStream类创建的对象称为数据输入流和数据输出流。这两个流是很有用的两个流它们允许程序按着机器无关的风格读取Java原始数据。也就是说当读取一个数值时不必再关心这个数值应当是多少个字节。
DataInputStream和DataOutputStream的构造方法如下
DataInputStream(InputStream in)创建的数据输入流指向一个由参数in指定的底层输入流。DataOutputStream(OutputStream out)创建的数据输出流指向一个由参数out指定的底层输出流。
DataInputStream和DataOutputStream类的常用方法如下
方法说明close()关闭流readBoolean()读取一个布尔值readByte()读取一个字节readChar()读取一个字符readDouble()读取一个双精度浮点值readFloat()读取一个单精度浮点值readInt()读取一个int值readLong()读取一个长型值readShort()读取一个短型值readUnsignedByte()读取一个无符号字节readUnsignedShort()读取一个无符号短型值readUTF()读取一个UTF字符串skipBytes(int n)跳过给定数量的字节writeBoolean(boolean v)写入一个布尔值writeBytes(String s)写入一个字符串writeChars(String s)写入字符串writeDouble(double v)写入一个双精度浮点值writeFloat(float v)写入一个单精度浮点值writeInt(int v)写入一个int值writeLong(long v)写入一个长型int值writeShort(int v)写入一个短型int值writeUTF(String s)写入一个UTF字符串
例如写几个Java类型的数据到一个文件然后再读出来
import java.io.*;public class Main {public static void main(String[] args) {// 写入文件try (DataOutputStream outputStream new DataOutputStream(new FileOutputStream(a.txt))) {int intValue 10;double doubleValue 3.14;String stringValue Hello, World!;outputStream.writeInt(intValue);outputStream.writeDouble(doubleValue);outputStream.writeUTF(stringValue);System.out.println(数据写入成功);} catch (IOException e) {e.printStackTrace();}// 读取文件try (DataInputStream inputStream new DataInputStream(new FileInputStream(a.txt))) {int intValue inputStream.readInt();double doubleValue inputStream.readDouble();String stringValue inputStream.readUTF();System.out.println(读取的整数值 intValue);System.out.println(读取的浮点数值 doubleValue);System.out.println(读取的字符串值 stringValue);} catch (IOException e) {e.printStackTrace();}}
}Java对象流
ObjectInputStream和ObjectOutputStream类分别是InputStream和OutputStream类的子类。ObjectInputStream和ObjectOutputStream类创建的对象称为对象输入流和对象输出流。对象输出流使用writeObject(Object obj)方法将一个对象obj写入到一个文件对象输入流使用readObject()读取一个对象到程序中。
ObjectInputStream和ObjectOutputStream类的构造方法如下
ObjectInputStream(InputStream in)ObjectOutputStream(OutputStream out)
ObjectOutputStream的指向应当是一个输出流对象因此当准备将一个对象写入到文件时首先用OutputStream的子类创建一个输出流。
例如用FileOutputStream创建一个文件输出流代码如下
FileOutputStream fileOut new FileOutputStream(a.txt);
ObjectOutputStream objectout new ObjectOutputStream(fileOut);
同样ObjectInputStream的指向应当是一个输入流对象因此当准备从文件中读入一个对象到程序中时首先用InputStream的子类创建一个输入流。
例如用FileInputStream创建一个文件输入流代码如下
FileInputStream fileIn new FileInputStream(a.txt);
ObjectInputStream objectIn new ObjectInputStream(fileIn);
当使用对象流写入或读入对象时要保证对象是序列化的,这是为了保证能把对象写入到文件并能再把对象正确读回到程序中。
一个类如果实现了Serializable接口(java.io包中的接口)那么这个类创建的对象就是所谓序列化的对象。Java类库提供的绝大多数对象都是所谓序列化的。需要强调的是Serializable接口中没有方法因此实现该接口的类不需要实现额外的方法。另外需要注意的是使用对象流把一个对象写入到文件时不仅要保证该对象是序列化的而且该对象的成员对象也必须是序列化的。
Serializable接口中的方法对程序是不可见的因此实现该接口的类不需要实现额外的方法当把一个序列化的对象写入到对象输出流时JVM就会实现Serializable接口中的方法将一定格式的文本(对象的序列化信息)写入到目的地。当ObjectInputStream对象流从文件读取对象时就会从文件中读回对象的序列化信息并根据对象的序列化信息创建一个对象。
下面是一个使用这两个类进行对象序列化和反序列化的Java代码示例
import java.io.*;public class Main {public static void main(String[] args) {// 序列化对象并写入文件try (ObjectOutputStream outputStream new ObjectOutputStream(new FileOutputStream(data.obj))) {// 创建一个自定义对象Person person new Person(John Doe, 25);// 将对象写入文件outputStream.writeObject(person);System.out.println(对象序列化成功);} catch (IOException e) {e.printStackTrace();}// 反序列化对象并读取文件try (ObjectInputStream inputStream new ObjectInputStream(new FileInputStream(data.obj))) {// 从文件中读取对象Person deserializedPerson (Person) inputStream.readObject();System.out.println(读取的对象信息);System.out.println(姓名 deserializedPerson.getName());System.out.println(年龄 deserializedPerson.getAge());} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}// 自定义Person类需要实现Serializable接口才能被序列化static class Person implements Serializable {private String name;private int age;public Person(String name, int age) {this.name name;this.age age;}public String getName() {return name;}public int getAge() {return age;}}
}上述代码创建了一个名为Person的自定义类并在其中定义了姓名和年龄属性。该类实现了Serializable接口使得对象可以被序列化。首先将一个Person对象序列化并写入到名为data.obj的文件中。然后从文件中反序列化出对象并进行相关信息的打印输出。
请注意要想使自定义类能够被序列化需要确保该类实现了Serializable接口。同时反序列化过程需要进行类型转换以恢复原始的对象类型。
Java序列化与对象克隆
Java的序列化和对象克隆都是用于处理对象的机制但它们有不同的作用和实现方式。 序列化Serialization:
序列化用于将对象转换为字节流的过程以便在网络传输或持久化存储时使用。通过实现Serializable接口类可以支持序列化。该接口没有任何方法只是一个标记接口。使用ObjectOutputStream将对象写入输出流使用ObjectInputStream从输入流中读取对象。序列化过程会将对象的状态以及对象包含的数据保存下来然后可以重新反序列化为原始对象。 对象克隆Object Cloning:
对象克隆用于创建一个现有对象的副本以便通过克隆对象进行操作而不影响原对象。在默认情况下Java中的对象克隆是浅克隆即只复制对象本身而不复制引用类型的成员变量。要实现对象克隆类必须实现Cloneable接口并重写clone()方法。使用clone()方法可以创建一个新的与原始对象相同的副本。
虽然序列化和对象克隆都涉及对象的复制和重建但它们的应用场景有所不同
序列化主要用于对象的传输和持久化存储例如在网络通信中发送对象、将对象保存到文件或数据库中。对象克隆主要用于创建一个相同属性的对象副本在某些场景下可以提高性能、降低开销或简化代码逻辑。
需要注意的是虽然对象克隆可以方便地创建对象的副本但它也有一些潜在问题如浅克隆的风险、深克隆的复杂性等。因此在使用对象克隆时需要谨慎并根据具体需求选择合适的实现方式。
扩展小知识
在编程中克隆(Clone)和拷贝(Copy)是用于复制对象或数据的概念但它们有一些区别 克隆(Clone)
克隆是创建一个与原始对象具有相同状态和数据的全新对象。克隆使用的是对象克隆机制通过调用对象的 clone() 方法实现。克隆得到的对象是独立的对克隆对象的修改不会影响原始对象。在默认情况下Java 的对象克隆是浅克隆只复制对象本身而不复制引用类型的成员变量。如果需要深度克隆需要在 clone() 方法中手动处理引用类型的成员变量。 拷贝(Copy)
拷贝是指将一个对象或数据的值复制到另一个对象或数据中。拷贝可以通过多种方式进行包括不同层级的拷贝如深拷贝和浅拷贝、手动逐个复制属性等。拷贝的实现方式依赖于编程语言或框架提供的特定操作或函数。
区别总结
克隆是创建一个全新的、与原始对象具有相同状态和数据的对象通过对象自身的克隆机制实现。拷贝是将一个对象或数据的值复制到另一个对象或数据中可以使用不同方式实现。克隆得到的对象是独立的对克隆对象的修改不会影响原始对象而拷贝得到的对象可能与原始对象共享引用数据。在 Java 中默认的对象克隆是浅克隆需要手动处理引用类型的成员变量以实现深度克隆而拷贝可以根据需求选择不同层级的拷贝方式。
下面是一个使用Java序列化和对象克隆进行对象复制的代码示例
import java.io.*;// 实现Serializable接口以支持序列化
class Person implements Serializable, Cloneable {private String name;private int age;public Person(String name, int age) {this.name name;this.age age;}// 省略了Getter和Setter方法Overridepublic String toString() {return Person{name name , age age };}// 重写clone()方法实现对象的深拷贝Overridepublic Object clone() throws CloneNotSupportedException {// 调用父类的clone()方法进行浅拷贝Person clonedPerson (Person) super.clone();// 对非基本类型的字段进行拷贝clonedPerson.name new String(this.name);return clonedPerson;}
}public class Main {public static void main(String[] args) {// 使用序列化进行对象复制Person person1 new Person(Alice, 25);Person person2 null;try {// 将person1序列化为字节流ByteArrayOutputStream byteOut new ByteArrayOutputStream();ObjectOutputStream objectOut new ObjectOutputStream(byteOut);objectOut.writeObject(person1);// 将字节流反序列化为person2对象ByteArrayInputStream byteIn new ByteArrayInputStream(byteOut.toByteArray());ObjectInputStream objectIn new ObjectInputStream(byteIn);person2 (Person) objectIn.readObject();// 通过序列化实现的对象复制完成System.out.println(使用序列化进行对象复制);System.out.println(原始对象 person1);System.out.println(复制后的对象 person2);} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}// 使用对象克隆进行对象复制Person person3 new Person(Bob, 30);Person person4 null;try {// 调用person3的clone()方法进行对象克隆person4 (Person) person3.clone();// 通过对象克隆实现的对象复制完成System.out.println(使用对象克隆进行对象复制);System.out.println(原始对象 person3);System.out.println(复制后的对象 person4);} catch (CloneNotSupportedException e) {e.printStackTrace();}}
}注意clone()方法在java.lang.Object类中是受保护的成员意味着它只能被同一类或子类中的方法访问。这使得对象克隆只能在类内部或继承关系中使用。在示例代码中要想成功对Person对象进行克隆必须在Person类中实现Cloneable接口并覆盖clone()方法将其访问控制修改为public。通过在Person类中实现Cloneable接口并重写clone()方法并将其访问控制修改为public就可以在示例代码中成功地使用对象克隆进行复制了。
Java使用Scanner解析文件
使用默认分隔标记解析文件
创建Scanner对象并指向要解析的文件例如
File file new File(a.txt);
Scanner sc new Scanner(file);
那么sc将空格作为分隔标记调用next()方法依次返回file中的单词如果file最后一个单词已被next()方法返回sc调用hasNext()将返回false否则返回true。
另外对于数字型的单词比如108167.92等可以用nextInt()或nextDouble()方法来代替next()方法即sc可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回但需要特别注意的是如果单词不是数字型单词调用nextInt()或nextDouble()方法将发生InputMismatchException异常在处理异常时可以调用next()方法返回该非数字化单词。
使用正则表达式作为分隔标记解析文件
创建Scanner对象指向要解析的文件并使用useDelimiter方法指定正则表达式作为分隔标记例如
File file new File(a.txt);
Scanner sc new Scanner(file);
sc.useDelimiter(正则表达式);
那么sc将正则表达式作为分隔标记调用next()方法依次返回file中的单词如果file最后一个单词已被next()方法返回sc调用hasNext()将返回false否则返回true。
另外对于数字型的单词比如19790.618等可以用nextInt()或nextDouble()方法来代替next()方法即sc可以调用nextInt()或nextDouble()方法将数字型单词转化为int或double数据返回但需要特别注意的是如果单词不是数字型单词调用nextInt()或nextDouble()方法将发生InputMismatchException异常那么在处理异常时可以调用next()方法返回该非数字化单词。
以下是使用Scanner解析文件中的数字并计算这些数字的平均值的代码示例
a.txt:
张三的成绩是70分李四的成绩是80分赵五的成绩是90分。
import java.io.*;
import java.util.*;public class Main {public static void main(String[] args) {File file new File(a.txt);Scanner sc null;int count 0;double sum 0;try {double score 0;sc new Scanner(file);sc.useDelimiter([^0123456789.]); // 使用非数字字符作为分隔符while (sc.hasNextDouble()) {score sc.nextDouble();count;sum sum score;System.out.println(score);}double average sum / count;System.out.println(平均成绩 average);// 关闭Scannersc.close();} catch (Exception exp) {System.out.println(exp);}}
}Java文件对话框
文件对话框是一个选择文件的界面。Javax.swing包中的JFileChooser类可以创建文件对话框使用该类的构造方法JFileChooser()创建初始不可见的有模式文件对话框。然后文件对话框调用下述2个方法
showSaveDialog(Component a);
showOpenDialog(Component a);
都可以使得对话框可见只是呈现的外观有所不同showSaveDialog方法提供保存文件的界面showOpenDialog方法提供打开文件的界面。上述两个方法中的参数a指定对话框可见时的位置当a是null时文件对话框出现在屏幕的中央如果组件a不空文件对话框在组件a的正前面居中显示。
用户单击文件对话框上的“确定”、“取消”或“关闭”图标文件对话框将消失ShowSaveDialog()或showOpenDialog()方法返回下列常量之一
JFileChooser.APPROVE OPTION
JFileChooser.CANCEL_OPTION
如果希望文件对话框的文件类型是用户需要的几种类型比如扩展名是.jpeg等图像类型的文件可以使用FileNameExtensionFilter类事先创建一个对象在JDK 1.6版本FileNameExtensionFilter类在javax.swing.filechooser包中。
下面是一个示例代码片段演示了如何使用JFileChooser类创建文件对话框并设置文件类型过滤器
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;public class Main {public static void main(String[] args) {// 创建文件对话框对象JFileChooser fileChooser new JFileChooser();// 设置文件类型过滤器FileNameExtensionFilter filter new FileNameExtensionFilter(图像文件, jpg, gif);fileChooser.setFileFilter(filter);// 显示保存文件对话框并获取用户操作的结果int result fileChooser.showSaveDialog(null);// 处理用户的操作结果if (result JFileChooser.APPROVE_OPTION) {// 用户点击了确定按钮String selectedFilePath fileChooser.getSelectedFile().getPath();System.out.println(用户选择的文件路径 selectedFilePath);} else if (result JFileChooser.CANCEL_OPTION) {// 用户点击了取消按钮System.out.println(用户取消了操作);}}
}在上述示例中我们创建了一个JFileChooser对象并通过setFileFilter()方法设置文件类型过滤器为指定的图像文件类型.jpg和.gif。然后我们调用showSaveDialog(null)来显示保存文件的文件对话框。根据用户的操作结果我们可以处理用户选中的文件路径或取消操作的情况。
Java带进度条的输入流
ProgressMonitorInputStream是一个可以显示读取进度条的输入流类。它可以在文件读取过程中弹出一个进度条窗口来显示读取速度和进度。其构造方法是
ProgressMonitor InputStream(Conmponent c,String s,InputStream);
组件c指定了进度条窗口将显示在哪个组件的前面。可以传入一个具体的组件对象如JFrame或JPanel进度条会显示在该组件的正前方。如果你传入null则进度条将显示在屏幕的正前方。字符串s是进度条窗口的标题用于描述正在进行的操作。可以根据需要给进度条窗口设置一个有意义的标题。输入流InputStream是要读取的文件的输入流。通过将文件输入流传给ProgressMonitorInputStream你可以在读取文件时实时显示进度条并监控读取的进度。
需要注意的是ProgressMonitorInputStream属于javax.swing包所以在使用之前需要确保已经导入该包。另外为了使进度条能够正常显示需要在图形界面线程中执行文件的读取操作。
import javax.swing.*;
import java.io.*;public class Main {public static void main(String args[]) {byte b[] new byte[1024]; // 增加缓冲区的大小以便更好地读取文件内容try {FileInputStream input new FileInputStream(a.txt);// 创建进度条窗口的父组件例如JFrameJFrame frame new JFrame();ProgressMonitorInputStream in new ProgressMonitorInputStream(frame, 读取txt, input);ProgressMonitor p in.getProgressMonitor(); // 获得进度条int bytesRead; // 用来记录每次读取到的字节数while ((bytesRead in.read(b)) ! -1) {String s new String(b, 0, bytesRead); // 仅使用读取到的字节构建字符串System.out.print(s);Thread.sleep(1000); // 为了看清进度条延迟了一定时间}in.close();// 关闭进度条窗口frame.dispose();} catch (Exception e) {e.printStackTrace();}}
}Java文件锁
通过使用文件锁可以确保多个程序对同一个文件进行处理时不会发生混乱。Java在JDK 1.4版本后提供了文件锁功能可以通过FileLock和FileChannel类来实现。
下面是使用文件锁的基本步骤
使用RandomAccessFile流建立指向文件的流对象并设置读写属性为rw。 RandomAccessFile input new RandomAccessFile(a.txt,rw); input流调用方法getChannel()获得一个连接到底层文件的FileChannel对象(信道)。 FileChannel channel input.getChannel(); 信道调用tryLock()或lock()方法获得一个FileLock(文件锁)对象这一过程也称做对文件加锁。 FileLock lock channel.tryLock();
文件锁对象产生后将禁止任何程序对文件进行操作或再进行加锁。对一个文件加锁之后如果想读、写文件必须让FileLock对象调用release()释放文件锁。
lock.release();
以下是一个代码示例演示如何使用文件锁进行文件读写
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;public class Main {public static void main(String[] args) {RandomAccessFile file null;FileChannel channel null;FileLock lock null;try {// 1. 创建RandomAccessFile流对象并设置读写属性为rwfile new RandomAccessFile(a.txt, rw);// 2. 获取FileChannel对象channel file.getChannel();while (true) {try {// 3. 尝试加锁lock channel.tryLock();if (lock ! null) {// 文件已被锁定System.out.println(文件已被锁定);// 进行文件读取操作String line file.readLine();System.out.println(读取的文本: line);// 释放文件锁lock.release();System.out.println(释放文件锁);// 继续下一轮循环continue;}} catch (Exception e) {// 加锁失败e.printStackTrace();}// 等待一段时间后再尝试加锁Thread.sleep(1000);}} catch (Exception e) {e.printStackTrace();} finally {try {if (file ! null)file.close();if (channel ! null)channel.close();} catch (Exception e) {e.printStackTrace();}}}
}该示例中首先创建一个RandomAccessFile对象并设置读写属性为rw。然后通过调用getChannel()方法获取与文件连接的FileChannel对象。进入循环后程序会尝试对文件进行加锁并检查是否成功获取到FileLock对象。如果成功获取到锁则进行文件读取操作读取完毕后释放文件锁。如果未能获取到锁则等待一段时间后再次尝试。
