用Lambda表达式进行Java排序

我是Java新手，这可能是一个愚蠢的问题。 我看的是905年。在Leetcode上按奇偶校验对数组排序。解决办法之一是

class Solution {
    public int[] sortArrayByParity(int[] A) {
        Integer[] B = new Integer[A.length];
        for (int t = 0; t < A.length; ++t)
            B[t] = A[t];

        Arrays.sort(B, (a, b) -> Integer.compare(a%2, b%2));

        for (int t = 0; t < A.length; ++t)
            A[t] = B[t];
        return A;

        /* Alternative:
        return Arrays.stream(A)
                     .boxed()
                     .sorted((a, b) -> Integer.compare(a%2, b%2))
                     .mapToInt(i -> i)
                     .toArray();
        */
    }
}

它是如何对数组进行精确排序的？a和b来自哪里？

您正在调用，其中

T

由编译器解析为

Integer

，这意味着lambda表达式必须实现方法

a

和

b

是该方法的两个参数。这就是工作原理，您必须命名（并可选地键入）的抽象方法的形式参数。

• 对于面试，您应该尽可能避免使用Java的专用方法

• 您可以使用这个解决方案，它非常简单易懂，并且便于面试

可接受的解决方案：

类解决方案{
公共int[]SortaryByParity（int[]A）{
int左=0；
int right=A.length-1；
while（左<右）{
如果（A[左]%2==0）
左++；
否则{
如果（A[右]%2！=0）
对--；
如果（A[右]%2==0）{
交换（A、左、右）；
左++；
对--；
}
}
}
返回A；
}
私有无效交换（int[]nums，int左，int右）{
int temp=nums[左]；
nums[左]=nums[右]；
nums[右]=温度；
}
}

---

类解决方案{
公共int[]SortaryByParity（int[]A）{
int左=0；
int right=A.length-1；
while（左<右）{
如果（（A[左]&1）==0）
左++；
否则{
如果（（A[右]&1）！=0）
对--；
如果（（A[右]&1）==0）{
交换（A、左、右）；
左++；
对--；
}
}
}
返回A；
}
私有无效交换（int[]nums，int左，int右）{
int temp=nums[左]；
nums[左]=nums[右]；
nums[右]=温度；
}
}

---

工具书类

• 有关其他详细信息，请参见。在讨论板中，有许多公认的解决方案、解释、使用各种语言的高效算法以及时间/空间复杂性分析

排序 Java方法将数组

B

作为输入，并根据数组元素的

compare（a，B）

方法对其进行排序。因此，如果数组存储整数对象，它将根据

Integer对它们进行排序。默认情况下，比较（a，b）

。这只是按递增顺序对整数排序

比较器 Java有一个接口，它定义了一个名为

compare（a，b）

的方法。如果（a==b），此方法返回零；如果（ab），则返回正值。比较器接口通常用于排序方法或有序数据结构，如

兰姆达 现在，由于这个问题要求定制排序顺序，您需要提供一个定制的

compare（a，b）

方法。幸运的是，有一个重载版本的允许您通过提供lambda方法来实现这一点。lambda只是一个内联函数。在这种情况下，它为排序提供所需的比较逻辑。在您的示例中，

（a，b）->

是lambda函数的输入，由sort方法提供。这是标准的lambda语法。排序将在数组B上运行

mergesort

算法，使用lambda比较方法确定每对数字的排序方式

按奇偶性排序

整数。比较（a%2，b%2）

根据整数a和b的最低有效位对其排序

%

是模运算符（除法后的余数）。如果a是偶数，

a%2

返回0。如果a是奇数，

a%2

返回1。很好地解释了为什么这个操作会按奇偶校验对数字进行排序，但这并不是很明显。你解决的问题越多，你学到的捷径就越多

工具书类 以下是一些提供更多信息的SO线程：

“a和b来自哪里？”它们被声明为int

（a，b）->……

部分。您可能需要熟悉lambdas及其语法。好文章之一：

Arrays.sort(B, (a, b) -> Integer.compare(a%2, b%2));

class Solution {
    public int[] sortArrayByParity(int[] A) {
        int left = 0;
        int right = A.length - 1;

        while (left < right) {
            if (A[left] % 2 == 0)
                left++;

            else {
                if (A[right] % 2 != 0)
                    right--;

                if (A[right] % 2 == 0) {
                    swap(A, left, right);
                    left++;
                    right--;
                }
            }
        }

        return A;
    }

    private void swap(int[] nums, int left, int right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }
}

class Solution {
    public int[] sortArrayByParity(int[] A) {
        int left = 0;
        int right = A.length - 1;

        while (left < right) {
            if ((A[left] & 1) == 0)
                left++;

            else {
                if ((A[right] & 1) != 0)
                    right--;

                if ((A[right] & 1) == 0) {
                    swap(A, left, right);
                    left++;
                    right--;
                }
            }
        }

        return A;
    }

    private void swap(int[] nums, int left, int right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }
}