可变长编码

最新推荐文章于 2024-11-05 19:47:09 发布

原创最新推荐文章于 2024-11-05 19:47:09 发布 · 2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#byte #string #null #import #class

Java 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一个用于处理int、byte[]和String类型数据的可变长编码解码器的设计与实现。该编码器能够高效地将这些类型的数据编码成字节数组，并能从字节数组中解码回原始数据。文章详细阐述了编码和解码的过程，包括如何处理整形数据的可变长编码。

import java.util.Arrays;



/*写一个编码解码的类,具体要求如下: 

编码过程:将int,byte[],String类型的数据,放到一个字节数组中,

解码:将字节数组转换为相应数据 

在编码过程中,要求对所有整形数据进行可变长编码, byte[]和String类型数据存放时要首先存放长度(也作为整形进行可变长编码),再存放内容.解码过程中要对整形数据进行相应的解码. 

整形数据的可变长编码过程具体为,用一个字节的最高位来表示下一个字节是否和这个字节表示同一个整形数据,最高位为1,表示下一个字节和这个字节表示同一个整形数据,为0,

反之.例如 十进制127表示为01111111,用一个字节表示. 十进制128表示为:1000 0001 0000 0000,需要两个字节. 十进制129表示为:1000 0001 0000 0001,需要两个字节 

此类的方法要有 

编码:void putInt( int value), 

void putString(String value),

void putBytes(byte[] value) 

 解码:Int getInt(),

  Stirng getString(),

 byte[] getBytes() 方法*/

class Bit{

	byte elems[];

	Bit next;

	

	Bit(Bit next){

		elems=new byte[8];

		this.next=next;

	}

	public void setNext(Bit next){

		this.next=next;

	}

	public void reverse() {

		int i=1;

		byte tem;

		for(;i<4;i++){

			tem=elems[i];

			elems[i]=elems[8-i];

			elems[8-i]=tem;

		}

		

	}

	public String toString(){

		int i;

		StringBuffer sb=new StringBuffer();

		for(i=0;i<8;i++){

			sb.append(elems[i]);

		}

		return sb.toString();

	}

	public void hasNext(){

		elems[0]=1;

	}

	public byte getValue(){

		byte s=0;

		int i;

		for(i=1;i<8;i++){

			s+=elems[i]<<(7-i);

			//s=(byte)(s<<1);

		}

		//s=(byte) (s>>1);

		return s;

	}

}

public class Encode {

	private Bit head;

	private Bit tail;

	int leng;

	public Encode(){

		head=new Bit(null);

	}

	public void putInt( int value){

		int t;

		byte n;

		if(head.next!=null)tail=head.next;

		else tail=null;

		t=value;

		do{

			n=(byte)(t&0x7f);

			t=t>>7;

			add(n);

		}while(t>0);

		flag();

	}

	

	private void flag(){

		Bit t=head.next;

		if(t!=null){

		do{

			t.hasNext();

			t=t.next;

			}while(t.next!=tail);

		}

	}

	private void add(byte n) {

		Bit b=new Bit(null);

		leng++;

		int i;

		b.setNext(head.next);

		head.setNext(b);

		b.elems[0]=0;

		for(i=1;i<8;i++){

			b.elems[i]=(byte)(n%2);

			n=(byte) (n>>1);

		}

		b.reverse();

	}

	public void putString(String value){

		this.putInt(Integer.parseInt(value));

	}

	public Bit getCode() {

		return head;

	}

	

	public String toString(){

		StringBuffer sb=new StringBuffer();

		Bit t=head.next;

		for(;t!=null;t=t.next)

			{

				sb.append(t.toString());

				

			}

		return sb.toString();

	}

	

	public void putBytes(byte[] value) {

		

	}

	public int getInt(){

		int s=0;

		Bit t=head.next;

		if(t==null)return -1;

		do{

			s+=t.getValue(); //高位字节

			if(t.elems[0]!=0)s=s<<7;

			else break;//t指向有elems[0]==0

		}while((t=t.next)!=null);

		if(t!=null)head=t;

		return s;

	}

	public String getString(){

		int s=getInt();

		return String.valueOf(s);

	}

	public static void main(String args[]){

		Encode d=new Encode();

		int i=129;//     		1000010111100010100110011011110000011101

		String s="154845111";//1000010111100010100110011011110000011101

		d.putInt(i);

		d.putString(s);

		System.out.println(d);

		System.out.println(d.getString());

		System.out.println(d.getInt());

		System.out.println(Integer.toBinaryString(i));

	//1000 0001 0000 0001

	//1000 0001 0000 0001

	}

}