Java 显示偶数后跟所有奇数的步骤_Java

Java 显示偶数后跟所有奇数的步骤

java

Java 显示偶数后跟所有奇数的步骤,java,Java,下面写的代码是正确的，但我想缩短这段代码用java编写一个程序，在一维数组中输入10个数字，并以所有偶数后跟所有奇数的方式排列它们 // java code to segregate even odd // numbers in an array public class GFG { // Function to segregate even // odd numbers static void arrayEvenAndOdd( int arr[], in

下面写的代码是正确的，但我想缩短这段代码

用java编写一个程序，在一维数组中输入10个数字，并以所有偶数后跟所有奇数的方式排列它们

// java code to segregate even odd 
// numbers in an array 
public class GFG { 

// Function to segregate even 
// odd numbers 
static void arrayEvenAndOdd( 
            int arr[], int n) 
{ 

    int i = -1, j = 0; 
    while (j != n) { 
        if (arr[j] % 2 == 0) 
        { 
            i++; 

            // Swapping even and 
            // odd numbers 
            int temp = arr[i]; 
            arr[i] = arr[j]; 
            arr[j] = temp; 
        } 
        j++; 
    } 

    // Printing segregated array 
    for (int k = 0; k < n; k++) 
        System.out.print(arr[k] + " "); 
} 

// Driver code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 3, 2, 4, 7, 
                        6, 9, 10 }; 
    int n = arr.length; 
    arrayEvenAndOdd(arr, n); 
 } 
}

inta[]=newint[6]；
int b[]=新int[6]；
int i，j；
int k=0；
System.out.println（“输入数组”）；
对于（i=0；i<6；i++）{
a[i]=sc.nextInt（）；
}
对于（j=0；j<6；j++）{
如果（a[j]%2==0）{
b[k]=a[j]；
k++；
}
}
对于（j=0；j<6；j++）{
如果（a[j]%2！=0）{
b[k]=a[j]；
k++；
}
}
System.out.println（“输出”）；
对于（i=0；i<6；i++）{
系统输出println（b[i]）；
}

我能把偶数和奇数安排在一个for循环中而不是两个for循环中吗？我使用双for循环将偶数和奇数转换为

b[]

数组。请缩短代码。一个用于检查偶数的循环遍历，另一个用于检查奇数。

此代码将帮助您分离偶数和奇数

// java code to segregate even odd 
// numbers in an array 
public class GFG { 

// Function to segregate even 
// odd numbers 
static void arrayEvenAndOdd( 
            int arr[], int n) 
{ 

    int i = -1, j = 0; 
    while (j != n) { 
        if (arr[j] % 2 == 0) 
        { 
            i++; 

            // Swapping even and 
            // odd numbers 
            int temp = arr[i]; 
            arr[i] = arr[j]; 
            arr[j] = temp; 
        } 
        j++; 
    } 

    // Printing segregated array 
    for (int k = 0; k < n; k++) 
        System.out.print(arr[k] + " "); 
} 

// Driver code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 3, 2, 4, 7, 
                        6, 9, 10 }; 
    int n = arr.length; 
    arrayEvenAndOdd(arr, n); 
 } 
}

//分离奇偶的java代码
//数组中的数字
公共类GFG{
//均分功能
//奇数
静态空穴阵列奇数和奇数（
整数arr[]，整数n）
{ 
int i=-1，j=0；
而（j！=n）{
如果（arr[j]%2==0）
{ 
i++；
//交换偶数和
//奇数
int temp=arr[i]；
arr[i]=arr[j]；
arr[j]=温度；
} 
j++；
} 
//打印隔离阵列
对于（int k=0；k

此代码将帮助您分离偶数和奇数

// java code to segregate even odd 
// numbers in an array 
public class GFG { 

// Function to segregate even 
// odd numbers 
static void arrayEvenAndOdd( 
            int arr[], int n) 
{ 

    int i = -1, j = 0; 
    while (j != n) { 
        if (arr[j] % 2 == 0) 
        { 
            i++; 

            // Swapping even and 
            // odd numbers 
            int temp = arr[i]; 
            arr[i] = arr[j]; 
            arr[j] = temp; 
        } 
        j++; 
    } 

    // Printing segregated array 
    for (int k = 0; k < n; k++) 
        System.out.print(arr[k] + " "); 
} 

// Driver code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 3, 2, 4, 7, 
                        6, 9, 10 }; 
    int n = arr.length; 
    arrayEvenAndOdd(arr, n); 
 } 
}

//分离奇偶的java代码
//数组中的数字
公共类GFG{
//均分功能
//奇数
静态空穴阵列奇数和奇数（
整数arr[]，整数n）
{ 
int i=-1，j=0；
而（j！=n）{
如果（arr[j]%2==0）
{ 
i++；
//交换偶数和
//奇数
int temp=arr[i]；
arr[i]=arr[j]；
arr[j]=温度；
} 
j++；
} 
//打印隔离阵列
对于（int k=0；k

这是一个简单的程序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author Momir Sarac
 */
public class GroupByEvenAndOddNumbers {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // create a collection
        List<Integer> listOfNumbers = new ArrayList<>();
        // do code within a loop for 10 times
        for(int i=0;i<10;i++)
        {
            //print to screen this text
            System.out.println("Input your number:");
            //get next input integer
            int number = scanner.nextInt();
            // add it to collection
            listOfNumbers.add(number);
        }
        // sort this collection, list of numbers
        // convert all numbers(positive and negative ) within to 0 or 1 depending whether or not they are even or odd and sort them accordignaly.
        Collections.sort(listOfNumbers, Comparator.comparingInt(n -> Math.floorMod(n, 2)));
        //print sorted collection
        System.out.println("Ordered list ..." + listOfNumbers);
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
导入java.util.Scanner；
/**
*
*@作者莫米尔·萨拉克
*/
公共类GroupByEven和OddNumber{
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
//创建一个集合
List listofNumber=new ArrayList（）；
//在循环中编码10次
对于（int i=0；i Math.floorMod（n，2））；
//打印已排序的集合
System.out.println（“有序列表…”+编号列表）；
}
}

这是一个简单的程序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author Momir Sarac
 */
public class GroupByEvenAndOddNumbers {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // create a collection
        List<Integer> listOfNumbers = new ArrayList<>();
        // do code within a loop for 10 times
        for(int i=0;i<10;i++)
        {
            //print to screen this text
            System.out.println("Input your number:");
            //get next input integer
            int number = scanner.nextInt();
            // add it to collection
            listOfNumbers.add(number);
        }
        // sort this collection, list of numbers
        // convert all numbers(positive and negative ) within to 0 or 1 depending whether or not they are even or odd and sort them accordignaly.
        Collections.sort(listOfNumbers, Comparator.comparingInt(n -> Math.floorMod(n, 2)));
        //print sorted collection
        System.out.println("Ordered list ..." + listOfNumbers);
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
导入java.util.Scanner；
/**
*
*@作者莫米尔·萨拉克
*/
公共类GroupByEven和OddNumber{
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
//创建一个集合
List listofNumber=new ArrayList（）；
//在循环中编码10次
对于（int i=0；i Math.floorMod（n，2））；
//打印已排序的集合
System.out.println（“有序列表…”+编号列表）；
}
}

由于您没有任何要求，偶数和奇数本身必须在其各自的一半数组中排序，因此您可以在输入它们时将它们分配到其关联的数组部分。因此，您只需要使用两个“计数器”变量，一个用于左边，从零开始递增，另一个用于右边，从数组长度减去1开始递减。然后你可以添加你的数字，检查一个是偶数，一个是偶数，一个是奇数，一个是偶数，一个是奇数，一个是奇数，一个是奇数，一个是奇数，一个是奇数。在循环中执行此操作，直到左侧计数器大于右侧计数器。我创建了一个简单的示例，在将字符串解析为int时，我没有检查

NumberFormatException

：

import java.util.Arrays;
import java.util.Scanner;

public class SortedArrayInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter length of array: ");
        final int arrayLength = Integer.parseInt(scanner.nextLine());

        int intArray[] = new int[arrayLength];
        for (int l = 0, r = arrayLength - 1; l <= r; ) {
            System.out.print("Enter new array value: ");
            int v = Integer.parseInt(scanner.nextLine());
            intArray[v % 2 == 0 ? l++ : r--] = v;
        }

        System.out.println("Output: " + Arrays.toString(intArray));
    }
}

由于您不要求奇数和偶数本身必须在各自的一半数组中排序，因此您可以在输入它们的同时将它们分配到关联的数组部分。因此，您只需要使用两个“计数器”变量，一个用于左边，从零开始递增，另一个用于右边，从数组长度减去1开始递减。然后你可以添加你的数字，检查一个是偶数，一个是偶数，一个是奇数，一个是偶数，一个是奇数，一个是奇数，一个是奇数，一个是奇数，一个是奇数。在循环中执行此操作，直到左侧计数器大于右侧计数器。我创建了一个简单的示例，在将字符串解析为int时，我没有检查

NumberFormatException

：

import java.util.Arrays;
import java.util.Scanner;

public class SortedArrayInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter length of array: ");
        final int arrayLength = Integer.parseInt(scanner.nextLine());

        int intArray[] = new int[arrayLength];
        for (int l = 0, r = arrayLength - 1; l <= r; ) {
            System.out.print("Enter new array value: ");
            int v = Integer.parseInt(scanner.nextLine());
            intArray[v % 2 == 0 ? l++ : r--] = v;
        }

        System.out.println("Output: " + Arrays.toString(intArray));
    }
}

在这个版本中，它将偶数复制到开头，将奇数复制到结尾

static int[] sortEvenOdd(int... nums) {
    int even = 0, odd = nums.length, ret[] = new int[nums.length];
    for (int num : nums)
        if (num % 2 == 0)
            ret[even++] = num;
        else
            ret[--odd] = num;
    return ret;
}

public static void main(String[] args) {
    int[] arr = {1, 3, 2, 4, 7, 6, 9, 10};
    int[] sorted = sortEvenOdd(arr);
    System.out.println(Arrays.toString(sorted));
}

印刷品

[2, 4, 6, 10, 9, 7, 3, 1]

在这个版本中，它将偶数复制到开头，将奇数复制到结尾

static int[] sortEvenOdd(int... nums) {
    int even = 0, odd = nums.length, ret[] = new int[nums.length];
    for (int num : nums)
        if (num % 2 == 0)
            ret[even++] = num;
        else
            ret[--odd] = num;
    return ret;
}

public static void main(String[] args) {
    int[] arr = {1, 3, 2, 4, 7, 6, 9, 10};
    int[] sorted = sortEvenOdd(arr);
    System.out.println(Arrays.toString(sorted));
}

印刷品

[2, 4, 6, 10, 9, 7, 3, 1]

我建议你阅读流，它们会让你更容易处理收集

List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        numbers.add(6);
        numbers.add(7);
        numbers.add(8);
        numbers.add(9);
        numbers.add(0);

        //this way you simply traverse the numbers twice and output the needed ones
        System.out.println(numbers.stream()
                .filter(x->x%2==0)
                .collect(Collectors.toList()));
        System.out.println(numbers.stream()
                .filter(x->x%2==1)
                .collect(Collectors.toList()));

        //this way you can have the numbers in two collections
        numbers.forEach(x-> x%2==0? addItToEvenCollection : addItToOddCollection);

        //this way you will have a map at the end. The boolean will tell you if the numbers are odd or even, 
        // and the list contains the numbers, in order of apparition in the initial list
        numbers.stream().collect(Collectors.groupingBy(x->x%2==0));

List number=new ArrayList（）；
增加（1）；
增加（2）；