生成64位长度的纯数字

  由于有个需求要写个由64位长度的数字组成的“大数字”，还要实现增加或减少指定数字的方法，于是自己写了个类：

 

import java.util.Random;

public class Generate64Number
{

	private int[] a = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 };

	// 随机生成一个64位的数
	public Generate64Number(boolean generate)
	{
		// 如果TRUE的话随机生成
		if (generate)
		{
			Random rand = new Random();
			for (int i = 0; i < 8; i++)
			{
				a[i] = rand.nextInt(99999999);
			}
		}
	}

	// 根据传入的64位的字符串来构造
	public Generate64Number(String code) throws Not64Exception
	{
		if (code.length() != 64)
		{
			throw new Not64Exception();
		}

		try
		{
			// 分解成八个八位的
			for (int i = 0; i < 8; i++)
			{
				a[i] = Integer.parseInt(code.substring(8 * i, 8 * (i + 1)));
			}
		} catch (Exception e)
		{
			e.printStackTrace();
			throw new Not64Exception();
		}
	}

	// 转成64位的字符串
	public String toString()
	{
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 8; i++)
		{
			String s = String.valueOf(a[i]);
			int len = s.length();
			if (len < 8)
			{
				for (int j = 0; j < 8 - len; j++)
					sb.append("0");
			}
			sb.append(s);
		}

		return sb.toString();
	}

	// 加法操作
	public void add(int m)
	{
		for (int i = 7; i >= 0; i--)
		{
			if (a[i] + m > 99999999)
			{
				if(i==7)
					a[i] = m - 1;
				else
					a[i] = 0;
			} else
			{
				a[i] = a[i] + 1;
				break;
			}
		}
	}

	// 减法操作
	public void sub(int m)
	{
		for (int i = 7; i >= 0; i--)
		{
			if (a[i] - m < 0)
			{
				if(i == 7)
					a[i] = 99999999 - m + 1;
				else
					a[i] = 99999999;
			} else
			{
				a[i] = a[i] - 1;
				break;
			}
		}
	}

	//上一个数字
	public void prev()
	{
		sub(1);
	}
	
	//下一个数字
	public void next()
	{
		add(1);
	}
	// 全部清为0
	public void clear()
	{
		for (int i = 0; i < 8; i++)
		{
			a[i] = 0;
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		try
		{
			//使用指定的来生成
			Generate64Number gn1 = new Generate64Number(
					"0000901261030492737117826098589044485275508695163425252999999999");
			System.out.println("原:"+gn1.toString());
			gn1.add(1);
			System.out.println("新:"+gn1.toString());
			System.out.print("Length:");
			System.out.println(gn1.toString().length());

			//生成64个0
			Generate64Number gn2 = new Generate64Number(false);
			System.out.println("原:"+gn2.toString());
			gn2.sub(1);
			System.out.println("新:"+gn2.toString());
			System.out.print("Length:");
			System.out.println(gn2.toString().length());

			//为了验证加法操作
			Generate64Number gn3 = new Generate64Number(
					"9999999999999999999999999999999999999999999999999999999999999999");
			System.out.println("原:"+gn3.toString());
			gn3.add(1);
			System.out.println("新:"+gn3.toString());
			System.out.print("Length:");
			System.out.println(gn3.toString().length());

			//随机生成然后清空
			Generate64Number gn4 = new Generate64Number(true);
			System.out.println("原:"+gn4.toString());
			gn4.clear();
			System.out.println("新:"+gn4.toString());
			System.out.print("Length:");
			System.out.println(gn4.toString().length());
			
			//减法
			Generate64Number gn5 = new Generate64Number(
					"0000901261030492737117826098589044485275508695163425252000000000");
			System.out.println("原:"+gn5.toString());
			gn5.sub(6);
			System.out.println("新:"+gn5.toString());
			System.out.print("Length:");
			System.out.println(gn5.toString().length());
		} catch (Not64Exception e)
		{
			System.out.println(e.getMessage());
			e.printStackTrace();
		}

	}

}

class Not64Exception extends Exception
{

	public Not64Exception()
	{
		super("不是64位的数字！");
	}
}