Java中的Java.io.ByteArrayInputStream类

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)
  •   Java I/O总结

    Java中的Java.io.ByteArrayInputStream类

    java.io.ByteArrayInputStream类包含所有缓冲区,包含要从输入流中读取的字节。ByteArrayInputStream类方法没有IO异常。这个类的方法甚至可以在关闭Stream之后调用,它对类方法没有影响。

    语法 :

    public class ByteArrayInputStream
       extends InputStream

    字段

    • protected byte [] buf:由流的创建者提供的字节数组。
    • protected int count:索引1大于输入流缓冲区中最后一个有效字符。
    • protected int mark:流中当前标记的位置。
    • protected int pos:这是从输入流缓冲区读取的下一个字符的索引。

    构造函数:

    • ByteArrayInputStream(byte [] buffer):创建ByteArrayInputStream以使用缓冲区数组 - “缓冲区”。
    • ByteArrayInputStream(byte [] buf,int offset,int length):创建ByteArrayInputStream,它使用“buffer”的某个部分,即缓冲区数组

    方法:

    • mark(int arg):Java.io.ByteArrayInputStream.mark(int arg)标记输入流的当前位置。它设置readlimit,即标记位置变为无效之前可以读取的最大字节数。
      句法 :

      public void mark(int arg)
      Parameters :
      arg : integer specifying the read limit of the input Stream
      Return : 
      void
    • read():java.io.ByteArrayInputStream.read()从输入流中读取下一个字节的数据。值字节的返回范围是0到255.如果由于流的末尾已到达而没有可用的字节,则返回值-1。方法不会阻止
      语法:

      public int read()
      Parameters :
      ------
      Return : 
      Reads next data else, -1 i.e. when end of file is reached.
      Exception :
      ->  IOException : If I/O error occurs.
    • close():java.io.ByteArrayInputStream.close()关闭输入流并将与此流关联的系统资源释放到垃圾收集器。
      句法 :

      public void close()
      Parameters :
      ------
      Return : 
      void
      Exception :
      ->  IOException : If I/O error occurs.
    • 读取(byte []缓冲区,int偏移量,int maxlen):Java.io.ByteArrayInputStream.read(byte [] buffer,int offset,int maxlen)从位置“offset”开始读取输入流的“buffer”字节数组到maxlen 。
      句法 :

      public int read(byte[] buffer, int offset, int maxlen)
      Parameters :
      arg : array whose number of bytes to be read
      offset : starting position in buffer from where to read
      maxlen : maximum  no. of bytes to be read
      Return : 
       reads number of bytes and return to the buffer else, -1 i.e. when end of file is reached.
      Exception :
      ->  IOException : If I/O error occurs.
      ->  NullPointerException : if arg is null.
    • reset():由mark()方法调用Java.io.ByteArrayInputStream.reset()。它将输入流重新定位到标记位置。
      句法 :

      public void reset()
      Parameters :
      ----
      Return : 
      void
      Exception :
      ->  IOException : If I/O error occurs.
    • markSupported():Java.io.ByteArrayInputStream.markSupported() 方法测试此输入流是否支持标记和重置方法。ByteArrayInputStreamInputStream的markSupported方法始终返回true
      语法:

      public boolean markSupported()
      Parameters :
      -------
      Return : 
      true if input stream supports the mark() and reset() method  else,false
    • skip(long arg):Java.io.ByteArrayInputStream.skip(long arg) 跳过输入流中的arg字节。
      句法 :

      public long skip(long arg)
      Parameters :
      arg : no. of bytes to be skipped
      Return : 
      skip bytes.
      Exception :
      ->  IOException : If I/O error occurs.
    • available():Java.io.ByteArrayInputStream.available() 告诉总数。来自输入流的字节被读取
      语法:

      public int available()
      Parameters :
      -----------
      Return : 
      total no. of bytes to be read
      Exception :
      -----------

    Java程序解释ByteArrayInputStream类方法:

    // Java program illustrating the working of ByteArrayInputStream method
    // mark(), read(), skip(), available()
    // markSupported(), close(), reset()
    
    import java.io.*;
    
    public class NewClass
    {
        public static void main(String[] args) throws Exception
        {
            byte[] buffer = {71, 69, 69, 75, 83};
            ByteArrayInputStream geek = null;
            try
            {
                geek = new ByteArrayInputStream(buffer);
    
                // Use of available() method : telling the no. of bytes to be read
                int number = geek.available();
                System.out.println("Use of available() method : " + number);
    
    
                // Use of read() method : reading and printing Characters one by one
                System.out.println("\nChar : "+(char)geek.read());
                System.out.println("Char : "+(char)geek.read());
                System.out.println("Char : "+(char)geek.read());
    
                // Use of mark() :
                geek.mark(0);
    
                // Use of skip() : it results in skiping 'k' from "GEEKS"
                geek.skip(1);
                System.out.println("skip() method comes to play");
                System.out.println("mark() method comes to play");
                System.out.println("Char : "+(char)geek.read());
    
                // Use of markSupported
                boolean check = geek.markSupported();
                System.out.println("\nmarkSupported() : " + check);
                if(geek.markSupported())
                {
                    // Use of reset() method : repositioning the stram to marked positions.
                    geek.reset();
                    System.out.println("\nreset() invoked");
                    System.out.println("Char : "+(char)geek.read());
                    System.out.println("Char : "+(char)geek.read());
                }
                else
                {
                    System.out.println("reset() method not supported.");
                }
    
                System.out.println("geek.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();
                }
            }
        }
    }
    

    输出:

    Use of available() method : 5
    
    Char : G
    Char : E
    Char : E
    skip() method comes to play
    mark() method comes to play
    Char : S
    
    markSupported() : true
    
    reset() invoked
    Char : K
    Char : S
    geek.markSupported() supported reset() : true
  •   Java I/O总结
  •   本文标题:Java中的Java.io.ByteArrayInputStream类 - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/4276.html

    "Java中的Java.io.ByteArrayInputStream类"的笔记

    • InputStream在使用完后,不关闭流,想复用怎么办?

      具体的方法是:过mark和reset方法重复利用InputStream。以ByteArrayInputStream为例

      package breakyizhan;
       
      import java.io.ByteArrayInputStream;
      import java.io.IOException;
      import java.io.InputStream;
       
      public class Test {
      	public static void main(String[] args) {
      		String content = "MengUer";
      		InputStream inputStream = new ByteArrayInputStream(content.getBytes());
      		int ch;
      		try {
      			while ((ch = inputStream.read()) != -1) {
      				System.out.print((char) ch);
      			}
      		} catch (IOException e) {
      			e.printStackTrace();
      		}
       
      		System.out.println("\n" + "-------华丽的分割线------");
       
      		try {
      			// 注意!
      			inputStream.reset();
      			while ((ch = inputStream.read()) != -1) {
      				System.out.print((char) ch);
      			}
      		} catch (IOException e) {
      			e.printStackTrace();
      		}
      	}
      }
      

      运行结果如下:

      MengUer
      -------华丽的分割线------
      
      MengUer
      

      如果没有inputStream.reset()方法,结果是这样的:

      MengUer
      -------华丽的分割线------
      Arvin Chen 2018年9月25日 下午1:32

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注