版本会越来越难：
版本1：只写一个read方法
package com.guigu.shen.InputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.print.attribute.PrintRequestAttribute;
//包含main方法。用来做测试的。
public class MyStream {
public static void main(String[] args) throws Exception {
byte[] b=new byte[16];
for(int i=0;i<b.length;i++)
{
b[i]=(byte)i;
}
MybyteArrayInputStream mybyteArrayInputStream=new MybyteArrayInputStream(b);
//死循环，直到把数据读完
while(true)
{
int c=mybyteArrayInputStream.read();
if(c<0)
{
break;
}
System.out.println(c+" ");
}
}
}
class MybyteArrayInputStream extends InputStream
{
//存放要被读取的数据的索引
private byte[] data;
//当前读的位置
private int ptr=0;
//这个构造函数传进来的就是我们要去读取的数据。
public MybyteArrayInputStream(byte[] b) {
//把要读的数据的索引赋给data;
this.data=b;
}
//每一次读取一个字节，没有读到返回-1;
@Override
public int read() throws IOException {
//看data里面的数据有没有被读完，没有读完(<data.length)就返回里面的值，读完了，就返回-1；
return (ptr<data.length)?(data[ptr++]):-1;
}
}结果：1,2，3,4,5,6、、、、、、15
版本2：有2个read方法。重写了InputStream里面很多方法，基本完整了。
package com.guigu.shen.InputStream;
import java.io.IOException;
import java.io.InputStream;
public class MyStream2 extends InputStream{
protected byte[] data;
//表示我当前读到的位置
protected int ptr=0;
//表示记住位置，我下一次可以跳到这个位置上
protected int mark=0;
public MyStream2(byte[] b) {
this.data=b;
}
@Override
public int read()
{
return (ptr<data.length)?(data[ptr++]):-1;
}
//这个方法返回的是我还有几个数据没有读
@Override
public int available() throws IOException {
//this.data.length表示我要读的数据额长度,ptr表示我已经读到哪里了，两者相减就是还剩下多少没有读
return this.data.length-ptr;
}
@Override
public void close() throws IOException {
//表明我读到最后了
ptr=data.length;
}
//表示我下次可以跳到这个位置上
@Override
public synchronized void mark(int readlimit) {
this.mark=readlimit;
}
//这个方法表示，我调用这个方法呢，就可以回到mark这个位置上。
@Override
public synchronized void reset() throws IOException {
if(mark<0||mark>=data.length)
{
throw new IOException("the postion is not valid");
}
ptr=mark;
}
//要想使用mark这个功能，就要让这个函数返回ture
@Override
public boolean markSupported() {
return true;
}
//重写第三个read方法，这个方法会调用第一个read()方法
@Override
public int read(byte[] b, int off, int len) throws IOException {
//如果已经读到末尾了或者长度小于0，就不行
if(this.ptr>=data.length||len<0)
{
return -1;
}
//如果已经读到了ptr,你还要读len这么长，当ptr+len>数据总长度时是不合理的。
if((this.ptr+len)>data.length)
{
//读取剩下的就好了
len=data.length-this.ptr;
}
if(len==0)
{
return 0;
}
/*
*
* System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。
* 其函数原型是： public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
* src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位置； length:复制的长度。
* 注意：src and dest都必须是同类型或者可以进行转换类型的数组．
*
*
*/
//把data数据里面的数据从ptr这个位置开始共len长度拷贝到b这个数组中的off这个位置开始的位置。同过数组拷贝的方式把数组拷贝到外面
System.arraycopy(data, ptr, b, off, len);
//更新已经读到的位置
ptr+=len;
//返回实际读到的长度
return len;
}
}
到这里，字节流讲完了
时间： 2024-10-19 10:25:29