Question

我有一系列n个元素和这些方法：

last()返回数组的最后一个
first()返回数组的第一个int
size()返回数组的长度
replaceFirst(num)在开头添加int并返回其位置
remove(pos)删除了pos

我必须创建一个新方法，以相反的顺序为我提供数组。我需要使用那些方法。现在，我无法理解为什么我的方法不起作用。所以 for（int i = 1; i

remove将删除位置i处的元素，并返回它在该位置的数字，然后使用replaceFirst将移动数组的数字（由remove删除）。

我尝试使用{2,4,6,8,10,12}的简单数组我的输出是：12 12 12 8 6 10

所以如果我有一个1,2,3,4,5

的数组

表示i = 1;我要：2,1,3,4,5
对于i = 2> 3,2,1,4,5
etc

但它似乎不起作用。

Answer 1

好吧，我会给你提示。有多种方法可以反转数组。

最简单，最明显的方法是以相反的顺序循环遍历数组，并按正确的顺序将值分配给另一个数组。
上一个方法需要你使用额外的数组，如果你不想这样做，你可以在for循环中有两个索引，一个来自第一个，下一个来自最后一个并且开始交换这些指数的价值。
您的方法也有效，但由于您将值插入数组的前面，因此它会更复杂。
Collections.reverse类中还有一个Collections方法来反转对象数组。您可以在this post

Answer 2

这是在Stackoverflow by @unholysampler上提供的代码。您可能想要从那里开始：Java array order reversing

public static void reverse(int[] a)
{
    int l = a.length;
    for (int j = 0; j < l / 2; j++)
    {
        int temp = a[j]
        a[j] = a[l - j - 1];
        a[l - j - 1] = temp;
    }
}

Answer 3

反转数组是一个相对简单的过程。让我们开始考虑如何正常打印数组。

int[] numbers = {1,2,3,4,5,6};

for(int x = 0; x < numbers.length; x++)
{
    System.out.println(numbers[x]);
}

这是做什么的？好吧，它增加x，而它小于numbers.length，所以实际发生的是...

首次运行：X = 0

System.out.println(numbers[x]);
// Which is equivalent to..
System.out.println(numbers[0]);
// Which resolves to..
System.out.println(1);

第二次运行：X = 1

System.out.println(numbers[x]);
// Which is equivalent to..
System.out.println(numbers[1]);
// Which resolves to..
System.out.println(2);

您需要做的是从numbers.length - 1开始，然后返回0。为此，您需要重新构建for loop，以匹配以下伪代码。

for(x := numbers.length to 0) {
    print numbers[x]
}

现在你已经研究了如何打印，现在是时候转向反转阵列了。使用for循环，您可以从头到尾循环遍历数组中的每个值。你还需要一个新阵列。

int[] revNumbers = new int[numbers.length];

for(int x = numbers.length - 1 to 0) {
    revNumbers[(numbers.length - 1) - x] = numbers[x];
}

Answer 4

int[] reverse(int[] a) {
    int len = a.length;
    int[] result = new int[len];
    for (int i = len; i > 0 ; i--)
        result[len-i] = a[i-1];
    return result;
}

Answer 5

for(int i = array.length; i >= 0; i--){
    System.out.printf("%d\n",array[i]);
}

试试这个。

Answer 6

如果它是Java数组而不是复杂类型，最简单和最安全的方法是使用库，例如Apache commons：ArrayUtils.reverse(array);

Answer 7

在Java中用于随机数组：

public static void reverse(){

    int[] a = new int[4];

    a[0] = 3;
    a[1] = 2;
    a[2] = 5;
    a[3] = 1;

    LinkedList<Integer> b = new LinkedList<Integer>();

    for(int i = a.length-1; i >= 0; i--){

        b.add(a[i]); 

    }

    for(int i=0; i<b.size(); i++){

        a[i] = b.get(i);
        System.out.print(a[i] + ",");   
    }



}

希望这有帮助。

Answer 8

int[] noArray = {1,2,3,4,5,6};
    int lenght = noArray.length - 1;

    for(int x = lenght ;  x >= 0; x--)
    {
        System.out.println(noArray[x]);
    }
}

Answer 9

    int[] numbers = {1,2,3,4,5};
    int[] ReverseNumbers = new int[numbers.Length];

    for(int a=0; a<numbers.Length; a++)
    {
        ReverseNumbers[a] = numbers.Length - a;
    }

    for(int a=0; a<ReverseNumbers.Length; a++)
    Console.Write(" " + ReverseNumbers[a]);

Answer 10

int[] numbers = { 1, 2, 3, 4, 5, 6 };
reverse(numbers, 1); >2,1,3,4,5
reverse(numbers, 2); >3,2,1,4,5

public int[] reverse(int[] numbers, int value) {
int index = 0;
for (int i = 0; i < numbers.length; i++) {
  int j = numbers[i];
  if (j == value) {
    index = i;
    break;
  }
}
int i = 0;
int[] result = new int[numbers.length];
int forIndex = index + 1;
for (int x = index + 2; x > 0; x--) {
  result[i] = numbers[forIndex--];
  ++i;
}
for (int x = index + 2; x < numbers.length; x++) {
  result[i] = numbers[x];
  ++i;
}
return result;
}

数组顺序相反

10 个答案: