Java—输入输出技术

在Java中，通过java.io包提供的类来表示流，基本的输入输出流为InputStream和OutputStream。从这两个基本的输入输出流派生出面向特定处理的流，如缓冲区读写流、文件读写流等。

1  InputStream类

InputStream是抽象类，代表字节输入流的所有类的超类。这个类本身不能使用，只能通过继承它的具体类完成某些操作。它的常用方法如下：

public int available() throws IOException                             返回流中可用的字节数。

public void close() throws IOException                               关闭流并释放与流相关的系统资源。用户使用完输入流时，调用这个方法。

public void mark(int readlimit) throws IOException               输入流中标志当前位置。

public boolean markSupported() throws IOException          测试流是否支持标志和复位。

public abstract int read() throws IOException                     读取输入流中的下一个字节。

public int read(byte[] b) throws IOException                      从输入流中读取字节并存储到缓冲区数组b中，返回读取的字节数，遇到文件结尾返回-1。

public int read(byte[] b, int off, int len) throws IOException 从输入流中读取len个字节并写入b中，位置从off开始。返回写的字节数。

public void reset() throws IOException                               重定位到上次输入流中调用的位置。

public long skip(long n) throws IOException                        跳过输入流中n个字节，返回跳过的字节数，遇到文件结尾返回-1。

2  OutputStream类

OutputSteam是抽象类，代表输出字节流的所有类的超类。

public void close() throws IOException                                         关闭输出流，释放与流相关的系统资源。

public void flush() throws IOException                                         清洗输出流，使得所有缓冲区的输出字节全部写到输出设备中。

public void write(byte[] b) throws IOException                             从特定字节数组b将b数组长度个字节写入输出流。

public void write(byte[] b, int off, int len) throws IOException        从特定字节数组b将从off开始的len个字节写入输出流。

public abstract void write(int b) throws IOException                      向输出流写一个特定字节。

3  系统输入输出对象

Java定义了两个流对象System.in和System.out，允许用户在自己的程序中直接使用。System.in对象允许用户从键盘读取数据，System.out对象可以产生屏幕输出。

例：使用流对象System.in和System.out，接收用户从键盘上输入的数据并将数据输出到屏幕上。

 1 package inputOutput;
 2 import java.io.*;
 3 
 4 public class SystemIO {
 5     public static void main(String[] args)
 6     {
 7         int bytes = 0;
 8         byte buf[] = new byte[255];
 9         System.out.println("
请输入任意文本：");
10         try
11         {
12                       //接收输入字符串
13             bytes = System.in.read(buf,0,255);
14         
15             System.out.println("这是你输入的文本行：");
16             String inStr = new String(buf,0,bytes);
17             //输出字符串
18             System.out.println(inStr);
19         }
20         catch(IOException e)
21         {
22             System.out.println(e.getMessage());
23         }
24     }
25 }
View Code

4  FileInputStream类

FileInputStream(文件输入流)类是用来得到文件的输入字节流。大部分方法继承于InputStream类。它的构造方法如下：

FileInputStream(File file)                                                           通过打开一个到实际文件的链接，创建一个文件输入流，参数file是一个文件对象。

FileInputStream(String name)                                                   通过打开一个到实际文件的链接，创建文件输入流，参数name为文件的实际路径。

例：使用FileInputStream对象打开源程序文件

 1 package inputOutput;
 2 
 3 import java.io.*;
 4 public class UseFileInputStream 
 5 {
 6     public static void main(String[] args)
 7     {
 8         byte buf[] = new byte[2056];
 9         try
10         {
11                       //构造文件输入流
12             FileInputStream fileIn = new FileInputStream("UseFileInputStream.java");
13             //存入缓冲buf
14             int bytes = fileIn.read(buf,0,2056);
15             String inStr = new String(buf,0,bytes);
16             //输出文件内容
17             System.out.println(inStr);
18         }
19         catch(IOException e){
20             System.out.println(e.getMessage());
21         }
22    }
23 };
View Code

注：此时需要用System.getProperty("user.dir");打印出来看看是在哪个文件夹。需将UseFileInputStream放到此文件夹下。

5  FileOutputStream类

FileOutputStream(文件输出流)类是将数据写入File或 FileDescriptor对象的输出流。它的方法大都是从OutStream继承来的，其构造方法如下：

FileOutputStream(File file)                                                         创建输出流写到特定的file对象。

FileOutputStream(File file, boolean append)                                以追加的方式写入file对象。

FileOutputStream(FileDescriptor fdObj)                                      创建输出文件流到fdObj对象，代表一个到实际文件的链接。

FileOutputStream(String name)                                                创建输出流，写到指定的name文件。

FileOutputStream(String name, boolean append)                        是否以追加的方式写到指定的name文件。

例：使用FileOutputStream对象，打开一个文件，写入一行文本，然后追加一行从键盘接收的字符串

 1 package inputOutput;
 2 import java.io.*;
 3 
 4 public class UseFileOutputStream {
 5 
 6     public static void main(String[] args) {
 7         // TODO 自动生成的方法存根
 8         byte buf[] = new byte[255];
 9         byte bufIn[] = new byte[255];
10         try
11         {
12             String str = "你好，这是已有的文本";
13             buf = str.getBytes();
14             //创建文件输出流对象
15             FileOutputStream fileOut = new FileOutputStream("Hello.txt");
16             //写入文件
17             fileOut.write(buf,0,buf.length);
18             //fileOut.flush();
19             //fileOut.close();
20             System.out.println("
请输入一行文本：");
21             //从键盘接收文本
22             int bytes = System.in.read(bufIn,0,255);
23             //追加文本
24             //fileOut = new FileOutputStream("Hello.txt",true);
25             fileOut.write(bufIn,0,bytes);
26             fileOut.flush();
27             fileOut.close();
28         }
29         catch(IOException e)
30         {
31             System.out.println(e.getMessage());
32          }
33       }
34 }
View Code

6  File类

        用户接口和操作系统使用依赖于系统的路径字符串来命名文件和目录。File类就表示这些文件和目录路径，它代表一个抽象的依赖于系统的层次路径视图。File类允许用户向系统查询该文件的所有信息，也可以使用类来创建新的目录或者删除和重命名文件。当用户需要获得有关文件的信息时，就需要创建一个File类，而当File类用于文件读写时，通常与FileInputStream流相结合。

 1 package inputOutput;
 2 
 3 import java.io.*;
 4 
 5 public class UseFile {
 6 
 7     public static void main(String[] args) {
 8         // TODO 自动生成的方法存根
 9         try
10         {
11             File f = new File("temp.txt");
12             System.out.println("创建临时文件");
13             FileOutputStream fout = new FileOutputStream(f);
14             PrintStream p = new PrintStream(fout);
15             p.println("将这句话放入临时文件");
16             System.out.println("写临时文件");
17             f.deleteOnExit();
18             System.out.println("删除临时文件");
19         }
20         catch(IOException e)
21         {
22             System.out.println(e.getMessage());
23         }
24     }
25 }
View Code

7  RandomAccessFile类

        RandomAccessFile(随机访问文件)类的实例支持对随机访问文件的读/写。随机访问文件就像存储在文件系统中的巨大的字节数组，通过游标或者索引(叫做文件指示器)指向这个暗含的数组，输入操作从指示器处读取字节，然后前进指针。如果随机访问文件以可读/写模式创建，那么还支持输出操作，输出操作写到暗含数组的尾端，使得数组得以扩展。

例：随机访问文件，将文件内容输出，并写入两个字符“O”、“K”。若文件内容直接输出到屏幕上，的乱码问题，添加一个parseChinese方法后，得以修正。

 1 package inputOutput;
 2 import java.io.*;
 3 
 4 public class UseRandom {
 5 
 6     public static void main(String[] args) {
 7         // TODO 自动生成的方法存根
 8         try
 9         {
10                 //构建随机访问文件对象
11                RandomAccessFile f = new RandomAccessFile("Hello1.txt","rw");
12                //得到文件指针和长度
13                long flag = 0;
14                long len = f.length();
15                //字符处理后输出
16                while(flag <len)
17                {
18                     String s = f.readLine();
19                     System.out.println(parseChinese(s));
20                     flag = f.getFilePointer();
21                 }
22                           //末尾写入字符
23                 f.writeChar('O');
24                 f.writeChar('K');
25                 f.writeUTF("美女，你好！");
26             }
27             catch(IOException e)
28             {
29                 System.out.println(e.getMessage());
30             }
31         }
32     //解决中文转换问题
33     public static String parseChinese(String inStr) 
34     { 
35         String s = null; 
36         byte temp[]; 
37         if (inStr == null) 
38         { 
39             return new String(""); 
40         } 
41         try 
42         { 
43             temp=inStr.getBytes("iso-8859-1"); 
44             s = new String(temp); 
45         } 
46         catch(UnsupportedEncodingException e) 
47         { 
48             System.out.println (e.toString()); 
49         } 
50         return s; 
51     }
52 }
View Code

8  对象流

8.1  ObjectInputStream类

ObjectInputStream(对象输入流)可读取使用对象输出流写入的原始数据和类型，与文件输入输出流一起可以实现对象的持久性存储。它的构造函数和一个读对象的方法如下：

public ObjectInputStream(InputStream in) throws IOException                    从特定的输入流中读取并创建一个对象输入流。

Public Object readObject()                                                                        从对象输入流中读取对象。

8.2  ObjectOutputStream类

ObjectOutputStream(对象输出流)可将Java的原始数据类型和图形写入输出流，对象可以使用对象输入流读取，使用文件可以实现对象的持久存储。它的构造函数和一个写对象方法如下：

public ObjectOutputStream(OutputStream out) throws IOException            创建一个对象输出流，可以写入特定的输出流。

void writeObject(Object obj)                                                                    将对象obj写入对象输出流。

例：将日期对象和向量对象写入文件，然后从文件中读出并输出到屏幕上。要求向量对象含有三个值“语文”、“数学”和“物理”。

 1 package inputOutput;
 2 import java.io.*;
 3 import java.text.SimpleDateFormat;
 4 import java.util.*;
 5 
 6 public class UseStream {
 7 
 8     public static void main(String[] args) {
 9         // TODO 自动生成的方法存根
10         //构建Vector对象
11         Vector<String> v = new Vector<String>();
12         v.add("语文");
13         v.add("数学");
14         v.add("物理");
15         try
16         {
17             //文件处理对象
18             File f = new File("temp.txt");
19             FileOutputStream fOut = new FileOutputStream(f);
20             ObjectOutputStream objOut = new ObjectOutputStream(fOut);
21             //写入日期对象
22             
23             objOut.writeObject(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
24             //写入Vector对象
25             objOut.writeObject(v);
26             objOut.close();
27             //构建readObj的实例
28             readObj rObj = new readObj();
29             //调用方法输出
30             rObj.readO();
31         }catch(IOException e)
32         {
33             System.out.println(e.getMessage());
34         }
35     }
36  };
37  //自定义类，实现读取对象并输出
38  class readObj extends Object
39  {
40   public void readO()
41   {
42      try
43      {
44         //文件处理对象
45          File f = new File("temp.txt");
46          FileInputStream fIn = new FileInputStream(f);
47          @SuppressWarnings("resource")
48         ObjectInputStream objIn = new ObjectInputStream(fIn);
49          //读取对象输出
50          Object ob1 = objIn.readObject();
51          System.out.println(ob1);
52          Object ob2 = objIn.readObject();
53          System.out.println(ob2);
54      }catch(IOException e){
55             System.out.println(e.getMessage());
56      }catch(ClassNotFoundException e){
57             System.out.println(e.getMessage());
58      }
59   }
60  }
View Code
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/feitiannengdou/p/5477511.html