Java 如何跳过某些数组索引？

只需要对数组中的奇数值进行排序，但偶数值必须保留在它们的位置上

这是我的密码：

public static int[] sortArray(int[] array) {

    int length = array.length;
    int temp = 0;


    for (int i = 0; i < length; i++) {
        for (int j = 1; j < length - i; j++) {
            if (j > 0 && array[j] % 2 == 0)continue;

                if (array[j - 1] > array[j]){
                    temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                }
            }
        }

    return array;
}

公共静态int[]数组（int[]数组）{
int length=array.length；
内部温度=0；
for（int i=0；i0&&array[j]%2==0）继续；
if（数组[j-1]>数组[j]）{
温度=阵列[j-1]；
数组[j-1]=数组[j]；
数组[j]=温度；
}
}
}
返回数组；
}

输入：

newint[]{5,3,2,8,1,4,0}

输出：

[1,3,5,2,8,4,0]

但是我需要：

[1,3,2,8,5,4,0]

如何跳过数组中的某些索引

---

我认为这应该与

continue

操作符连接，但我不知道如何操作。

在我看来，这段代码在逻辑上是错误的。 因为如果你用这个代码切换号码

temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;

你不能保留偶数的位置

---

只搜索数组中的奇数，然后对奇数进行排序怎么样？

对于气泡排序这样的简单算法，您只需使用

继续
忽略偶数值即可

for(int i=0; i<ar.length; i++) {
    if(ar[i] % 2 == 0) continue;
    for(int j=i; j<ar.length; j++) {
        if(ar[j] % 2 == 0) continue;

        if(ar[i] > ar[j]) {
        int temp = ar[i];
        ar[i] = ar[j];
        ar[j] = temp;
    }
}

对于（int i=0；i使用以下代码：

public static int[] sortArray(int[] array) {

    int length = array.length;

    for (int i = 0; i < length - 1; i++) {
        int k = -1; // The index of last odd element
        for (int j = 0; j < length - i; j++)
            if (array[j] % 2 != 0) {
                if (k >= 0 && array[k] > array[j]) {
                    int temp = array[k];
                    array[k] = array[j];
                    array[j] = temp;
                }
                k = j;
            }
    }

    return array;
}

公共静态int[]数组（int[]数组）{
int length=array.length；
对于（int i=0；i=0&&array[k]>array[j]）{
int temp=数组[k]；
数组[k]=数组[j]；
数组[j]=温度；
}
k=j；
}
}
返回数组；
}
只是为了好玩：

与Lamda和Stream合作；-）

导入java.util.array；
公共类IntSort{
公共静态void main（字符串[]args）{
int[]数组=新的int[]{5,3,2,8,1,4,0}；
SortonlyAddressemaineven（数组）；
System.out.println（array.toString（array））；
}
公共静态无效SortonlyAddressMainEvent（int[]数组）{
//获取已排序奇数的列表
int[]odd=Arrays.stream（array）.filter（x->x%2！=0）.sorted（）.toArray（）；
int c=0；
for（int i=0；i
另一种可能的解决方案是将原始数组包装在
OddArray
类中，这使得底层原始数组看起来只包含奇数项。比如：

class OddArray {

  int[] baseArray;

  // Constructor
  OddArray(int[] base) {
    this.baseArray = base;
  }

  // Getter
  public int get(int index) {
    return baseArray[2 * index + 1];  // Odd entries only.
  }

  // Setter
  public void set(int index, int value) {
    baseArray[2 * index + 1] = value;  // Odd entries only.
  }

  // Return changed baseArray.
  public int[] getBaseArray() {
    return baseArray;
  }

} // end class OddArray

这需要添加一些错误检查等，但它隐藏了所有偶数位置，允许您将数组视为仅存在奇数位置并编号为0、1、2、。。。数组排序后，调用
OddArray.getBaseArray（）
检索整个数组。
另一个带有流的答案：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

class IntSort {

    public static void main(String[] args) {
        int[] array = new int[]{5, 3, 2, 8, 1, 4, 0};
        final int[] result = sortOnlyOddRemainEven(array);
    }

    public static int[] sortOnlyOddRemainEven(int[] array) {
        final LinkedList<Integer> collect;
        collect = Arrays.stream(array)
                        .filter(x -> x % 2 != 0)
                        .boxed()
                        .sorted()
                        .collect(Collectors.toCollection(LinkedList::new));

        return IntStream.of(array)
                        .map(value -> value % 2 != 0 ? collect.pop() : value)
                        .toArray();
    }
}

导入java.util.array；
导入java.util.LinkedList；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
类IntSort{
公共静态void main（字符串[]args）{
int[]数组=新的int[]{5,3,2,8,1,4,0}；
最终int[]结果=sortonlyaddremaineven（数组）；
}
公共静态int[]sortonlyaddremaineven（int[]数组）{
最终链接列表收集；
collect=Arrays.stream（数组）
.filter（x->x%2！=0）
.boxed（）
.已排序（）
.collect（Collectors.toCollection（LinkedList:：new））；
返回IntStream.of（数组）
.map（值->值%2！=0？collect.pop（）：值）
.toArray（）；
}
}
当数组[j]的前一个是奇数时，您不能只与它的前一个交换
数组[j]
，因为后者可能是偶数。您需要找到最近的前置器，这很奇怪，以查看交换是否正常。tn我需要在数组中的位置对NUBRER进行反向排序。对奇数进行排序不是问题，问题是将其放回数组中的位置，而不是与偶数混合。偶数应该保留在他们的表上places@IMBABOT这不是问题。首先，将奇数的索引存储在数组中。然后，只对奇数进行排序。然后，将每个奇数放在存储的索引数组给定的索引中。为此输出：
[3,1,5,2,8,4,0]
，应该
[1,3,2,8,5,4,0]
您的语句-
但偶数值必须保留在它们的位置。
:2是否从第三个索引移动到第二个索引？（用数组索引的术语）8从第4个索引移动到第3个索引。提示：返回数组是可选的，因为外部数组将被修改。您也可以用流替换for循环。您是指map还是更好的解决方案？流并不总是比for循环好。请看我的答案。@KorayTugay:pop（）是个好主意；-）
import java.util.Arrays;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

class IntSort {

    public static void main(String[] args) {
        int[] array = new int[]{5, 3, 2, 8, 1, 4, 0};
        final int[] result = sortOnlyOddRemainEven(array);
    }

    public static int[] sortOnlyOddRemainEven(int[] array) {
        final LinkedList<Integer> collect;
        collect = Arrays.stream(array)
                        .filter(x -> x % 2 != 0)
                        .boxed()
                        .sorted()
                        .collect(Collectors.toCollection(LinkedList::new));

        return IntStream.of(array)
                        .map(value -> value % 2 != 0 ? collect.pop() : value)
                        .toArray();
    }
}