码迷,mamicode.com
首页 > 编程语言 > 详细

JavaI/O系统

时间:2015-04-22 22:04:01      阅读:141      评论:0      收藏:0      [点我收藏+]

标签:

I/O:(输入/输出)指的是计算机与外部世界,或者一个与计算机其余部分的接口。它对任何计算机系统都非常关键。

Java类库中有大量的类,帮助我们从不同的设备读取数据并保存或输出到不同的设备中。

这些类统一放在java.io包java.nio包中,统称JavaI/O系统。(I:Input输入;O:Output输出)

 

流(Stream):

流是java I/O的基础,java语言对I/O的一个最基本的抽象

基本特性:含有流质,有方向(流质是数据,方向就是读或写)。

对流的读或写就是针对设备进行信息的输入输出。

流按方向分:

输入流:(继承自InputStream或Reader);

输出流:(继承自OutputStream或Writer);

处理数据的最小单位分:

字节流:以byte为最小单位进行数据传送(继承自InputStreamOutputStream);

字符流:以char为最小单位进行数据传送(继承自ReaderWriter);

按功能分:

节点流:(低级流)节点流是可以直接从/向一个特定的数据源(磁盘文件、内存、网络等)读/写数据的流。

处理流:(高级流)不直接连接到设备,而是连接在已存在的流(节点流或处理流之上)通过对数据的处理为程序提供更强大的读写功能

 

InputStream类层次

 

 

 

技术分享

 

 

OutputStream类层次

技术分享

Reader类层次

技术分享

 

Writer类层次

技术分享

 

 

技术分享

技术分享

技术分享

1.创建File类对象:
File f;
f = new File("Test.java");
f = new File("E:\\ex\\","Test.java");

2.将目录也当作文件处理File类中提供了实现目录管理功能的方法:
File path = new File("E:\\ex\\");
File f = new File(path, "Test.java");

方法:
f.getName():返回文件名 temp.dat
f.getParent():返回文件所在目录名 data
f.getPath():返回文件路径 data\temp.dat
f.getAbsolutePath():返回绝对路径 …\data\temp.dat
f.exists():文件是否存在
f.canWrite(), f.canRead():文件是否可写、读
f.isFile(), f.isDirectory():是否为文件或目录
f.lastModified(), f.length(), f.delete():文件的最后修改日期、长度;删除文件
f.mkdir(), f.list():创建一个目录;列出目录下所有的文件

 

一些方法使用:

package com.lovo;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类测试
 *
 */
public class FileTest {

    public static void main(String[] args) {
        // 创建File对象
        File file = new File("E:\\jg\\exercise_bak.txt");

        // 能否读
        System.out.println("能否读:" + file.canRead());

        // 删除
        System.out.println("删除成功:" + file.delete());

        // 重新创建文件对象
        file = new File("E:\\jg\\exercise_bak.txt");

        // 判断文件是否存在
        System.out.println("是否存在:" + file.exists());

        // 目录或文件名称
        System.out.println("名称:" + file.getName());

        // 是否目录、文件
        System.out.println("是否目录:" + file.isDirectory());
        System.out.println("是否文件:" + file.isFile());

        // 最后一次修改时间
        System.out.println("最后一次修改时间:"
                + new Date(file.lastModified()));

        // 文件大小
        System.out.println("文件大小:" + file.length());

        // 重新创建File对象
        file = new File("E:\\jg");

        System.out.println("文件目录列表:");
        // 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录
        String[] list = file.list();
        for (String string : list) {
            System.out.println(string);
        }
        System.out.println("*******************************");

        // 返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件对象
        File[] files = file.listFiles();
        for (File item : files) {
            if (item.isDirectory()) { // 当前File对象为目录,则遍历该目录下所有子目录与文件
                System.out.println(item.getName() + " 目录下子目录与文件:");
                String[] it = item.list();
                for (String i : it) {
                    System.out.println(i);
                }
                System.out.println("*******************************");
                continue;
            }

            System.out.println(item.getName() + "  文件");
        }

        // 重新创建File对象
        file = new File("E:\\jg\\test\\demo\\test.txt");
        if (!file.exists()) { // 文件不存在
            // 获取文件路径
            File dir = file.getParentFile();
            if (!dir.exists()) { // 目录不存在,则创建路径中所有不存在的目录
                dir.mkdirs();
            }

            try {
                // 创建空文件
                System.out.println("文件是否创建成功:" + file.createNewFile());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.lovo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 字节输入输出流测试
 *
 */
public class IOTest {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer(); // 字符串缓冲
        
        /* 输入流 */
        InputStream in = null;

        try {
            // 1. 打开输入流
            in = new FileInputStream("E:\\jg\\exercise.txt");
            // 2. 读取
//            byte[] b = new byte[128];
            byte[] b = new byte[1024 * 4];
            int len = in.read(b); // 返回读取到的字节数,返回-1表示读取到流结尾
            while(len != -1){
                buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲
                len = in.read(b);
            }
//            System.out.println("读到" + len + "字节的数据");
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源,关闭输入流
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        /* 输出流 */
        OutputStream out = null;
        
        try {
            File file = new File("D:\\test\\demo\\test.txt");
            if (!file.getParentFile().exists()){ // 文件路径不存在,则创建路径中所有不存在的目录
                file.getParentFile().mkdirs();
            }
            // 1. 打开输出流
            out = new FileOutputStream(file);
            // 2. 写
            out.write(buffer.toString().getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放输出流资源
            if (out != null){
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.lovo;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符输入输出流测试
 *
 */
public class IOTest2 {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();

        /* 输入流 */
        Reader reader = null;

        try {
            // 1. 打开流
            reader = new FileReader("E:\\jg\\exercise.txt");
            // 2. 读取
            char[] ch = new char[128]; // 缓冲区
            int len;
            do {
                len = reader.read(ch);
                if (len == -1)
                    break;
                buffer.append(new String(ch, 0, len));
            } while (len != -1);
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /* 输出流 */

        Writer writer = null;

        try {
            // 1. 打开流
            writer = new FileWriter("d:\\test.txt");
            // 2. 写入
            writer.write(buffer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (writer != null) {
                try {
                    writer.flush();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ex:

import java.io.*;
public class FileTest{
    public static void main(String[] str){
        File f = new File("E:\\Workspace\\aaa.txt");
        //判断是否存在该文件
        if (!f.exists()){
            System.out.println("file is not exist");
            try {
                f.createNewFile();//不存在就创建新的文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        File f1 = new File("E:\\Workspace\\aaa1\\sdfsdf\\asdf");
        if (f1.mkdir()){ //创建目录
            System.out.println("yes");
        }
        else{
            System.out.println("errors ");
        }
    }
}

ex2:

 

import java.io.*;

//浏览当前目录下的所有文件和目录
class FileDirectory{
     public static void main( String[] args ) {
          try {
             File f1 = new File("");
             String ss = f1.getAbsolutePath();
             System.out.println("ss= " + ss);
             File f = new File(ss);

             if( f.isDirectory() ) {
                //获取目录下所有的文件列表
                File[] files = f.listFiles();
                for( int i=0; i<files.length; i++ ) {
                   if( files[ i ].isDirectory() ) {
                      System.out.println( "<dir> " + files[ i ].getName() );
                   }
                   else {
                      System.out.println( files[ i ].getName() );
                   }
                }
             }
          }
          catch( Exception e ) {
             e.printStackTrace();
          }       
      }    
}

 

ex3:

 

 

import java.io.*;

class SuperTest{
    public static void main(String args[]) {
        File dir = new File("E:\\Workspace\\Java\\test20111108"); // 用File 对象表示一个目录
        Filter filter = new Filter("txt"); // 生成一个名为java的过滤器
        System.out.println("list java files in directory " + dir);
        
        String[] files = dir.list(filter); // 列出目录dir下,文件后缀名为txt的所有文件
                            
        for (int i = 0; i < files.length; i++) {
            File f = new File(dir, files[i]); // 为目录dir 下的文件或目录创建一个File 对象
            if (f.isFile()) // 如果该对象为后缀为java的文件,则打印文件名
                System.out.println("file: " + f);
            else
                System.out.println("sub directory " + f); // 如果是目录则打印目录名
        }        
    }
}

class Filter implements FilenameFilter {
    String extent;
    Filter(String extent) {
        this.extent = extent;
    }
    
    public boolean accept(File dir, String name) {        
        return name.endsWith("." + extent); //返回文件的后缀名
    }
}

ex4:

 

 

import java.io.*;

/**
*把一个文件的所有内容写到另外一个文件中
*/
class FileStreamTest{
    public static void main(String args[]) {
        try {
            File inFile=new File("test1.txt");
            File outFile=new File("test2.txt");
            FileInputStream fis=new FileInputStream(inFile);
            FileOutputStream fos=new  FileOutputStream(outFile);
            
            int c;
            while((c=fis.read())!=-1) //读取一个字节
            {
                    fos.write(c);
            }
            
            fis.close();
            fos.close();
        }catch(FileNotFoundException e) {
              System.out.println("FileStreamsTest: "+e);
        }catch(IOException e) {
           System.err.println("FileStreamsTest: "+e);
        }
    }
}

 

 

 

import java.io.*;

class CopyFileTest{
    public static void main(String args[]) {
        CopyFileTest cf = new CopyFileTest ();
        cf.copyFile("test1.txt","test3.txt");
    }
    
    public boolean copyFile(String src,String des){    
        File srcFile,desFile;
        srcFile = new File(src);
        desFile = new File(des);
        FileInputStream fis = null;
        FileOutputStream fos = null;
    
        try{
              desFile.createNewFile();
              fis = new FileInputStream(srcFile);
              fos = new FileOutputStream(desFile);//覆盖
            //  fos = new FileOutputStream(desFile,true);//追加

              int bytesRead;
              byte[] buf = new byte[4 * 1024];  // 4K buffer
              while((bytesRead=fis.read(buf))!=-1){
                fos.write(buf,0,bytesRead);
              }
              fos.flush();
              fos.close();
              fis.close();
        }catch(IOException e){
          System.out.println(e);
          return false;
        }
          return true;    
    } 
}

 

如果只是在尾部追加,而不是覆盖需要调用FileOutputStream(“file”,true)就Ok了,对于字符流文件就是FileWriter(“file”,true)就OK乐。

 

 

 

父类过滤流:
FilterInputStream(InputStream in);
FilterOutputStream(OutputStream out);

 

 

 

过滤流—缓冲流

 

类BufferedInputStream和BufferedOutputStream继承FilterInputStream和FilterOutputStream,实现了带缓冲的过滤流,它提供了缓冲机制,把任意的I/O流“捆绑”到缓冲流上,可以提高该I/O流的读取效率,在初始化时,除了要指定所连接的I/O流之外,还可以指定缓冲区的大小。
在读写的同时对数据缓存,这样避免每次读写数据都要进行实际的物理读写操作,在用BufferdOutputStream输出时,数据先输入缓冲区,当缓冲区满的时再写入连接的输出流,可以调用flush()来清空缓冲区。

 

 
import java.io.*;

class SuperTest{
    public static void main(String args[]) {
        try {
            File inFile = new File("test1.txt");
            File outFile = new File("test4.txt");
            
            BufferedInputStream bufFis=new BufferedInputStream(new FileInputStream(inFile),256);            
            BufferedOutputStream bufFos=new BufferedOutputStream(new FileOutputStream(outFile),256);            
            
            int len;
            byte bArray[]=new byte[256];
            
            do{
                System.out.println("while");
                len = bufFis.read(bArray);
                bufFos.write(bArray,0,len);
                System.out.println("len: " +len);
            }while (len==256);    
                        
            bufFis.close();
            bufFos.close();
        } catch (FileNotFoundException e) {
            System.out.println("FileStreamsTest: " + e);
        } catch (IOException e) {
            System.err.println("FileStreamsTest: " + e);
        }
    }
}

 

 

 

过滤流—数据流

 

DataInputStream和DataOutputStream, 继承FilterInputStream和FilterOutputStream,可以用来与计算机无关的格式读写JAVA的基本数据类型以及String对象。
readBoolean() 读一字节,非零为真
readByte() 以8位读字节
readChar() 读Unicode字符
readInt() 读整数值
writeChar(int v) 把字符写进输出流
writeLong(long v) 把长整写进输出流
writeInt(int v) 把整数写进输出流

 


数据输出流可以是一个已经建立好的输入数据流对象,例如网络的连结,文件等。数据流可通过如下方式建立。
FileInputStream fis = new FileInputStream("file1.txt");
FileOutputStream fos = new FileOutputStream("file2.txt");
DataInputStream dis = new DataInputStream(fis);
DataOutputStream dos = new DataOutputStream(fos);

 

 
import java.io.*;

class DataStreamIOTest{
    public static void main(String args[]) throws IOException 
    {
        FileOutputStream fos = new FileOutputStream("a.txt");
        DataOutputStream dos = new DataOutputStream(fos);
        try {
            dos.writeBoolean(true);
            dos.writeByte((byte) 123);
            dos.writeChar(‘J‘);
            dos.writeDouble(3.141592654);
            dos.writeFloat(2.7182f);
            dos.writeInt(1234567890);
            dos.writeLong(998877665544332211L);
            dos.writeShort((short) 11223);
        } finally {
            dos.close();
        }
        
        FileInputStream fis = new FileInputStream("a.txt");
        DataInputStream dis = new DataInputStream(fis);
        try {
            System.out.println("\t " + dis.readBoolean());
            System.out.println("\t " + dis.readByte());
            System.out.println("\t " + dis.readChar());
            System.out.println("\t " + dis.readDouble());
            System.out.println("\t " + dis.readFloat());
            System.out.println("\t " + dis.readInt());
            System.out.println("\t " + dis.readLong());
            System.out.println("\t " + dis.readShort());
        } finally {
            dis.close();
        }
    }
}//需要注意的是必须throws IOException才可以编译通过。

 

 

 

字符流

 

 
例子:利用FileWriter来写文件
    try
        {
            FileWriter fw = new FileWriter("mydata.txt");             
            PrintWriter out = new PrintWriter(fw); 
            out.print("面朝大海,");
            out.println("春暖花开!");
            out.println("环境美好!!");
            out.close();
            fw.close();
        }catch(IOException e)
        {
            e.printStackTrace();
        }

 

例子:字符缓冲流BufferedReader
import java.io.*;
class SuperTest{
    public static void main(String args[]) throws IOException
    {
        File file = new File("mydata.txt");
        
        try {
            BufferedReader in = new BufferedReader(new FileReader(file));
            String s;
            s = in.readLine();
            while ( s != null ) {
                System.out.println("Read: " + s);
                s = in.readLine();
            }
            in.close();
        } catch (FileNotFoundException e1) {
            System.err.println("File not found: " + file);
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }
}

 

 
例子:拷贝(FileReader和FileWriter)
            try {
                    FileReader input = new FileReader(args[0]);
                    FileWriter output = new FileWriter(args[1]);
                    
                    char[] buffer = new char[128];
                    int charsRead;
                    charsRead = input.read(buffer);
                    
                    while ( charsRead != -1 ) 
                    {
                        output.write(buffer, 0, charsRead);
                        charsRead = input.read(buffer);
                    }
                    
                    input.close();
                    output.close();
                } catch (IOException e) 
                {
                    e.printStackTrace();            
                }
            }
 

 

例子:拷贝(BufferedWriter)
try {
        FileReader input = new FileReader(args[0]);
        BufferedReader bufInput = new BufferedReader(input);
        FileWriter output = new FileWriter(args[1]);
        BufferedWriter bufOutput = new BufferedWriter(output);
        String line;
        
        line = bufInput.readLine();
        while ( line != null ) 
        {
            bufOutput.write(line, 0, line.length());
            bufOutput.newLine();
            line = bufInput.readLine();
        }
        
        bufInput.close();
        bufOutput.close();
    } 
    catch (IOException e) 
    {
        e.printStackTrace();
    }

 

 

 

随机存取文件流--RandomAccessFile
1 RandomAccessFile是一种特殊的文件流,可以用它在文件的任何地方查找或者插入数据
2 RandomAccessFile同时实现了DataInput和DataOutput接口,所以可以用它来读/写文件
3构造器:
RandomAccessFile(java.io.File f,String mode)
RandomAccessFile(String file,String mode)
4 mode可以为”r”或”rw”

 

方法:
1 readXXX()或writeXXX():
如ReadInt(), ReadLine(), WriteChar(), WriteDouble()等
2 int skipBytes(int n):将指针向下移动若干字节
3 length():返回文件长度
4 long getFilePointer():返回指针当前位置
5 void seek(long pos):将指针调到所需位置

 

 

import java.io.*;
import java.util.*;

class RandomAccessFileTest{
    public static void main(String args[])
    {
        try{
              File logfile=new File("mydata.txt");
              
              if(logfile.exists())
              {
    RandomAccessFile raf=new RandomAccessFile(logfile,"rw");
                  System.out.println("leghth = " + raf.length());
                  raf.seek(raf.length());
                  
                  for(int i=0;i<5;i++)
                  {
                      raf.writeBytes("Write "+new Date()+ "\r\n");
                  }
                    
                  raf.seek(0);
                  String x=raf.readLine();
                  
                  while(x!=null)
                  {
                    System.out.println(x);
                    x=raf.readLine();
                  }
                  
                  raf.close();
              }
           }catch(IOException e){
              e.printStackTrace();
            }
    }
}

 

JavaI/O系统

标签:

原文地址:http://www.cnblogs.com/Spirit612/p/4448783.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!