05 Java中的输入、输出流

输入输出流

内容概括：

存在java.io包中

所有输入流都是抽象类InputStream（字节输入流）和抽象类Reader（字符输入流）的子类。

所有输出流都是抽象类OutputStream（字节输出流）和抽象类Writer（字符输出流）的子类。

File类

不涉及对文件的读写操作，只获取文件信息，如文件所在目录、文件长度、文件读写权限等。

创建一个File对象的构造方法有：

• File(String filename);
• File(String directoryPath, String filename);
• File(File dir , String filename); //dir是一个目录

几个常用方法：

文件属性

• public String getName() //获取文件名
• public boolean canRead() //是否可读
• public boolean exists() //是否存在
• public String getAbsolutePath() //获取文件绝对路径
• public String getParent() //获得父目录
• public boolean isFile() //判断是否是文件

Txt.java

package com.InOut;

import java.io.*;

public class Txt {
    public static void main(String[] args) {
        File f = new File(\"E:\\\\\", \"hello.txt\");  //文件需事先创建
        System.out.println(f.getName() + \"是可读的吗：\" + f.canRead());
        System.out.println(f.getName() + \"的长度：\" + f.length());
        System.out.println(f.getName() + \"的绝对路径：\" + f.getAbsolutePath());

        File file = new File(\"new.txt\");
        System.out.println(\"在当前目录下创建新文件\" + file.getName());
        if (!file.exists()) {
            try {
                file.createNewFile();
                System.out.println(\"创建成功\");
            } catch (IOException exp) {
            }
        }
    }
}

hello.txt是可读的吗：true
hello.txt的长度：24
hello.txt的绝对路径：E:\\hello.txt
在当前目录下创建新文件new.txt

创建目录

• public boolean mkdir();

列出目录中的文件

• public String[] list(); //

• public File [] listFiles(); //

• public String[] list(FilenameFilter obj) //以字符串形式返回目录下指定类型的所有文件

• public File [] listFiles(FilenameFilter obj) //用File对象形式返回

  FilenameFilter是一个接口，该接口有一个方法：

  public boolean accept(File dir,String name);

Directory.java

package com.InOut;
import java.io.*;

class FileAccept implements FilenameFilter{
    private String extendName;
    public void setExtendName(String s){
        extendName = \".\"+s;
    }
    public boolean accept(File dir,String name){ //重写接口中的方法
        return name.endsWith(extendName);
    }
        }

public class Directory {
    public static void main(String[] args) {
        File dirFile = new File(\".\");  //参数点号表示当前目录
        FileAccept fileAccept = new FileAccept();
        fileAccept.setExtendName(\"txt\");
        String fileName[] = dirFile.list(fileAccept);//以字符串形式返回,参数为接口回调
        for(String name:fileName){
            System.out.println(name);
        }
    }
}

new.txt

文件的创建与删除

先创建对象：File file = new File(\"E:\\\",mary.txt);

如果没有名为mary.txt的文件，调用public bolean createNewFile();创建

file.delete();删除文件

运行可执行文件

可以用Runtime类，此时将使用静态方法创建对象：

Runtime ec = Runtime.getRuntime();

Exe.java

package com.InOut;
import java.io.*;

//打开记事本和Typora
public class Exe {
    public static void main(String[] args) {
        try {
            Runtime ce = Runtime.getRuntime();
            File file = new File(\"c:/windows\", \"Notepad.exe\");
            ce.exec(file.getAbsolutePath());
            file = new File(\"E:\\\\User\\\\Soft\\\\Typora\\\\Typora.exe\");
            ce.exec(file.getAbsolutePath());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

文件字节输入流

四个基本步骤：

1. 设定输入流的源
2. 创建指向源的输入流
3. 让输入流读取源中的数据
4. 关闭输入流

如果需求简单，可使用InputStream的子类FileInputStream。

构造方法

FileInputStream(String name);

FileInputStream(File file);

参数name和file指定的文件就称为输入流的源。通常要配合try catch使用

关闭流

close();

InStream.java

package com.InOut;
import java.io.*;

//使用文件字节流读文件的内容
public class InStream {
    public static void main(String[] args) {
        int n=-1;
        byte [] a =new byte[100];
        try{
            File f = new File(\"hello.txt\");
            System.out.println(\"is file exists:\"+f.exists());
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1){
                String s = new String(a,0,n);
                System.out.println(s);
            }
            in.close();
        }
        catch(IOException e){
            System.out.println(\"File read error\"+e);
        }
    }
}

is file exists:true
Hello, this is my world.
你好，这是我的世界。

文件字节输出流

同文件字节输入流类似

文件字符输入、输出流

上面的文件字节输入流、输出流的read write方法不能很好操作Unicode字符，例如汉字可能会出现乱码现象。

FileReader 和 FileWriter分别是Reader 和 Writer的子类。

CharInOut.java

package com.InOut;
import java.io.*;

public class CharInOut {
    public static void main(String[] args) {
        File sourceFile = new File(\"hello.txt\");
        File targetFile = new File(\"hello_1.txt\"); //不必事先创建
        char c[] = new char[19];
        try{
            Writer out = new FileWriter(targetFile,true);
            Reader in = new FileReader(sourceFile);
            int n = -1;
            while((n=in.read(c))!=-1){
                out.write(c,0,n);
            }
            out.flush();
            out.close();
        }
        catch(IOException e){
            System.out.println(\"Error\"+e);
        }
    }
}

缓冲流

如果把文件字符输入流作为BufferedReader流的源，把文件字符输出流作为BufferedWriter流的目的地，则将具有更强的读写能力，例如按行读取等。

核心语句：String strLine = inTwo.readLine();

//inTwo是一个BufferedReader对象，但是参数里是文件输入流的源。

随机流

RandomAccessFile类，既不是InputStream，也不是OutStream的子类。

由RandomAccessFile类创建的流称为随机流，既可作为流的源，也可作为流的目的地。

构造方法

RandomAccessFile(String name, String mod)

RandomAccessFile(File file, String mod) //参数mod为 r 或 rw

方法

seek(long a) 参数a确定读写位置距离文件开头的字节个数

getFilePointer（） 获取流的当前读写位置

read Char( )

writeFloat( )

数组流

• 字节数组流
• 字符数组流

数据流

对象流

其他功能

进度条

ProgressMonitorInputStream(Component c, String s, InputStream);  //import java.swing.**

文件锁

FileChannel channel = input.getChannel();  //获得信道
FileLock lock = channel.tryLock();   //加锁
lock.release();	 //解锁

来源：https://www.cnblogs.com/allisonHunter/p/16315444.html
本站部分图文来源于网络，如有侵权请联系删除。