Java泛型列表多线程排序实现遇ArrayStoreException错误求助

报错根因 #

Exception in thread "main" java.lang.ArrayStoreException: arraycopy: source type java.util.ArrayList is not an array

System.arraycopy() 仅支持数组类型参数，你传入的是ArrayList集合对象，类型不匹配触发报错。除此之外你的代码还存在排序泛型约束缺失、线程未传入待排序列表、未等待线程执行完成就返回、没有实现有序列表合并逻辑、排序对象未实现比较接口的问题，完整修改方案如下：

完整修改代码 #

1. 定义SortingThread线程类 #

import java.util.ArrayList;

// 泛型约束：要排序的元素必须实现Comparable比较接口
class SortingThread<T extends Comparable<T>> extends Thread {
    private ArrayList<T> sortList;

    // 构造方法传入待排序列表
    public SortingThread(ArrayList<T> sortList) {
        this.sortList = sortList;
    }

    // 对外返回排序后的列表
    public ArrayList<T> getSortedResult() {
        return sortList;
    }

    @Override
    public void run() {
        sortList.sort(null);
    }
}

2. 修正Tools类逻辑 #

class Complex implements Comparable<Complex> {
    private double real;
    private double imaginary;

    public Complex(double real, double imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    // 自定义复数排序规则：按模长排序，可根据需求调整
    @Override
    public int compareTo(Complex o) {
        double modSelf = Math.sqrt(real*real + imaginary*imaginary);
        double modOther = Math.sqrt(o.real*o.real + o.imaginary*o.imaginary);
        return Double.compare(modSelf, modOther);
    }

    @Override
    public String toString() {
        return real + "+" + imaginary + "i";
    }
}

public class Tools {
    public static <T extends Comparable<T>> ArrayList<T> parallelSort(ArrayList<T> arr){
        int mid = arr.size() / 2;
        // 拆分列表，subList生成新片段不会修改原列表
        ArrayList<T> firstHalf = new ArrayList<>(arr.subList(0, mid));
        ArrayList<T> secondHalf = new ArrayList<>(arr.subList(mid, arr.size()));

        // 初始化线程并传入待排序片段
        SortingThread<T> thread1 = new SortingThread<>(firstHalf);
        SortingThread<T> thread2 = new SortingThread<>(secondHalf);
        thread1.start();
        thread2.start();

        try {
            // 等待两个线程排序完成再合并
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }

        // 合并两个有序列表
        return mergeSortedLists(firstHalf, secondHalf);
    }

    // 双指针合并两个有序列表的辅助方法
    private static <T extends Comparable<T>> ArrayList<T> mergeSortedLists(ArrayList<T> list1, ArrayList<T> list2) {
        ArrayList<T> result = new ArrayList<>(list1.size() + list2.size());
        int i = 0, j = 0;
        while (i < list1.size() && j < list2.size()) {
            if (list1.get(i).compareTo(list2.get(j)) <= 0) {
                result.add(list1.get(i++));
            } else {
                result.add(list2.get(j++));
            }
        }
        // 补充剩余元素
        while (i < list1.size()) result.add(list1.get(i++));
        while (j < list2.size()) result.add(list2.get(j++));
        return result;
    }

    public static <T> boolean areEqual(ArrayList<T> arr1, ArrayList<T> arr2) {
        return arr1.equals(arr2);
    }

    public static void main(String[] args) {
        //测试用例不变
        Complex c1= new Complex(3,4);
        Complex c2= new Complex(2,2);
        Complex c3= new Complex(1,2);
        ArrayList<Complex> a1= new ArrayList<>();
        a1.add(c1);
        a1.add(c2);
        a1.add(c3);

        System.out.println("原列表：");
        System.out.println(a1);
        System.out.println("排序后列表：");
        System.out.print(Tools.parallelSort(a1));
    }
}

内容的提问来源于stack exchange，提问作者rana bacha