Java 无法打印ArrayList（代码中可能存在逻辑错误）

我正在用java创建一个MergeSort类来执行MergeSort算法。我尝试了多种方法打印出最终返回控制台的结果，但无论我做了什么，它都会打印出任何对象的gobbledeegook

这是我的伪代码（如果有任何逻辑错误，请告诉我）

这是我的实际代码：

import java.util.ArrayList;

public class MergeSort {
    public static void main(String[] args) {
        ArrayList<Object> List = new ArrayList<Object>();
        List.add(new Object[]{412, 491, 312, 265, 295, 253, 278});

        ArrayList<Object> Q = MergeSort.mergeSort(List);
        MergeSort.printArrayList(Q);
    }

    @SuppressWarnings("null")
    public static ArrayList<Object> merge(ArrayList<Object> A, ArrayList<Object> B) {
        ArrayList<Object> C = null;

        while (!A.isEmpty() && !B.isEmpty()) {
            if ((int) A.get(0) < (int) B.get(0)) {
                C.add(A.get(0));
                A.remove(0);
            } else {
                C.add(B.get(0));
                B.remove(0);
            }
        }

        return C;
    }

    public static ArrayList<Object> mergeSort(ArrayList<Object> A) {
        if (A.size() == 1) {
            return A;
        }

        ArrayList<Object> L = (ArrayList<Object>) A.subList(0, A.size() / 2);
        ArrayList<Object> R = (ArrayList<Object>) A.subList(A.size() / 2 + 1, A.size() + 1);

        ArrayList<Object> Q = merge(mergeSort(L), mergeSort(R));

        return Q;
    }

    public static void printArrayList(ArrayList<Object> Q) {
        Object[] P = new Object[Q.size()];
        Q.toArray(P);

        for (Object c : P) {
            System.out.print(c.toString() + " ");
        }
    }

}

import java.util.ArrayList；
公共类合并排序{
公共静态void main（字符串[]args）{
ArrayList=新建ArrayList（）；
添加（新对象[]{412491312265295253278}）；
ArrayList Q=MergeSort.MergeSort（列表）；
MergeSort.printarylist（Q）；
}
@抑制警告（“空”）
公共静态ArrayList合并（ArrayList A、ArrayList B）{
arraylistc=null；
而（！A.isEmpty（）&&！B.isEmpty（））{
如果（（int）A.get（0）<（int）B.get（0））{
C.添加（A.get（0））；
A.删除（0）；
}否则{
C.add（B.get（0））；
B.移除（0）；
}
}
返回C；
}
公共静态ArrayList合并排序（ArrayList A）{
如果（A.size（）==1）{
返回A；
}
ArrayList L=（ArrayList）A.subList（0，A.size（）/2）；
ArrayList R=（ArrayList）A.subList（A.size（）/2+1，A.size（）+1）；
ArrayList Q=合并（合并排序（L），合并排序（R））；
返回Q；
}
公共静态无效printArrayList（ArrayList Q）{
Object[]P=新对象[Q.size（）]；
Q.toArray（P）；
用于（对象c:P）{
System.out.print（c.toString（）+）；
}
}
}

任何帮助都将不胜感激（我对ArrayList或List不是很有经验）

这是我的新代码，我是根据你的建议得出的

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class MergeSort
{
public static void main(String[] args)
{
    List<Integer> list = new ArrayList<Integer>(); //(Arrays.asList(412, 491,  312, 265, 295, 253, 278));
    list.addAll(Arrays.asList(412,491,312,265,295,253,278));

    List<Integer> sortedList = MergeSort.mergeSort(list);
    MergeSort.printList(sortedList);
}

public static List<Integer> merge(List<Integer> firstHalf, List<Integer> secondHalf)
{
    List<Integer> mergedList = new ArrayList<>();

    while((!(firstHalf.size() == 0)) && (!(secondHalf.size() == 0)))
    {
        if((int)firstHalf.get(0) < (int)secondHalf.get(0))
        {
            mergedList.add(firstHalf.get(0));
            firstHalf.remove(0);
        }
        else
        {
            mergedList.add(secondHalf.get(0));
            secondHalf.remove(0);
        }
    }

    if(firstHalf.size() > 0)
    {
        for(Integer c : firstHalf)
        {
            mergedList.add(c);
        }
    }
    else
    {
        for(Integer c : secondHalf)
        {
            mergedList.add(c);
        }
    }



    return mergedList;
}

public static List<Integer> mergeSort(List<Integer> list)
{
    if(list.size() == 1)
    {
        return list;
    }

    List<Integer> firstHalf = list.subList(0, list.size() / 2);
    List<Integer> secondHalf = list.subList(list.size() / 2 + 1, list.size());

    List<Integer> sortedList = merge(mergeSort(firstHalf), mergeSort(secondHalf));

    return sortedList;
}

public static void printList(List<Integer> sortedList)
{
    for(Integer c : sortedList)
    {
        System.out.print(c.toString() + " ");
    }
}

}

import java.util.ArrayList；
导入java.util.List；
导入java.util.array；
公共类合并排序
{
公共静态void main（字符串[]args）
{
List List=newarraylist（）；/（Arrays.asList（412491312265295253278））；
addAll（Arrays.asList（41249131265295253278））；
List sortedList=MergeSort.MergeSort（列表）；
MergeSort.printList（sortedList）；
}
公共静态列表合并（列表上半部分，列表下半部分）
{
List mergedList=new ArrayList（）；
而（（！（firstHalf.size（）=0））和（！（secondHalf.size（）=0）））
{
if（（int）firstHalf.get（0）<（int）secondHalf.get（0））
{
mergedList.add（firstHalf.get（0））；
上半部分。移除（0）；
}
其他的
{
mergedList.add（secondHalf.get（0））；
后半部分。移除（0）；
}
}
if（firstHalf.size（）>0）
{
for（整数c:上半部分）
{
合并列表。添加（c）；
}
}
其他的
{
for（整数c:secondHalf）
{
合并列表。添加（c）；
}
}
返回合并列表；
}
公共静态列表合并排序（列表列表）
{
if（list.size（）==1）
{
退货清单；
}
List firstHalf=List.subList（0，List.size（）/2）；
List secondHalf=List.subList（List.size（）/2+1，List.size（））；
列表排序列表=合并（合并排序（上半部分），合并排序（下半部分））；
返回分类列表；
}
公共静态无效打印列表（列表分类列表）
{
for（整数c:sortedList）
{
System.out.print（c.toString（）+）；
}
}
}

我一直得到ConcurrentModificationException，但我没有使用任何线程。错误发生在第22、66和14行。在

时（（！（firstHalf.size（）=0））和（！（secondHalf.size（）=0））

再次寻求帮助我感到很难过，因为您的所有答案确实帮助了我，但我还没有弄明白这一点。

该方法返回一个新数组（因此您的

p

数组为空）。像这样的方法应该会奏效：

public static void printArrayList(ArrayList<Object> Q)
{
    for(Object c : Q)
    {
        System.out.print(c.toString() + " ");
    }
}

publicstaticvoidprintarylist（arraylistq）
{
对于（对象c:Q）
{
System.out.print（c.toString（）+）；
}
}

您正在用一个数组而不是一堆数字初始化

列表

变量。因此，最终会得到一个二维数组，如果这样做，您可以看到

System.out.println(Arrays.deepToString(P)); 

请像这样尝试：

List<Object> list = new ArrayList<Object>(Arrays.asList(412, 491, 312, 265, 295, 253, 278));

List List=newarraylist（Arrays.asList（412491312265295253278））；

这揭示了代码中的一系列其他问题，例如，您试图将

子列表（）返回的
列表
强制转换为
数组列表
，并且超出了
列表
的边界

将所有
ArrayList
引用变量改为
List
类型，并重新考虑有关索引的逻辑。
您应该更改数据结构

new Object[]{412, 491, 312, 265, 295, 253, 278} //this will return an array of objects

现在将其作为对象存储在列表中：

ArrayList<Object> List = new ArrayList<Object>();

下面是一些改进的代码：

1） 使用左侧的
List
而不是
ArrayList
：

List<Integer> list = new ArrayList<Integer>();

4） 初始化
列表
如下：

List<Integer> list = new ArrayList<Integer>();
list.addAll(Arrays.asList(412,491,312,265,295,253,278));

or
List<Integer> list = new ArrayList<Integer>(Arrays.asList(412,491,312,265,295,253,278));

您将获得
java.lang.IndexOutOfBoundsException

6） 您声明
列表C=null
；然后访问它
C.add（A.get（0））；
。在访问之前初始化列表

 List<Integer> C = new ArrayList<>();
 C.add(A.get(0));

listc=newarraylist（）；
C.添加（A.get（0））；
覆盖对象的toString（）方法？：）如果按原样打印列表，效果如何？系统输出打印项次（列表）？
List<Integer> list = new ArrayList<Integer>();

List<Integer> sortedList = MergeSort.mergeSort(list);

List<Integer> list = new ArrayList<Integer>();
list.addAll(Arrays.asList(412,491,312,265,295,253,278));

or
List<Integer> list = new ArrayList<Integer>(Arrays.asList(412,491,312,265,295,253,278));

list.subList(list.size() / 2 + 1, list.size() + 1);

 List<Integer> C = new ArrayList<>();
 C.add(A.get(0));