快捷搜索:

Java语言深入 文件和流

Java I/O系统的类其实是太多了,这里我们只进修一些基础的和常用的,信托能够掌握这些就可以办理我们今后的通俗利用了

1.什么是数据流 ?

数据流是指所有的数据通信通道

有两类流,InputStream and OutputStream,Java中每一种流的基础功能依附于它们

InputStream 用于read,OutputStream 用于write, 读和写都是相对与内存说的,读便是从其他地方把数据拿进内存,写便是把数据从内存推出去

这两个都是抽象类,不能直接应用

2.InputStream 的措施有:

read() 从流中读入数据 有3中要领:

int read() 一次读一个字节

int read(byte[]) 读多个字节到数组中

int read(byte[],int off,int len) 指定从数组的哪里开始,读多长

skip() 跳过流中多少字节

available() 返回流中可用字节数,但基于收集时无效,返回0

markSupported() 判断是否支持标记与复位操作

mark() 在流中标记一个位置,要与markSupported()连用

reset() 返回标记过的位置

close() 关闭流

3.OutputStream 的措施:

write(int) 写一个字节到流中

write(byte[]) 将数组中的内容写到流中

write(byte[],int off,int len) 将数组中从off指定的位置开始len长度的数据写到流中

close() 关闭流

flush() 将缓冲区中的数据强制输出

4.File 类

File 可以表示文件也可以表示目录,File 类节制所有硬盘操作

构造器:

File(File parent,String child) 用父类和文件名构造

File(String pathname) 用绝对路径构造

File(String parent,String child) 用父目录和文件名构造

File(URI uri) 用远程文件构造

常用措施:

boolean createNewFile();

boolean exists();

例子:

//建立 test.txt 文件工具,判断是否存在,不存在就创建

import java.io.*;

public class CreateNewFile{

public static void main(String args[]){

File f=new File("test.txt");

try{

if(!f.exists())

f.createNewFile();

else

System.out.println("exists");

}catch(Exception e){

e.printStackTrace();

}

}

}

boolean mkdir()/mkdirs()

boolean renameTo(File destination)

例子://看一下这 mkdir()/mkdirs() 的差别和 renameTo 的用法

import java.io.*;

public class CreateDir{

public static void main(String args[]){

File f=new File("test.txt");

File f1=new File("Dir");

File f2=new File("Top/Bottom");

File f3=new File("newTest.txt");

try{

f.renameTo(f3);

f1.mkdir();

f2.mkdirs();

}catch(Exception e){

e.printStackTrace();

}

}

}

String getPath()/getAbsolutePath()

String getParent()/getName()

例子://硬盘上并没有parent 目录和 test.txt 文件,但我们仍旧可以操作,由于我们创建了他们的工具,是对工具进行操作

import java.io.*;

public class Test{

public static void main(String args[]){

File f=new File("parent/test.txt");

File f1=new File("newTest.txt");

try{

System.out.println(f.getParent());

System.out.println(f.getName());

System.out.println(f1.getPath());

System.out.println(f1.getAbsolutePath());

}catch(Exception e){

e.printStackTrace();

}

}

}

String list[] //显示目录下所有文件

long lastModified() //返回 1970.1.1 到着末改动光阴的秒数

boolean isDirectory()

例子://列出目录下的所有文件和目录,着末改动光阴,是目录的后面标出,是文件的后面标出文件长度

import java.io.*;

import java.util.*;

public class Dir{

public static void main(String args[]){

File f=new File("Dir");

String[] listAll=null;

File temp=null;

try{

listAll=f.list();

for(int i=0;i);

System.out.print(listAll+"\t");

if(temp.isDirectory())

System.out.print("\t\t");

else

System.out.print(temp.length()+"\t");

System.out.println(new Date(temp.lastModified()));

}

}catch(Exception e){

e.printStackTrace();

}

}

}

5.文件流的建立

File f=new File("temp.txt");

FileInputStream in=new FileInputStream(f);

FileOutputStream out=new FileOutputStream(f);

例子:文件拷贝

import java.io.*;

public class Copy{

public static void main(String args[]){

FileInputStream fis=null;

FileOutputStream fos=null;

try{

fis=new FileInputStream("c2.gif");

fos=new FileOutputStream("c2_copy.gif");

int c;

while((c=fis.read()) != -1)

fos.write(c);

}catch(Exception e){

e.printStackTrace();

}finally{

if(fis != null) try{ fis.close(); }catch(Exception e){ e.printStackTrace(); }

if(fos!= null) try{ fos.close(); }catch(Exception e){ e.printStackTrace(); }

}

}

}

6.缓冲区流

BufferedInputStream

BufferedOutputStream

他们是在通俗文件流上加了缓冲的功能,以是构造他们时要先构造通俗流

例子:文件拷贝的缓冲改进

import java.io.*;

public class Copy{

public static void main(String args[]){

BufferedInputStream bis=null;

BufferedOutputStream bos=null;

byte buf[]=new byte[100];

try{

bis=new BufferedInputStream(new FileInputStream("persia.mp3"));

bos=new BufferedOutputStream(new FileOutputStream("persia_copy.mp3"));

int len=0;

while( true ){

len=bis.read(buf);

if(len7.原始型数据流

DataInputStream

DataOutputStream

他们是在通俗流上加了读写原始型数据的功能,以是构造他们时要先构造通俗流

措施:

readBoolean()/writeBoolean()

readByte()/writeByte()

readChar()/writeByte()

......

例子://这个流对照简单,要留意的便是读时的顺序要和写时的一样

import java.io.*;

public class DataOut{

public static void main(String args[]){

DataOutputStream dos=null;

try{

dos=new DataOutputStream(new FileOutputStream("dataout.txt"));

dos.writeInt(1);

dos.writeBoolean(true);

dos.writeLong(100L);

dos.writeChar('a');

}catch(Exception e){

e.printStackTrace();

}finally{

if(dos!=null)

try{

dos.close();

}catch(Exception e){

}

}

}

}

import java.io.*;

public class DataIn{

public static void main(String args[]){

DataInputStream dis=null;

try{

dis=new DataInputStream(new FileInputStream("dataout.txt"));

System.out.println(dis.readInt());

System.out.println(dis.readBoolean());

System.out.println(dis.readLong());

System.out.println(dis.readChar());

}catch(Exception e){

e.printStackTrace();

}finally{

if(dis!=null)

try{

dis.close();

}catch(Exception e){

}

}

}

}

8.工具流

串行化:工具经由过程写出描述自己状态的数值来记述自己的历程叫串行话

工具流:能够输入输出工具的流

将串行化的工具经由过程工具流写入文件或传送到其他地方

工具流是在通俗流上加了传输工具的功能,以是构造工具流时要先构造通俗文件流

留意:只有实现了Serializable接口的类才能被串行化

例子:

import java.io.*;

class Student implements Serializable{

private String name;

private int age;

public Student(String name,int age){

this.name=name;

this.age=age;

}

public void greeting(){

System.out.println("hello ,my name is "+name);

}

public String toString(){

return "Student["+name+","+age+"]";

}

}

public class ObjectOutTest{

public static void main(String args[]){

ObjectOutputStream oos=null;

try{

oos=new ObjectOutputStream(

new FileOutputStream("student.txt"));

Student s1=new Student("Jerry",24);

Student s2=new Student("Andy",33);

oos.writeObject(s1);

oos.writeObject(s2);

}catch(Exception e){

e.printStackTrace();

}finally{

if(oos!=null)

try{

oos.close();

}catch(Exception e){

e.printStackTrace();

}

}

}

}

import java.io.*;

public class ObjectInTest{

public static void main(String args[]){

ObjectInputStream ois=null;

Student s=null;

try{

ois=new ObjectInputStream(

new FileInputStream("student.txt"));

System.out.println("--------------------");

s=(Student)ois.readObject();

System.out.println(s);

s.greeting();

System.out.println("--------------------");

s=(Student)ois.readObject();

System.out.println(s);

s.greeting();

}catch(Exception e){

e.printStackTrace();

}finally{

if(ois!=null)

try{

ois.close();

}catch(Exception e){

e.printStackTrace();

}

}

}

}

9.字符流 InputStreamReader/OutputStreamWriter

上面的几种流的单位是 byte,以是叫做字撙节,写入文件的都是二进制字节,我们无法直接看,下面要进修的是字撙节

Java采纳 Unicode 字符集,每个字符和汉字都采纳2个字节进行编码,ASCII 码是 Unicode 编码的自集

InputStreamReader 是 字撙节 到 字符桥的桥梁 ( byte->char 读取字节然后用特定字符集编码成字符)

OutputStreamWriter是 字符流 到 字撙节的桥梁 ( char->byte )

他们是在字撙节的根基上加了桥梁感化,以是构造他们时要先构造通俗文件流

我们常用的是:

BufferedReader 措施:readLine()

PrintWriter 措施:println()

例子:

import java.io.*;

public class PrintWriterTest{

public static void main(String args[]){

PrintWriter pw=null;

try{

pw=new PrintWriter(

new OutputStreamWriter(

new FileOutputStream("bufferedwriter.txt")));

pw.println("hello world");

}catch(Exception e){

e.printStackTrace();

}finally{

if(pw!=null)

try{

pw.close();

}catch(Exception e){

e.printStackTrace();

}

}

}

}

import java.io.*;

public class BufferedReaderTest{

public static void main(String args[]){

BufferedReader br=null;

try{

br=new BufferedReader(

new InputStreamReader(

new FileInputStream("bufferedwriter.txt")));

System.out.println(br.readLine());

}catch(Exception e){

e.printStackTrace();

}finally{

if(br!=null)

try{

br.close();

}catch(Exception e){

e.printStackTrace();

}

}

}

}

10.随机存取文件 RandomAccessFile

可同时完成读写操作

支持随机文件操作的措施:

readXXX()/writeXXX()

seek() 将指针调到所需位置

getFilePointer() 返回指针当前位置

length() 返回文件长度

例子:把多少个32位的整数写到一个名为 “temp.txt”的文件中,然后使用seek措施,以相反的顺序再读取这些数据

import java.io.*;

public class RandomFile{

public static void main(String args[]){

RandomAccessFile raf=null;

int data[]={12,31,56,23,27,1,43,65,4,99};

try{

raf=new RandomAccessFile("temp.txt","rw");

for(int i=0;i);

for(int i=data.length-1;i>=0;i--){

raf.seek(i*4);

System.out.println(raf.readInt());

}

}catch(Exception e){

e.getMessage();

}finally{

if(raf!=null)

try{

raf.close();

}catch(Exception e){

e.getMessage();

}

}

}

}

11.小结

这部分的难点便是类对照繁杂,尤其是每个类的构造要领,我觉得记着下面这个图比记类的承袭关系更好些

a. 字撙节:

InputStream

|-- FileInputStream (基础文件流)

|-- BufferedInputStream

|-- DataInputStream

|-- ObjectInputStream

OutputStream 同上图

BufferedInputStream DataInputStream ObjectInputStream 只是在 FileInputStream 上增加了响应的功能,构造时先构造FileInputStream

b. 字符流:

Reader

|-- InputStreamReader (byte->char 桥梁)

|-- BufferedReader (常用)

Writer

|-- OutputStreamWriter (char->byte 桥梁)

|-- BufferedWriter

|-- PrintWriter (常用)

c. 随机存取文件 RandomAccessFile

您可能还会对下面的文章感兴趣: