为什么我的Java方法需要一个不存在的int[0]？_Java_Arrays_Recursion

为什么我的Java方法需要一个不存在的int[0]？

java arrays recursion

为什么我的Java方法需要一个不存在的int[0]？,java,arrays,recursion,Java,Arrays,Recursion,下面是我合并两个排序数组的方法： public static int[] AddString(int[] a, int[] b, int pos, int n){ if(n > 1){ if(a[0] > b[0] && !(a.length == 0)){ c[pos] = b[0]; b = Arrays.copyOfRange(b, 1, b.length); }else{

下面是我合并两个排序数组的方法：

public static int[] AddString(int[] a, int[] b, int pos, int n){

    if(n > 1){
        if(a[0] > b[0] && !(a.length == 0)){
            c[pos] = b[0];
            b = Arrays.copyOfRange(b, 1, b.length);
        }else{
            c[pos] = a[0];
            a = Arrays.copyOfRange(a, 1, a.length);
        }
        AddString(a, b, pos + 1, n - 1);
    }
    return c;
}

我需要合并两个排序数组。以下是阵列：

static int[] c = new int[String1.length + String2.length];
static int[] array1 = new int[]{2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
static int[] array2 = new int[]{2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};

用于调用AddString的行：

System.out.println(Arrays.toString(AddString(String1, String2, 0, n)));

现在，我的应用程序返回以下错误：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
at com.company.Main.AddString(Main.java:21)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.AddString(Main.java:28)
at com.company.Main.main(Main.java:14)

我知道这是因为我的应用程序使用的是一个不存在的数组索引，但我不知道在哪里会发生这种情况。当array1为空时会出现问题。有人能帮我吗？

a[0]>b[0]&！（a.length==0）

导致越界异常

在检查任何长度值之前，首先访问

a[0]

，然后访问

b[0]

相反，您可能需要

a.length>0&&b.length>0&&a[0]>b[0]

请注意，java支持短路：

在破译了你到底想做什么之后，你就相当接近于完成它了

这里有几种不同的方法来合并这两个排序的数组

1. 您的实现修复了一点，递归的

public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

2. 也是递归的

public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

int[]合并（int[]a，int[]b）
{
返回合并（a，0，b，0，新int[a.length+b.length]，0）；
}
int[]合并（int[]a，int[]a计数器，int[]b，int[]b计数器，int[]out，int out计数器）
{
if（aCounter


3.
非递归
public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

int[] merge(int[] a, int[] b)
{
    int[] out = new int[a.length + b.length]; //out array large enough for both contents
    int ac = 0; //a index counter
    int bc = 0; //b index counter
    int outc = 0; //out index counter

    //merge until one array is fully used up
    while(ac < a.length && bc < b.length)
        out[outc++] = a[ac] < b[bc] ? a[ac++] : b[bc++];

    //add the remaining elements to out
    while(ac < a.length)
        out[outc++] = a[ac++];
    while(bc < b.length)
        out[outc++] = b[bc++];

    //return the merged array
    return out;
}

int[]合并（int[]a，int[]b）
{
int[]out=new int[a.length+b.length]；//out数组足够大，可以容纳两个内容
int ac=0；//索引计数器
int bc=0；//b索引计数器
int-outc=0；//输出索引计数器
//合并，直到一个数组完全用完
而（ac
a[0]>b[0]&！（a.length==0）
导致越界异常
在检查任何长度值之前，首先访问a[0]
，然后访问b[0]

相反，您可能需要a.length>0&&b.length>0&&a[0]>b[0]

请注意，java支持短路：

在破译了你到底想做什么之后，你就相当接近于完成它了
这里有几种不同的方法来合并这两个排序的数组
1.
您的实现修复了一点，递归的
public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

2.
也是递归的
public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

int[]合并（int[]a，int[]b）
{
返回合并（a，0，b，0，新int[a.length+b.length]，0）；
}
int[]合并（int[]a，int[]a计数器，int[]b，int[]b计数器，int[]out，int out计数器）
{
if（aCounter

3.
非递归
public static int[] merge(int[] a, int[] b, int pos, int n)
{
    if(n > 1) //expecting a or b to have an element
        if(a.length > 0)
            if(b.length > 0)
                if(a[0] > b[0]) //a and b have elements
                {
                    c[pos] = b[0];
                    b = Arrays.copyOfRange(b, 1, b.length);
                }
                else
                {
                    c[pos] = a[0];
                    a = Arrays.copyOfRange(a, 1, a.length);
                }
            else //b has no elements, a does
            {
                c[pos] = a[0];
                a = Arrays.copyOfRange(a, 1, a.length);
            }
        else //a has no elements
            if(b.length > 0)
            {
                c[pos] = b[0];
                b = Arrays.copyOfRange(b, 1, b.length);
            }

        merge(a, b, pos + 1, n - 1);
    }

    return c;
}

int[] merge(int[] a, int[] b)
{
    return merge(a, 0, b, 0, new int[a.length + b.length], 0);
}

int[] merge(int[] a, int aCounter, int[] b, int bCounter, int[] out, int outCounter)
{
    if(aCounter < a.length && bCounter < b.length) //both arrays have elements
        if(a[aCounter] < b[bCounter])
        {
            out[outCounter] = a[aCounter];
            return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
        }
        else
        {
            out[outCounter] = b[bCounter];
            return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
        }

    if(aCounter < a.length) //only a has elements
    {
        out[outCounter] = a[aCounter];
        return merge(a, aCounter + 1, b, bCounter, out, outCounter + 1);
    }

    if(bCounter < b.length) //only b has elements
    {
        out[outCounter] = b[bCounter];
        return merge(a, aCounter, b, bCounter + 1, out, outCounter + 1);
    }

    //no more elements
    return out;
}

int[] merge(int[] a, int[] b)
{
    int[] out = new int[a.length + b.length]; //out array large enough for both contents
    int ac = 0; //a index counter
    int bc = 0; //b index counter
    int outc = 0; //out index counter

    //merge until one array is fully used up
    while(ac < a.length && bc < b.length)
        out[outc++] = a[ac] < b[bc] ? a[ac++] : b[bc++];

    //add the remaining elements to out
    while(ac < a.length)
        out[outc++] = a[ac++];
    while(bc < b.length)
        out[outc++] = b[bc++];

    //return the merged array
    return out;
}

int[]合并（int[]a，int[]b）
{
int[]out=new int[a.length+b.length]；//out数组足够大，可以容纳两个内容
int ac=0；//索引计数器
int bc=0；//b索引计数器
int-outc=0；//输出索引计数器
//合并，直到一个数组完全用完
而（ac
Array3 BTW:static int[]c=new int[String1.length+String2.length]；你试过使用调试器吗？@LouisWasserman我不擅长使用调试器，但我知道当array1为空时会发生错误，并且该方法仍试图将其减少。@Mike，因此了解如何使用调试器a调试器很有用，但很多打印语句也可以帮助Array3 BTW:static int[]c=new int[String1.length+String2.length]；你试过使用调试器吗？@LouisWasserman我对调试器不太在行，但我知道当array1为空时会发生错误，而该方法仍试图将其减少。@Mike，因此了解如何使用调试器a调试器很有用，但很多打印语句也会有所帮助。谢谢你的回复，我明白你的意思，但当我使用那段代码时，我仍然会收到相同的错误消息。@Mike同一行中有相同的错误吗？或者你在另一条线上越界了？您可能还希望查看c[pos]
，并可能添加if（pos
或类似内容。还要注意，您可能在else块中调用a[0]
，这可能是由于a
为空造成的。我补充说，您是对的