Help me with Big Integer

Question

Hey everyone, I am trying to implement my own BigInt class. However I have absolutely no clue how to store them. So I use an array or linked list or any thing else. Can someone give a hint. Really Appreciate!

Answer 1

First, I'm assuming you're doing this just to learn Java, since this is a very inefficient way to store numbers.
Example:
Using 1 byte per digit means that the largest number you can represent with 2 bytes will be 99. However 2 bytes can be used to store a number as large as 255.
That being said here's one way of implementing add (I've just let go of the wrapper BigInt and am just using byte[], but you get the idea).
public class BigIntExample
    public static void main(String[] args) {
        BigIntExample example = new String8();
        byte[] foo = new byte[] {9,1,2,6,4};
        byte[] bar = new byte[] {  9,2,3,7};       
        byte[] baz = example.add(foo, bar);
        for (byte b : baz)
            System.out.print(b);
        System.out.println();
    public byte[] add(byte[] lhs, byte[] rhs) {
        byte[] result = new byte[Math.max(lhs.length, rhs.length)];
        int remainder = 0;
        int resI, lhsI, rhsI;
        for (resI = result.length - 1, lhsI = lhs.length - 1, rhsI = rhs.length - 1;
             lhsI >= 0 && rhsI >= 0;
             resI--, lhsI--, rhsI--) {
            byte[] added = addBytes(lhs[lhsI], rhs[rhsI], remainder);
            remainder = added[0];
            result[resI] = added[1];
        byte[] longer = lhs.length > rhs.length ? lhs : lhs.length < rhs.length ? rhs : null;
        int index = lhs.length > rhs.length ? lhsI : lhs.length < rhs.length ? rhsI : 0;
        if (longer != null) {
            for (; index >= 0; index--) {
                byte[] added = addBytes(longer[index], (byte)0, remainder);
                remainder = added[0];
                result[index] = added[1];
        if (remainder > 0) {
            byte[] temp = result;
            result = new byte[temp.length + 1];
            result[0] = 1;
            System.arraycopy(temp, 0, result, 1, temp.length);
        return result;
    private byte[] addBytes(byte b1, byte b2, int remainder) {
        byte[] result = new byte[2];
        int temp = b1 + b2 + remainder;
        if (temp > 9) {
            result[0] = 1;
            result[1] = (byte)(temp - 10);
        } else {
            result[0] = 0;
            result[1] = (byte)temp;
        return result;
}Note: this is probably not the most efficient way to do this