Java 如何将数组方法转换为ArrayList方法？

如何更改以下方法以使用ArrayList？ 我是这样想的：

public static boolean sortArrayList(ArrayList<Integer> list) {
    return false;
}

公共静态布尔排序列表（ArrayList列表）{
返回false；
}

但我不知道如何完成它

以下是我尝试将使用数组转换为使用ArrayList的方法：

public static boolean sortArrayList(final int[] data) {
    for(int i = 1; i < data.length; i++) {
        if(data[i-1] > data[i]) {
            return false;
        }
    }
    return true;
}

公共静态布尔排序列表（最终int[]数据）{
对于（int i=1；i数据[i]）{
返回false；
}
}
返回true；
}

公共静态布尔排序列表（最终数组列表数据）{
对于（int i=1；idata.get（i））{
返回false；
}
}
返回true；
}

对于@Sanj给出的公认答案，我有一些问题：（a）它不处理列表中的空值，（B）它不必要地专门化为

数组列表，因为它很容易被
Iterable
，以及（C）方法名称具有误导性

注：对于（A），很可能获得NPE是合适的-OP没有说。对于演示代码，我假设空值是可忽略的。其他解释也是公平的，例如null始终是“最小”值（需要不同的编码，LAAEFTR）。无论如何，行为应该是JavaDoc'ed——我在演示中没有这样做#8>P

注意：对于（B），保持专用版本可能会提高运行时性能，因为方法“知道”支持数据在数组中，编译器可能会使用
Iterable
提取版本上的一些运行时效率，但这种说法对我来说似乎是可疑的，而且在任何情况下，我希望看到基准测试结果来支持这种做法同样即使是版本I演示也可以使用通用元素类型进一步抽象（而仅限于
整数
）。这种方法可能有如下定义：

public static <T extends Comparable<T>> boolean isAscendingOrder(final Iterable<T> sequence)


import java.util.ArrayList；
公共类排序
{
公共静态布尔isAscendingOrder（最终Iterable序列）
{
整数prev=null；
用于（最终整数扫描：序列）
{
if（prev==null）
{
prev=扫描；
}
其他的
{
如果（扫描！=null）
{
如果（上一次比较（扫描）>0）
{
返回false；
}
prev=扫描；
}
}
}
返回true；
}
公共静态布尔排序列表（最终ArrayList数据）
{
对于（int i=1；idata.get（i））
{
返回false；
}
}
返回true；
}
专用静态ArrayList createArrayList（最终整数…VAL）
{
final ArrayList rval=新的ArrayList（）；
用于（最终整数x:VAL）
{
rval.add（x）；
}
返回rval；
}
公共静态void main（最终字符串[]args）
{
final ArrayList listEmpty=createArrayList（）；
最终ArrayList listSingleton=createArrayList（2）；
最终ArrayList升序=createArrayList（2,5,8,10）；
最终ArrayList listPlatuea=createArrayList（2,5,5,10）；
最终ArrayList listMixedUp=createArrayList（2,5,3,10）；
最终ArrayList listWithNull=createArrayList（2,5,8,null）；
系统输出打印（isAscendingOrder（listEmpty）+“，”；
系统输出打印（isAscendingOrder（listSingleton）+“，”；
系统输出打印（isAscendingOrder（列表升序）+“，”；
系统输出打印（isAscendingOrder（listPlatuea）+“，”；
系统输出打印（isAscendingOrder（listMixedUp）+“，”；
系统输出打印（isAscendingOrder（listWithNull）+“\n”）；
System.out.println（“-----------------------------------------”；
System.out.print（sortArrayList（listEmpty）+“，”；
System.out.print（SortaryList（listSingleton）+“，”；
系统输出打印（排序列表（升序）+“，”；
系统输出打印（Sortarray列表（listPlatuea）+“，”；
系统输出打印（Sortarray列表（listMixedUp）+“，”；
System.out.print（sortArrayList（listWithNull）+“\n”）；
}
}
尝试下面的函数，它获取
整数数组
并将其转换为
数组列表
，然后计算结果：

public static boolean sortArrayList(final int[] data) {
        List<Integer> aList = new ArrayList<Integer>();
        for (int index = 0; index < data.length; index++)
            aList.add(data[index]);

        for (int i = 1; i < aList.size(); i++) {
            if (aList.get(i - 1) > aList.get(i)) {
                return false;
            }
        }
        return true;
    }

公共静态布尔排序列表（最终int[]数据）{
列表列表=新的ArrayList（）；
for（int index=0；indexaList.get（i））{
返回false；
}
}
返回true；
}
由于您的sortArrayList方法不会对ArrayList进行排序，因此您可能希望将其重命名为类似IsAsortArrayList的名称您的方法名称！从字面上看，它不会再误导人了。
true, true, true, true, false, true
------------------------------------
true, true, true, true, false, 
Exception in thread "main" java.lang.NullPointerException
    at SortCheck.sortArrayList(SortCheck.java:35)
    at SortCheck.main(SortCheck.java:78)

import java.util.ArrayList;

public class SortCheck
{
    public static boolean isAscendingOrder(final Iterable<Integer> sequence)
    {
        Integer prev = null;
        for (final Integer scan : sequence)
        {
            if (prev == null)
            {
                prev = scan;
            }
            else
            {
                if (scan != null)
                {
                    if (prev.compareTo(scan) > 0)
                    {
                        return false;
                    }

                    prev = scan;
                }
            }
        }

        return true;
    }

    public static boolean sortArrayList(final ArrayList<Integer> data)
    {
        for (int i = 1; i < data.size(); i++)
        {
            if (data.get(i - 1) > data.get(i))
            {
                return false;
            }
        }
        return true;
    }

    private static ArrayList<Integer> createArrayList(final Integer... vals)
    {
        final ArrayList<Integer> rval = new ArrayList<>();

        for(final Integer x : vals)
        {
            rval.add(x);
        }

        return rval;
    }

    public static void main(final String[] args)
    {
        final ArrayList<Integer> listEmpty     = createArrayList();
        final ArrayList<Integer> listSingleton = createArrayList(2);
        final ArrayList<Integer> listAscending = createArrayList(2, 5, 8, 10  );
        final ArrayList<Integer> listPlatuea   = createArrayList(2, 5, 5, 10  );
        final ArrayList<Integer> listMixedUp   = createArrayList(2, 5, 3, 10  );
        final ArrayList<Integer> listWithNull  = createArrayList(2, 5, 8, null);

        System.out.print(isAscendingOrder(listEmpty    ) + ", ");
        System.out.print(isAscendingOrder(listSingleton) + ", ");
        System.out.print(isAscendingOrder(listAscending) + ", ");
        System.out.print(isAscendingOrder(listPlatuea  ) + ", ");
        System.out.print(isAscendingOrder(listMixedUp  ) + ", ");
        System.out.print(isAscendingOrder(listWithNull ) + "\n");

        System.out.println("------------------------------------");

        System.out.print(sortArrayList(listEmpty    ) + ", ");
        System.out.print(sortArrayList(listSingleton) + ", ");
        System.out.print(sortArrayList(listAscending) + ", ");
        System.out.print(sortArrayList(listPlatuea  ) + ", ");
        System.out.print(sortArrayList(listMixedUp  ) + ", ");
        System.out.print(sortArrayList(listWithNull ) + "\n");
    }
}

public static boolean sortArrayList(final int[] data) {
        List<Integer> aList = new ArrayList<Integer>();
        for (int index = 0; index < data.length; index++)
            aList.add(data[index]);

        for (int i = 1; i < aList.size(); i++) {
            if (aList.get(i - 1) > aList.get(i)) {
                return false;
            }
        }
        return true;
    }