织梦发布网站,建网站做淘宝客赚钱吗,网站建设时间怎样看,沈阳专业网站建设1、File 不同的操作系统对于档案系统路径的设定各有差别#xff0c;例如在Windows中#xff0c;一个路径的表示法可能是#xff1a; c:\\Windows\\Fonts\\ 而在Linux下的路径设定可能是#xff1a; /home/justin/ Windows的路径指定是使用UNC…1、File 不同的操作系统对于档案系统路径的设定各有差别例如在Windows中一个路径的表示法可能是 c:\\Windows\\Fonts\\ 而在Linux下的路径设定可能是 /home/justin/ Windows的路径指定是使用UNCUniversal Naming Convention路径名以\\开始表示磁盘根目录如果没有以\\开始表示相对路径c是可选的磁盘指定后面跟随着 : 字符。而UNIX-Like系统的路径指定以 / 开始表示绝对路径不以 / 开始表示相对路径。因而在程序中设定路径时会有系统相依性的问题File类别提供一个抽象的、与系统独立的路径表示您给它一个路径字符串它会将它转换为与系统无关的抽象路径表示这个路径可以指向一个档案、目录或是URI您可以用以下四种方式来建构File的实例 File(File parent, String child)
File(String pathname)
File(String parent, String child)
File(URI uri) 一个File的实例被建立时它就不能再被改变内容File类别除了用来表示一个档案或目录的抽象表示之外它还提供了不少相关操作方法您可以用它来对档案系统作一些查询与设定的动作。来看个简单的程序 FileDemo.java package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class FileDemo {public static void main(String[] args) {try {File file new File(args[0]);if(file.isFile()) { // 是否为档案System.out.println(args[0] 档案);System.out.print(file.canRead() ? 可读 : 不可读 );System.out.print(file.canWrite() ? 可写 : 不可写 );System.out.println(file.length() 字节);}else {// 列出所有的档案及目录File[] files file.listFiles();ArrayList fileList new ArrayList();for(int i 0; i files.length; i) {// 先列出目录if(files[i].isDirectory()) { //是否为目录// 取得路径名System.out.println([ files[i].getPath() ]);}else {// 档案先存入fileList待会再列出fileList.add(files[i]);}}// 列出档案for(File f: fileList) {System.out.println(f.toString());}System.out.println();}}catch(ArrayIndexOutOfBoundsException e) {System.out.println(using: java FileDemo pathname);}}
}执行结果 java onlyfun.caterpillar.FileDemo C:\
[C:\WINDOWS]
[C:\Documents and Settings]
[C:\Program Files]
[C:\System Volume Information]
[C:\Recycled]
C:\A3N_A3L.10
C:\bootfont.bin
C:\ntldr
C:\NTDETECT.COM
C:\boot.ini
C:\CONFIG.SYS
C:\AUTOEXEC.BAT
C:\IO.SYS
C:\MSDOS.SYS
C:\Finish.log
C:\pagefile.sys
C:\VIRTPART.DAT 9、RandomAccessFile 档案存取通常是「循序的」每在档案中存取一次读取档案的位置就会相对于目前的位置前进然而有时候您必须对档案的某个区段进行读取或写入的动作也就是进行「随机存取」Random access也就是说存取档案的位置要能在档案中随意的移动这时您可以使用RandomAccessFile使用seek()方法来指定档案存取的位置指定的单位是字节藉由它您就可以对档案进行随机存取的动作。为了方便通常在随机存取档案时会固定每组资料的长度例如一组学生个人数据Java中并没有像C/C中可以直接写入一个固定长度结构Structure的方法所以在固定每组长度的方面您必须自行设计。下面这个程序示范了如何使用RandomAccessFile来写入档案并随机读出一笔您所想读出的资料 Student.java package onlyfun.caterpillar;
public class Student {private String name; // 固定 15 字符private int score;public Student() {setName(noname);}public Student(String name, int score) {setName(name);this.score score;}public void setName(String name) {StringBuilder builder null;if(name ! null)builder new StringBuilder(name);elsebuilder new StringBuilder(15);builder.setLength(15);this.name builder.toString();}public void setScore(int score) {this.score score;}public String getName() {return name;}public int getScore() {return score;}// 每笔数据固定写入34字节public static int size() {return 34;}
}RandomAccessFileDemo.java package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class RandomAccessFileDemo {public static void main(String[] args) {Student[] students {new Student(Justin, 90),new Student(momor, 95),new Student(Bush, 88),new Student(caterpillar, 84)};try {File file new File(args[0]);// 建立RandomAccessFile实例并以读写模式开启档案RandomAccessFile randomAccessFile new RandomAccessFile(file, rw);for(int i 0; i students.length; i) {randomAccessFile.writeChars(students[i].getName());randomAccessFile.writeInt(students[i].getScore());}Scanner scanner new Scanner(System.in);System.out.print(读取第几笔数据);int num scanner.nextInt();randomAccessFile.seek((num-1) * Student.size());Student student new Student();student.setName(readName(randomAccessFile));student.setScore(randomAccessFile.readInt());System.out.println(姓名 student.getName());System.out.println(分数 student.getScore());randomAccessFile.close();}catch(ArrayIndexOutOfBoundsException e) {System.out.println(请指定文件名称);}catch(IOException e) {e.printStackTrace();}}private static String readName(RandomAccessFile randomAccessfile)throws IOException {char[] name new char[15];for(int i 0; i name.length; i)name[i] randomAccessfile.readChar();return new String(name).replace(\0, );}
} 在实例化一个RandomAccessFile对象时要设定档案开启的方式设定r表示只供读取设定rw表示可读可写为了让每组数据长度固 定在写入name时我们使用 StringBuilder 并设定其长度固定为15个字符而读回name时则直接读回15个字符然后再去掉空格符传回。 10、InputStream与OutputStream 计算机中的数据都是以0与1的方式来储存如果您要在两个装置之间进行数据的存取当然也是以0与1位的方式来进行实际上数据的流动是透过电路而上面 的数据则是电流而在程序上来说将数据目的地与来源之间抽象化为一个串流Stream而当中流动的则是位数据。 01010101 Stream --来源地 目的地 在Java中有两个类别用来作串流的抽象表示InputStream与OutputStream。InputStream是所有表示位输入串流的类别之父类别它是一个抽象类别子类会重新定义它当中所定义的方法 InputStream用于从装置来源地读取数据的抽象表示例如System中的标准输入串流 in 对象就是一个 InputStream在程序开始之后这个串流对象就会开启以从标准输入装置中读取数据这个装置通常是键盘或是其它使用者定义的装置。OutputStream是所有表示位输出串流的类别之父类别它是一个抽象类别子类会重新定义它当中所定义的方法 OutputStream是用于将数据写入目的地的抽象表示例如System中的标准输出串流对象 out out 的类型是PrintStream 这个类别是OutputStream的子类别FilterOutputStream继承OutputStream PrintStream再继承FilterOutputStream在程序开始之后这个串流对象就会开启您可以将数据透过它来写入目的地装置这 个装置通常是屏幕或其它使用者定义的装置。下面程序可以读取键盘输入串流并将资料以10进位方式显示在屏幕上 StreamDemo.java package onlyfun.caterpillar;
import java.io.*;
public class StreamDemo {public static void main(String[] args) {try {System.out.print(输入字符: );System.out.println(输入字符十进制表示: System.in.read());System.out.println(换行字符十进制表示: System.in.read());}catch(IOException e) {e.printStackTrace();}}
}执行结果 输入字符: A?
输入字符十进制表示: 65
换行字符十进制表示: 10 字符A输入后被标准输入串流读取A的位表示以十进制来看就是65这是A字符的编码查查ASCII编码表就知道了在这边要注意的是read()只读取一个字节的数据而当输入A并按Enter键时实际上在串流中会有A的位数据与换行字符的位数据换行字符的位数据以十进制来表示的话就是10。操作系统之间的换行字符各不相同Windows 为\r\nLinux 为\n而 Mac 为\r。 11、BufferedInputStream、 BufferedOutputStream 在介绍 FileInputStream、 FileOutputStream的 例子中您使用了一个数组来作为数据读入的缓冲区以档案存取为例的话您知道磁盘存取的速度是远低于内存中的数据存取速度为了减少对磁盘的存 您一次读入一定长度的数据如上一个主题范例中的1024字节而写入时也是一次写入一定长度的数据这可以增加数据存取的效率。 BufferedInputStream与BufferedOutputStream可以为InputStream类的对象增加缓冲区功能使用它们您无需自行设计缓冲区。BufferedInputStream的数据成员buf是个位数组预设为2048字节大小当读取数据来源时例如档案 BufferedInputStream会尽量将buf填满当使用read()方法时实际上是先读取buf中的数据而不是直接对数据来源作读取当buf中的数据不足时BufferedInputStream才会再从数据来源中提取数据。BufferedOutputStream的数据成员buf是个位数组预设为512个字节当写入数据时会先将资料存至buf中当buf已满时才会一次将数据写至目的地而不是每次写入都对目的地作写入。将上一个主题的范例作个改写这次不用自行设定缓冲区并进行判断了使用BufferedInputStream、 BufferedOutputStream让程序看来简单一些也比较有效率 BufferedStreamDemo.java package onlyfun.caterpillar;
import java.io.*;
public class BufferedStreamDemo {public static void main(String[] args) {try {byte[] data new byte[1];File srcFile new File(args[0]);File desFile new File(args[1]);BufferedInputStream bufferedInputStream new BufferedInputStream(new FileInputStream(srcFile));BufferedOutputStream bufferedOutputStream new BufferedOutputStream(new FileOutputStream(desFile));System.out.println(复制档案 srcFile.length() 字节);while(bufferedInputStream.read(data) ! -1) {bufferedOutputStream.write(data);}// 将缓冲区中的数据全部写出bufferedOutputStream.flush();// 关闭串流bufferedInputStream.close();bufferedOutputStream.close();}catch(ArrayIndexOutOfBoundsException e) {System.out.println(using: java UseFileStream src des);e.printStackTrace();}catch(IOException e) {e.printStackTrace();}}
}为了确保缓冲区中的数据一定被写出建议最后执行flush()将缓冲区中的数据全部写出目的串流中。 BufferedInputStream、BufferedOutputStream并没有改变来源InputStream或目的 OutputStream的行为读入或写出时的动作还是InputStream、OutputStream负责 BufferedInputStream、BufferedOutputStream只是在这之前动态的为它们加上一些功能像是缓冲区功能在这边是 以档案存取串流为例实际上您可以在其它串流对象上加上BufferedInputStream、BufferedOutputStream功能。 12、FileInputStream、 FileOutputStream FileInputStream是InputStream的子类由名称上就可以知道 FileInputStream主要就是从指定的档案中读取数据至目的地。FileOutputStream是OutputStream的子类顾名思义FileInputStream主要就是从来源地写入数据至指定的档案中。标准输入输出串流对象在程序一开始就会开启但只有当您建立一个FileInputStream或FileOutputStream的实例时实际的串流才会开启而不使用串流时也必须自行关闭串流以释放与串流相依的系统资源。下面这个程序可以复制档案程序先从来源档案读取数据至一个位缓冲区中然后再将位数组的数据写入目的档案 FileStreamDemo.java package onlyfun.caterpillar;
import java.io.*;
public class FileStreamDemo {public static void main(String[] args) {try {byte[] buffer new byte[1024];FileInputStream fileInputStream new FileInputStream(new File(args[0]));FileOutputStream fileOutputStream new FileOutputStream(new File(args[1]));System.out.println(复制档案 fileInputStream.available() 字节);while(true) { // 从来源档案读取数据至缓冲区if(fileInputStream.available() 1024) {int remain;while((remain fileInputStream.read())! -1) {fileOutputStream.write(remain);}break;}else {fileInputStream.read(buffer);// 将数组数据写入目的档案fileOutputStream.write(buffer);}}// 关闭串流fileInputStream.close();fileOutputStream.close();System.out.println(复制完成);}catch(ArrayIndexOutOfBoundsException e) {System.out.println(using: java FileStreamDemo src des);e.printStackTrace();}catch(IOException e) {e.printStackTrace();}}
}这个程序示范了两个 read() 方法一个可以读入指定长度的数据至数组一个一次可以读入一个字节每次读取之后读取的指标都会往前进您使用available()方法获得还有多少字节可以读取除了使用File来建立FileInputStream、FileOutputStream的实例之外您也可以直接使用字符串指定路径来建立。不使用串流时记得使用close()方法自行关闭串流以释放与串流相依的系统资源。 13、ObjectInputStream、ObjectOutputStream 在Java这样支持对象导向的程序中撰写程序很多数据都是以对象的方式存在在程序运行过后您会希望将这些数据加以储存以供下次执行程序时使用这时您可以使用ObjectInputStream、ObjectOutputStream来进行这项工作。要被储存的对象必须实作Serializable接口说是实作其实Serializable中并没有规范任何必须实作的方法所以这边所谓实作的意义其实像是对对象贴上一个标志代表该对象是可以序列化的Serializable。一个实作的例子如下所示 Student.java package onlyfun.caterpillar;
import java.io.*;
public class Student implements Serializable {private static final long serialVersionUID 1L;private String name;private int score;public Student() {name N/A;}public Student(String name, int score) {this.name name;this.score score;}public void setName(String name) {this.name name;}public void setScore(int score) {this.score score;}public String getName() {return name;}public int getScore() {return score;}public void showData() {System.out.println(name: name);System.out.println(score: score);}
}您要注意到serialVersionUID这代表了可序列化对象的版本 如果您没有提供这个版本讯息则会自动依类名称、实现的接口、成员等讯息来产生如果是自动产生的则下次您更改了Student类则自动产生的 serialVersionUID也会跟着变更当反序列化时两个serialVersionUID不相同的话就会丢出 InvalidClassException如果您想要维持版本讯息的一致则要显式宣告serialVersionUID。ObjectInputStream、ObjectOutputStream为InputStream、OutputStream加上了可以让使用者写入 对象、读出对象的功能在写入对象时我们使用writeObject()方法读出对象时我们使用readObject()方法被读出的对象都是以 Object的型态传回您必须将之转换为对象原来的型态才能正确的操作被读回的对象下面这个程序示范了如何简单的储存对象至档案中并将之再度读 回 ObjectStreamDemo.java package onlyfun.caterpillar;
import java.io.*;
import java.util.*;
public class ObjectStreamDemo {public static void writeObjectsToFile(Object[] objs, String filename) {File file new File(filename);try {ObjectOutputStream objOutputStream new ObjectOutputStream(new FileOutputStream(file));for(Object obj : objs) {objOutputStream.writeObject(obj);}objOutputStream.close();}catch(IOException e) {e.printStackTrace();}}public static Object[] readObjectsFromFile(String filename)throws FileNotFoundException {File file new File(filename);if(!file.exists())throw new FileNotFoundException();List list new ArrayList();try {FileInputStream fileInputStream new FileInputStream(file);ObjectInputStream objInputStream new ObjectInputStream(fileInputStream);while(fileInputStream.available() 0) {list.add(objInputStream.readObject());}objInputStream.close();}catch(ClassNotFoundException e) {e.printStackTrace();}catch(IOException e) {e.printStackTrace();}return list.toArray();}public static void appendObjectsToFile(Object[] objs, String filename)throws FileNotFoundException {File file new File(filename);if(!file.exists())throw new FileNotFoundException();try {ObjectOutputStream objOutputStream new ObjectOutputStream(new FileOutputStream(file, true)) {protected void writeStreamHeader()throws IOException {}};?for(Object obj : objs) {objOutputStream.writeObject(obj);}objOutputStream.close();}catch(IOException e) {e.printStackTrace();}}public static void main(String[] args) {Student[] students {new Student(caterpillar, 90),new Student(justin, 85)};// 写入新档writeObjectsToFile(students, data.dat);try {// 读取档案数据Object[] objs readObjectsFromFile(data.dat);for(Object obj : objs) {((Student) obj).showData();}System.out.println();students new Student[2];students[0] new Student(momor, 100);students[1] new Student(becky, 100);// 附加至档案appendObjectsToFile(students, data.dat);// 读取档案数据objs readObjectsFromFile(data.dat);for(Object obj : objs) {((Student) obj).showData();}}catch(FileNotFoundException e) {e.printStackTrace();}}
} 对象被写出时会写入对象的类别型态、类别署名Class signaturestatic与被标志为transient的成员则不会被写入。在这边注意到以附加的形式写入数据至档案时在试图将对象附加至一个先前已写入对象的档案时由于ObjectOutputStream在 写入数据时还会加上一个特别的标示头而读取档案时会检查这个标示头如果一个档案中被多次附加对象那么该档案中会有多个标示头如此读取检查时就会 发现不一致这会丢出StreamCorrupedException为此您重新定义ObjectOutputStream的writeStreamHeader()方法如果是以附加的方式来写入对象就不写入标示头 ObjectOutputStream objOutputStream new ObjectOutputStream(new FileOutputStream(file, true)) {protected void writeStreamHeader()throws IOException {}}; 将对象写出或读入并不仅限于档案存取您也可以用于网络的数据传送例如传送整个对象数据或是影像档案。 14、DataInputStream、DataOutputStream DataInputStream、DataOutputStream可提供一些对Java基本数据型态写入的方法像是读写int、double、 boolean等的方法由于Java的数据型态大小是规定好的在写入或读出这些基本数据型态时就不用担心不同平台间资料大小不同的问题。这边还是举档案存取来进行说明有时候您只是要储存一个对象的成员数据而不是整个对象的信息成员数据的型态假设都是Java的基本数据型态您不必要 使用Object输入、输出相关串流对象而可以使用DataInputStream、DataOutputStream来写入或读出数据下面这个程序 是个简单的示范 Student.java package onlyfun.caterpillar;
public class Student?{private String name;private int score;public Student() {name N/A;}public Student(String name, int score) {this.name name;this.score score;}public void setName(String name) {this.name name;}public void setScore(int score) {this.score score;}public String getName() {return name;}public int getScore() {return score;}public void showData() {System.out.println(name: name);System.out.println(score: score);}
}DataStreamDemo.java package onlyfun.caterpillar;
import java.io.*;
public class DataStreamDemo {public static void main(String[] args) {Student[] students {new Student(Justin, 90),new Student(momor, 95),new Student(Bush, 88)};try {DataOutputStream dataOutputStream new DataOutputStream(new FileOutputStream(data.dat));for(Student student : students) {dataOutputStream.writeUTF(student.getName());dataOutputStream.writeInt(student.getScore());}dataOutputStream.flush();dataOutputStream.close();DataInputStream dataInputStream new DataInputStream(new FileInputStream(data.dat));for(int i 0; i students.length; i) {String name dataInputStream.readUTF();int score dataInputStream.readInt();students[i] new Student(name, score);students[i].showData();}dataInputStream.close();}catch(IOException e) {e.printStackTrace();}}
}这个程序在写入档案时只提取对象的成员数据而在读出时将这些数据读出并将读回的数据设定给一个实例是对象数据还原的一种方式。 15、SequenceInputStream 您将一个档案分割为数个档案接下来要将之再度组合还原为原来的档案最基本的作法是使用数个 FileInputStream来开启分割后的档案然后一个一个档案的读取并连续写入至同一个FileOutputStream中在这中间您必须 要自行判断每一个分割档案的读取是否完毕如果完毕就换读取下一个档案。如果您使用SequenceInputStream就不用这么麻烦SequenceInputStream可以看作是数个 InputStream对象的组合当一个InputStream对象的内容读取完毕后它就会取出下一个InputStream对象直到所有的 InputStream对象都读取完毕为止。下面这个程序是SequenceInputStream的使用示范它可以将指定的档案进行分割也可以将分割后的档案还原为一个档案 SequenceStreamDemo.java package onlyfun.caterpillar;
import java.util.*;
import java.io.*;
public class SequenceStreamDemo {public static void main(String[] args) {try {// args[0]: 指定分割s或连接cswitch (args[0].charAt(1)) {case s:// args[1]: 每个分割档案的大小int size Integer.parseInt(args[1]);// args[2]: 指定要被分割的文件名称seperate(args[2], size);break;case c:// args[1]: 指定要被组合的档案个数int number Integer.parseInt(args[1]);// args[2]: 组合后的文件名称concatenate(args[2], number);break;}}catch(ArrayIndexOutOfBoundsException e) {System.out.println(Using: java UseSequenceStream [-s/-c] (size/number) filename);System.out.println(-s: 分割档案\n-c: 组合档案);}catch(IOException e) {e.printStackTrace();}}// 分割档案public static void seperate(String filename, int size)throws IOException {FileInputStream fileInputStream new FileInputStream(new File(filename));BufferedInputStream bufInputStream new BufferedInputStream(fileInputStream);byte[] data new byte[1];int count 0;?// 从原档案大小及指定分割的大小// 决定要分割为几个档案if(fileInputStream.available() % size 0)count fileInputStream.available() / size;elsecount fileInputStream.available() / size 1;// 开始进行分割for(int i 0; i count; i) {int num 0;// 分割的档案加上底线与编号File file new File(filename _ (i 1));BufferedOutputStream bufOutputStream new BufferedOutputStream(new FileOutputStream(file));while(bufInputStream.read(data) ! -1) {bufOutputStream.write(data);num;if(num size) { // 分割出一个档案bufOutputStream.flush();bufOutputStream.close();break;}}if(num size) {bufOutputStream.flush();bufOutputStream.close();}}System.out.println(分割为 count 个档案);}// 连接档案public static void concatenate(String filename,int number) throws IOException {// 收集档案用的ListList list new ArrayList();for(int i 0; i number; i) {// 文件名必须为底线加上编号File file new File(filename _ (i1));list.add(i, new FileInputStream(file));}final Iterator iterator list.iterator();// SequenceInputStream 需要一个Enumeration对象来建构Enumeration enumation new Enumeration() {public boolean hasMoreElements() {return iterator.hasNext();}public InputStream nextElement() {return iterator.next();}};// 建立SequenceInputStream// 并使用BufferedInputStreamBufferedInputStream bufInputStream new BufferedInputStream(new SequenceInputStream(enumation),8192);BufferedOutputStream bufOutputStream new BufferedOutputStream(new FileOutputStream(filename), 8192);byte[] data new byte[1];// 读取所有档案数据并写入目的地档案while(bufInputStream.read(data) ! -1)bufOutputStream.write(data);bufInputStream.close();bufOutputStream.flush();bufOutputStream.close();System.out.println(组合 number 个档案 OK!!);}
} 分割档案时的范例如下 java onlyfun.caterpillar.SequenceStreamDemo -s 1048576 test.zip
分割为6个档案 组合档案时的范例如下 java onlyfun.caterpillar.SequenceStreamDemo -c 6 test.zip
组合6个档案 OK!!16、PrintStream 之前所介绍过的Stream输出对象都是直接将内存中的数据写出至目的地例如一个档案举个例子来说如果您将 int 整数 1 使用之前介绍的Stream对象输出至档案则档案中所储存的是 int 整数 1 在内存中的值例如 FileStream.java package onlyfun.caterpillar;
import java.io.*;
public class FileStreamDemo {public static void main(String[] args)throws IOException {FileOutputStream file new FileOutputStream(new File(test.txt));file.write(1);file.close();}
}由于您使用write()方法这会将 1 在内存中的值之低字节0000001写入档案中所以如果您使用文字编辑软件像vi或UltraEdit观看test.txt的16进位表示其结果会显示 0116进位表示。 有时候您所想要储存的结果是转换为字符之后的结果例如若程序的执行结果是3.14159您会希望使用字符来储存3.14159也就是俗称的储存为纯文本文件如此当您使用简单的纯文字编辑器观看时就可以直接看到程序执行的结果。 例如您若想使用纯文本文件看到test.txt的显示结果是1则必须先将内存中的整数1也就是二进制00000000 00000000 00000000 00000001转换为对应的字符编码也就是0x31十进制表示49并加以储存。 使用PrintStream可以自动为您进行字符转换的动作它会使用操作系统的预设编码来处理对应的字符转换动作直接使用下面这个例子来作示范 PrintStreamDemo.java package onlyfun.caterpillar;
import java.io.*;
public class PrintStreamDemo {public static void main(String[] args)throws FileNotFoundException {PrintStream printStream new PrintStream(new FileOutputStream(new File(pi.txt)));printStream.print(PI );printStream.println(Math.PI);printStream.close();}
}执行程序之后使用纯文字编辑器开启pi.txt其内容会是PI 3.141592653589793print()或println()接受int、char、String、double等等数据型态 println()会在输出之后加上换行字符而print()则不会。 注意在档案储存上实际并没有二进制档案或是纯文本文件的分别所有的档案所储存的都是二进制的数据您俗称的纯文本文件其实正确的说是指储存的结果是经过字符转换例如将 int 整数 1转换为字符 1 的编码结果并加以储存。 17、Reader、Writer Reader、Writer支持Unicode标准字符集Character set字节串流则只支持ISO-Latin-1 8-bit在处理串流时会根据系统预设的字符编码来进行字符转换它们是抽象类别真正您会使用其子类别子类别通常会重新定义相关的方法。在 PushbackInputStream 中您读入一个含BIG5中文字及ASCII字符的文本文件这边改写一下这个例子使用Reader的子类别 InputStreamReader来转换读入的两个字节为汉字字符并显示在屏幕上 ReaderWriterDemo.java package onlyfun.caterpillar;
import java.io.*;
public class ReaderDemo {public static void main(String[] args) {try {PushbackInputStream pushbackInputStream new PushbackInputStream(new FileInputStream(args[0]));byte[] array new byte[2];ByteArrayInputStream byteArrayStream new ByteArrayInputStream(array);// reader会从已读的位数组中取出数据InputStreamReader reader new InputStreamReader(byteArrayStream);int tmp 0;int count 0;while((count pushbackInputStream.read(array))! -1) {// 两个字节转换为整数tmp (short)((array[0] 8) |(array[1] 0xff));tmp tmp 0xFFFF;// 判断是否为BIG5如果是则显示BIG5中文字if(tmp 0xA440 tmp 0xFFFF) {System.out.println(BIG5: (char)reader.read());// 重置ArrayInputStream的读取光标// 下次reader才会再重头读取数据byteArrayStream.reset();}else {// 将第二个字节推回串流pushbackInputStream.unread(array, 1, 1);// 显示ASCII范围的字符System.out.println(ASCII: (char)array[0]);}}pushbackInputStream.close();}catch(ArrayIndexOutOfBoundsException e) {System.out.println(请指定文件名称);}catch(IOException e) {e.printStackTrace();}}
} 假设的文本文件中有以下的文字这T是e一s个t测试 执行结果会是 BIG5: 这
ASCII: T
BIG5: 是
ASCII: e
BIG5: 一
ASCII: s
BIG5: 个
ASCII: t
BIG5: 测
BIG5: 试
ASCII: !
EOF? InputStreamReader可以用字节串流中取出字节数据并进行字符处理动作关于Reader、Writer相关子类别之后会于各相关主题进行介绍。 其余未看 ByteArrayInputStream、ByteArrayOutputStream CharArrayReader、CharArrayWriter PushbackReader http://www.iteedu.com//plang/java/javadiary/92.php转载于:https://www.cnblogs.com/CheeseZH/archive/2012/12/10/2811913.html
