bufferstream.java

这是我们专业的课程设计

package Commen;

import java.nio.ByteBuffer;

public class BufferStream {

	private byte[] buffer;
	private int readPoint;
	private int writePoint;
	boolean accuraty;
	private int capacity;
	private int remain;

	public BufferStream(int capacity) {
		this.capacity = capacity;
		buffer = new byte[capacity];
		readPoint = 0;
		writePoint = 0;
		remain = capacity;
		accuraty = false;
	}

	public BufferStream(int capacity, boolean bool) {
		this.capacity = capacity;
		buffer = new byte[capacity];
		readPoint = 0;
		writePoint = 0;
		remain = capacity;
		accuraty = bool;
	}

	public byte[] gets() {
		byte[] ret = null;
		if (writePoint > readPoint)// 读的在前 写的在后
		{
			ret = new byte[writePoint - readPoint];
			ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, readPoint,
					writePoint - readPoint);
			byteBuffer.get(ret);
		} else if (writePoint <= readPoint && remain != capacity)// 读得在后
		// 说明写了一轮了
		{
			ret = new byte[capacity - (readPoint - writePoint)];
			ByteBuffer byteBuffer = ByteBuffer.wrap(ret);
			byteBuffer.put(buffer, readPoint, capacity - readPoint);
			byteBuffer.put(buffer, 0, writePoint);// 是不是不用get了？
		}
		readPoint = writePoint;
		remain = capacity;
		return ret;
	}

	public byte[] gets(int length) {
		if (remain < length) {
			System.out.println("no more to get");
			return null;
		}
		byte[] ret = null;
		if (writePoint > readPoint)// 读的在前 写的在后
		{
			ret = new byte[length];
			ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, readPoint, length);
			byteBuffer.get(ret);
			readPoint = readPoint + length;
		} else if (writePoint <= readPoint && remain != capacity)// 读得在后
		// 说明写了一轮了
		// 且里面有数据
		// 防止写一轮
		{
			ret = new byte[length];
			ByteBuffer byteBuffer = ByteBuffer.wrap(ret);
			if (capacity - readPoint > length)// readPoint 不换行
			{
				byteBuffer.put(buffer, readPoint, length);
				readPoint = readPoint + length;
			} else {
				byteBuffer.put(buffer, readPoint, capacity - readPoint);
				int rest = length - (capacity - readPoint);
				byteBuffer.put(buffer, 0, rest);
				readPoint = readPoint + length - capacity;
			}
		}
		remain = remain + length;
		return ret;
	}

	public void puts(byte[] data) {
		// puts(data, 0, data.length);
		if (data == null)
			return;// 有问题 直接退出
		if (data.length > remain) {// 不可做 扩容 或者 不做 看accuraty参数了
			System.out.println("no room for the data");
			if (accuraty) {
				byte[] newBuffer = new byte[2 * (capacity + data.length)];
				byte[] newData = gets();
				ByteBuffer byteBuffer = ByteBuffer.wrap(newBuffer);
				byteBuffer.put(newData);
				byteBuffer.put(data);
				readPoint = 0;
				writePoint = newData.length + data.length;
				capacity = 2 * (capacity + data.length);
				remain = capacity - newData.length - data.length;
				buffer = byteBuffer.array();
			} else
				;// 不需准确 则什么都不做
		} else {// 可做
			ByteBuffer byteBuffer = ByteBuffer.wrap(data);
			if (writePoint + data.length >= capacity)// wp指针要转回去
			{
				byteBuffer.get(buffer, writePoint, capacity - writePoint);
				writePoint = writePoint + data.length - capacity;
				byteBuffer.get(buffer, 0, writePoint);
			} else {
				byteBuffer.get(buffer, writePoint, data.length);
				writePoint = writePoint + data.length;
			}
			remain = remain - data.length;
		}

	}

	public void puts(byte[] data, int offset, int length) {
		if (data == null)
			return;
		if (length > remain) {// 不可做 重新开辟空间
			System.out.println("no room for the data");
			if (accuraty) {
				System.out.println("no room for the data");
				byte[] newBuffer = new byte[2 * (capacity + length)];
				byte[] newData = gets();
				ByteBuffer byteBuffer = ByteBuffer.wrap(newBuffer);
				byteBuffer.put(newData);
				byteBuffer.put(data, offset, length);
				readPoint = 0;
				writePoint = newData.length + length;
				capacity = 2 * (capacity + length);
				remain = capacity - newData.length - length;
				buffer = byteBuffer.array();
			} else
				;// 不需准确 则什么都不做
		} else {// 可做
			ByteBuffer byteBuffer = ByteBuffer.wrap(data, offset, length);
			if (writePoint + length >= capacity)// wp指针要转回去
			{
				byteBuffer.get(buffer, writePoint, capacity - writePoint);
				writePoint = writePoint + length - capacity;
				byteBuffer.get(buffer, 0, writePoint);
			} else {
				byteBuffer.get(buffer, writePoint, length);
				writePoint = writePoint + length;
			}
			remain = remain - length;
		}
	}

	public void printState()// 测试用
	{
		printBytes();
		System.out.println("r:" + readPoint);
		System.out.println("w:" + writePoint);
		System.out.println("c:" + remain);
	}

	public void printBytes()// 测试用
	{
		if (writePoint > readPoint) {
			for (int i = readPoint; i < writePoint; i++)
				System.out.print(buffer[i] + " ");
		} else if (readPoint >= writePoint && remain != capacity) {
			for (int i = readPoint; i < capacity; i++)
				System.out.print(buffer[i] + " ");
			for (int i = 0; i < writePoint; i++)
				System.out.print(buffer[i] + " ");
		}
		System.out.println();
	}

	public int Remain() {
		return remain;
	}

	public int Hold() {
		return capacity - remain;
	}
}