Java Java.io.FilterInputStream用法及代码示例

过滤流在读取和写入输入流中的数据时过滤数据，过滤数据并将其传递到底层流。过滤流是

FilterInputStream
Java.io.FilterOutputStream

FilterInputStream：Java.io.FilterInputStream 类的工作方式与 Java 中的 InputStream 类几乎类似，但它所做的只是重写 InputStream 类方法，将请求传递给 InputStream。 FilterInputStream 类的 read() 方法过滤数据并读取数据，并将数据传递到底层流过滤，该过滤是根据流完成的。

声明：

public class FilterInputStream
   extends InputStream

构造函数：

受保护的FilterInputStream(InputStream中)：通过将参数分配给字段this.in来创建FilterInputStream，以便记住它以供以后使用。

方法：

读取(字节[]缓冲区)：java.io.FilterInputStream.read(byte[] 缓冲区)将 buffer.length 的字节数从过滤器输入流读取到缓冲区数组。
Syntax :

public int read(byte[] buffer)
Parameters :
buffer : buffer to be read
Return : 
reads number of bytes of buffer.length to the buffer 
else, -1 i.e. when end of file is reached.
Exception :
->  IOException : If I/O error occurs.

执行：


// Java program illustrating the working of read(byte[] buffer) method 
  
import java.io.*; 
  
public class NewClass 
{ 
    public static void main(String[] args) throws IOException 
    { 
        // LineNumberInputStream & FileInputStream initailly null 
        FilterInputStream geek_input = null; 
        InputStream geek = null; 
  
        try{ 
            char c; 
            int a; 
            byte[] buffer = new byte[6]; 
  
            // New InputStream : 'GEEKS' is created 
            geek = new FileInputStream("GEEKS.txt"); 
            geek_input = new BufferedInputStream(geek); 
  
            a = geek.read(buffer); 
            // read() method returning Bytes of Input Stream as integer 
            // '-1' indicating to read till end Of Input Stream 
            int length = 1 ; 
              
            for(byte g : buffer) 
            { 
                // Since read() method returns Integer value 
                // So, we convert each integer value to char 
                c = (char)g; 
  
                System.out.println("At position " + length  +  " : "  + c); 
                length++; 
            } 
        } 
        catch(Exception e) 
        { 
            // In case of error 
            e.printStackTrace(); 
            System.out.println("ERROR Occurs "); 
        } 
        finally
        { 
            // Closing the streams, Once the End of Input Stream is reached 
            if(geek != null) 
                geek.close(); 
  
            if(geek_input != null) 
                geek_input.close(); 
        } 
    } 
}

注意：
以下 Java 代码不会在这里运行，因为我们无法访问在线 IDE 上的任何文件。
因此，将该程序复制到您的系统并在那里运行。

程序中使用的GEEKS.txt文件包含：

HelloGeeks

在给定的代码中 buffer.length = 6 ，因此只有 HelloG 会通过 read(byte[] buffer) 方法读取
输出：

At position 1 : H
At position 2 : e
At position 3 : l
At position 4 : l
At position 5 : o
At position 6 : G

读取(字节[]缓冲区，int偏移量，int maxlen)：java.io.FilterInputStream.read(byte[] 缓冲区, int 偏移量, int maxlen)将 FilterInputStream 中最多 maxlen 的数据读取到缓冲区中。
Syntax :

public int read(byte[] buffer, int offset, int maxlen)
Parameters :
buffer : Destination buffer
offset : start position to read
maxlen : max. length of bytes to be read
Return : 
total no. of bytes to be written else, -1 i.e. when end of Stream is reached.
Exception :
->  IOException : If I/O error occurs.

执行：


// Java program illustrating the working of 
// read(byte[] buffer, int offset, int maxlen) method 
  
import java.io.*; 
  
public class NewClass 
{ 
    public static void main(String[] args) throws IOException 
    { 
        // LineNumberInputStream & FileInputStream initailly null 
        FilterInputStream geek_input = null; 
        InputStream geek = null; 
  
        try{ 
            char c; 
            int a; 
            byte[] buffer = new byte[4]; 
  
            // New InputStream : 'ABC' is created 
            geek = new FileInputStream("ABC.txt"); 
            geek_input = new BufferedInputStream(geek); 
  
            // Offset = 1(*), Maxlen = 3 (MOH) 
            a = geek.read(buffer, 1, 3); 
            // read() method returning Bytes of Input Stream as integer 
            // '-1' indicating to read till end Of Input Stream 
             
            for(byte g : buffer) 
            { 
                // Since read() method returns Integer value 
                // So, we convert each integer value to char 
                c = (char)g; 
  
                if(g == 0) 
                    c = '*'; 
  
                System.out.print(c); 
            } 
        } 
        catch(Exception e) 
        { 
            // In case of error 
            e.printStackTrace(); 
            System.out.println("ERROR Occurs "); 
        } 
        finally
        { 
            // Closing the streams, Once the End of Input Stream is reached 
            if(geek != null) 
                geek.close(); 
  
            if(geek_input != null) 
                geek_input.close(); 
        } 
    } 
}

注意：
以下 Java 代码不会在这里运行，因为我们无法访问在线 IDE 上的任何文件。
因此，将该程序复制到您的系统并在那里运行。

程序中使用的ABC.txt文件包含：

MOHIT

偏移 = 1 即 * 且 Maxlen = 3 即 MOH
输出：

*MOH

available():java.io.FilterInputStream.available()返回编号。可以从输入流读取的字节数。
Syntax :

public int available()
Parameters : 
-------
Return : 
returns the no. of bytes that can be read from the FilterInputStream.
Exception: 
IOException : in case I/O error occurs

执行：


// Java program illustrating the working of available() method 
  
import java.io.*; 
public class NewClass 
{ 
    public static void main(String[] args) throws IOException 
    { 
        // FilterInputStream & FileInputStream initailly null 
        FilterInputStream geek_input = null; 
  
        InputStream geek = null; 
  
        try{ 
            char c; 
            int a, b; 
  
            // New InputStream : 'ABC' is created 
            geek = new FileInputStream("ABC.txt"); 
            geek_input = new BufferedInputStream(geek); 
  
            while((a = geek_input.read()) != -1) 
            { 
                // So, we convert each integer value to char 
                c = (char)a; 
  
                // Use of available method : return no. of bytes that can be read 
                a = geek_input.available(); 
                System.out.println(c + " Bytes available : " + a); 
  
            } 
        } 
        catch(Exception e) 
        { 
            // In case of error 
            e.printStackTrace(); 
            System.out.println("ERROR Occurs "); 
        } 
        finally
        { 
            // Closing the streams, Once the End of FilterInputStream is reached 
            if(geek != null) 
                geek.close(); 
  
            if(geek_input != null) 
                geek_input.close(); 
        } 
    } 
}

注意：
以下 Java 代码不会在这里运行，因为我们无法访问在线 IDE 上的任何文件。
因此，将该程序复制到您的系统并在那里运行。

程序中使用的ABC.txt文件包含：

MOHIT

输出：

M Bytes available : 4
O Bytes available : 3
H Bytes available : 2
I Bytes available : 1
T Bytes available : 0

read():java.io.FilterInputStream.read()从过滤器输入流读取下一个数据字节。返回的字节值范围为 0 到 255。如果由于已到达流末尾而没有可用字节，则返回值 -1。
Syntax :
```
public int read()
Parameters :
------
Return : 
Reads next data else, -1 i.e. when end of Stream is reached.
Exception :
->  IOException : If I/O error occurs.
```
close():java.io.FilterInputStream.close()关闭过滤器输入流并将与该流关联的系统资源释放到垃圾Collector。
Syntax :
```
public void close()
Parameters :
------
Return : 
void
Exception :
->  IOException : If I/O error occurs.
```
标记(int arg)：java.io.FilterInputStream.mark(int arg)标记 FilterInputStream 的当前位置。它设置读取限制，即标记位置无效之前可以读取的最大字节数。
Syntax :
```
public void mark(int arg)
Parameters :
arg : integer specifying the read limit of the input Stream
Return : 
void
```

skip():java.io.FilterInputStream.skip(长参数)跳过并丢弃FilterInputStream 数据中的‘arg’ 字节。
Syntax :

public long skip(long arg)
Parameters : 
arg : no. of bytes of FilterInputStream data to skip.
Return : 
no. of bytes to be skipped
Exception: 
IOException : in case I/O error occurs

reset():java.io.FilterInputStream.reset()由mark()方法调用。它将 FilterInputStream 重新定位到标记位置。
Syntax :
```
public void reset()
Parameters :
----
Return : 
void
Exception :
->  IOException : If I/O error occurs.
```
markSupported():java.io.FilterInputStream.markSupported()方法测试此输入流是否支持标记和重置方法。 InputStream 的 markSupported 方法默认返回 false。
Syntax :
```
public boolean markSupported()
Parameters :
-------
Return : 
true if input stream supports the mark() and reset() method  else,false
```

Java程序讲解：markSupported()、close()、reset()、mark()、read()、skip()方法


// Java program illustrating the working of FilterInputStream method 
// mark(), read(), skip() 
// markSupported(), close(), reset() 
  
import java.io.*; 
  
public class NewClass 
{ 
    public static void main(String[] args) throws Exception 
    { 
        InputStream geek = null; 
        // FilterInputStream initialised to null here 
        FilterInputStream geek_input = null; 
        try { 
  
            geek = new FileInputStream("GEEKS.txt"); 
              
        geek_input = new BufferedInputStream(geek); 
  
            // read() method : reading and printing Characters 
            // one by one 
            System.out.println("Char : " + (char)geek_input.read()); 
            System.out.println("Char : " + (char)geek_input.read()); 
            System.out.println("Char : " + (char)geek_input.read()); 
  
            // mark() : read limiing the 'geek' input stream 
            geek_input.mark(0); 
  
            // skip() : it results in redaing of 'e' in G'e'eeks 
            geek_input.skip(1); 
            System.out.println("skip() method comes to play"); 
            System.out.println("mark() method comes to play"); 
            System.out.println("Char : " + (char)geek_input.read()); 
            System.out.println("Char : " + (char)geek_input.read()); 
            System.out.println("Char : " + (char)geek_input.read()); 
  
            boolean check = geek_input.markSupported(); 
            if (geek_input.markSupported()) 
            { 
                // reset() method : repositioning the stream to 
                // marked positions. 
                geek_input.reset(); 
                System.out.println("reset() invoked"); 
                System.out.println("Char : " + (char)geek_input.read()); 
                System.out.println("Char : " + (char)geek_input.read()); 
            } 
            else
                System.out.println("reset() method not supported."); 
                System.out.println("geek_input.markSupported() supported" 
                                                + " reset() : " + check); 
  
        } 
        catch(Exception excpt) 
        { 
            // in case of I/O error 
            excpt.printStackTrace(); 
        } 
        finally
        { 
            // releasing the resources back to the 
            // GarbageCollector when closes 
            if (geek != null) 
            { // Use of close() : closing the file 
                // and releasing resources 
                geek.close(); 
            } 
  
            if(geek_input != null) 
                geek_input.close(); 
        } 
    } 
}

注意：
此代码不会在在线 IDE 上运行，因为此处不存在此类文件。
您可以在系统上运行此代码来检查工作情况。
GEEKS.txt代码中使用的文件有

HelloGeeks

输出：

Char : H
Char : e
Char : l
skip() method comes to play
mark() method comes to play
Char : o
Char : G
Char : e
reset() invoked
Char : l
Char : o
geek_input.markSupported() supported reset() : true

相关用法

注：本文由纯净天空筛选整理自佚名大神的英文原创作品 Java.io.FilterInputStream Class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。