"ArrayIndexOutOfBoundsException" error when trying to add two int arrays

Question

I'm trying to make an implementation of 'adding' the elements of two arrays in Java. I have two arrays which contain integers and i wanna add them. I dont want to use immutable variables. I prefer do sth like that : a.plus(b); The problem is when i add 2 arrays with different length.It tries to add the elements of b to a, but if b has a bigger length it flags an error "ArrayIndexOutOfBoundsException". I can understand why that's happening. But how can i solve this? How can i expand array a? :/

public void plus(int[] b)
    {

        int maxlength = Math.max( this.length, b.length );

        if (maxlength==a.length)
        {
            for (int i = 0; i <= maxlength; i++)
            {
                a[i] = a[i] + b[i];   //ArrayIndexOutOfBoundsException error
            }
        }
    }

Answer 1

i <= maxlength replace this with i < maxlength.

Your array index is starting at zero, not at one. So the length of the array is one less than the end index of the array. When you use <= you are trying to go one element after the last element in your array, Hence the exception.

Also you got to check the length of array b. If length of array b is smaller than a, you will end up facing the same exception.

int maxlength = Math.min( this.length, b.length ); is more appropriate.

Or incase if you don't want to miss out any elements in either of the arrays while adding, ArrayList is the answer for you. ArrayList is the self expanding array you are looking for. Here is how you can do that -

    // First ArrayList
    ArrayList<Integer> a = new ArrayList<Integer>();
    a.add(1);
    a.add(2);
    a.add(3);

    // Second ArrayList
    ArrayList<Integer> b = new ArrayList<Integer>();
    b.add(1);
    b.add(2);
    b.add(3);
    b.add(4);

    int maxlength = Math.max(a.size(), b.size());
    // Add the elements and put them in the first ArrayList in the corresponding 
    // position
    for (int i = 0; i < maxlength; i++) {
        if (i < a.size()) {
            if (i < b.size()) {
                int j = a.get(i);                   
                a.set(i, j + b.get(i));
            }
        } else {
            a.add(i, b.get(i));
        }
    }

    for (int j : a) {
        System.out.println(j);
    }

Answer 2

How can i expand array a?

Don't use arrays if you need variable-size data structures. Use Lists.

Answer 3

maxlength is the max between the size of a[] and b[], so in a loop from 0 to maxlength, you will get an ArrayIndexOutOfBoundsException when i exceeds the min of the size of a[] and b[].

Try this:

public void plus(int[] b)
    {
        Polynomial a = this;
        int[] c;
        int maxlength;
        if (a.length>b.length) {
            c=a;
            maxlength=a.length;
        } else {
            c=b;
            maxlength=b.length;
        }

        int ca, cb;
        for (int i = 0; i < maxlength; i++)
        {
            if (i<this.length)
                ca=a[i];
            else
                ca=0;
            if (i<b.length)
                cb=b[i];
            else
                cb=0;
            c[i] = ca + cb;
        }
    }

Answer 4

How about this:

private int[] a;

/**
 * Adds the specified array to our array, element by element, i.e.
 * for index i, a[i] = a[i] + b[i].  If the incoming array is
 * longer, we pad our array with 0's to match the length of b[].
 * If our array is longer, then only the first [b.length] values
 * of our array have b[] values added to them (which is the same
 * as if b[] were padded with 0's to match the length of a[]. 
 *
 * @param b the array to add, may not be null
 */
public void plus(final int[] b)
{
    assert b != null; 

    if (a.length < b.length) {
        // Expand a to match b
        // Have to move a to a larger array, no way to increase its
        // length "dynamically", i.e. in place.
        final int[] newA = new int[b.length];
        System.arraycopy(a, 0, newA, 0, a.length);
        // remaining new elements of newA default to 0
        a = newA;
    }

    for (int i = 0; i < b.length; i++)
    {
        a[i] = a[i] + b[i];
    }
}

Another version:

private ArrayList<Integer> aList;

public void plusList(final int[] b)
{
    assert b != null; 

    if (aList.size() < b.length) {
        aList.ensureCapacity(b.length);
    }

    for (int i = 0; i < b.length; i++)
    {
        if (i < aList.size()) {
            aList.set(i, aList.get(i) + b[i]);
        } else {
            aList.add(b[i]);
        }
    }
}

Edit: Here's the full class with sample run from data in comments

public class AddableArray {
    private int[] a;

    public AddableArray(final int... a) {
        this.a = a;
    }

    /**
     * Adds the specified array to our array, element by element, i.e.
     * for index i, a[i] = a[i] + b[i].  If the incoming array is
     * longer, we pad our array with 0's to match the length of b[].
     * If our array is longer, then only the first [b.length] values
     * of our array have b[] values added to them (which is the same
     * as if b[] were padded with 0's to match the length of a[].
     *
     * @param b the array to add, may not be null
     */
    public void plus(final int[] b)
    {
        assert b != null;

        if (a.length < b.length) {
            // Expand a to match b
            // Have to move a to a larger array, no way to increase its
            // length "dynamically", i.e. in place.
            final int[] newA = new int[b.length];
            System.arraycopy(a, 0, newA, 0, a.length);
            // remaining new elements of newA default to 0
            a = newA;
        }

        for (int i = 0; i < b.length; i++)
        {
            a[i] = a[i] + b[i];
        }
    }

    int[] get() {
        return a;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("a[] = [ ");
        for (int i = 0; i < a.length; i++) {
            if (i > 0)   sb.append(", ");
            sb.append(a[i]);
        }
        sb.append(" ]");
        return sb.toString();
    }

    public static void main (final String[] args) {

        final AddableArray myAddableArray = new AddableArray(1,2,3);

        System.out.println("Elements before plus(): ");
        System.out.println(myAddableArray.toString());

        final int b[]={1,2,3,4};
        myAddableArray.plus(b);

        System.out.println("Elements after plus(): ");
        System.out.println(myAddableArray.toString());

    }
}

Sample run:

Elements before plus(): 
a[] = [ 1, 2, 3 ]
Elements after plus(): 
a[] = [ 2, 4, 6, 4 ]

Answer 5

Try replacing:

for (int i = 0; i <= maxlength; i++)

with:

for (int i = 0; i < maxlength; i++)