Question

我正在尝试在Java中实现'添加'两个数组的元素。我有两个包含整数的数组，我想添加它们。我不想使用不可变变量。我更喜欢这样做：a.plus（b）; 问题是当我添加2个不同长度的数组时。它尝试将b的元素添加到a，但如果b的长度更长，则会标记错误“ArrayIndexOutOfBoundsException”。我能理解为什么会这样。但我怎么能解决这个问题呢？我怎样才能扩展阵列？：/

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将此替换为i < maxlength。

您的数组索引从零开始，而不是从一开始。因此，数组的长度比数组的结束索引小1。当你使用＆lt; =你试图在数组中的最后一个元素之后去一个元素时，因此异常。

你还要检查数组b的长度。如果数组b的长度小于a，则最终会遇到相同的异常。

int maxlength = Math.min( this.length, b.length );更合适。

或者如果您不想在添加时错过任何一个数组中的任何元素，ArrayList就是您的最佳选择。 ArrayList是您正在寻找的自扩展阵列。这是你如何做到的 -

    // 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

如何扩展阵列？

如果需要可变大小的数据结构，请不要使用数组。 Use Lists

Answer 3

maxlength是a []和b []大小之间的最大值，所以在从0到maxlength的循环中，当i超过a的 min 大小时，你将得到一个ArrayIndexOutOfBoundsException。 []和b []。

试试这个：

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

这个怎么样：

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];
    }
}

另一个版本：

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]);
        }
    }
}

编辑：这是完整的课程，其中包含来自评论数据的示例

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());

    }
}

示例运行：

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

Answer 5

尝试更换：

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

使用：

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

尝试添加两个int数组时出现“ArrayIndexOutOfBoundsException”错误

5 个答案: