使用Java反转数组

我使用

for循环

将数字1到10填充到一个数组中。 现在我需要用第一个数组的值填充第二个数组，但要颠倒。所以第二个数组必须用10比1填充

我尝试了一些东西，但它仅用1填充了第二个数组

输出为：

1
2
3
4
5
6
7
8
9
10
1
1
1
1
1
1
1
1
1
1

而且应该是

1234567810998764321

package FillandTurn;

import java.util.Scanner;

/**
 *
 * @author Quinten
 */
public class FillandTurn {

    /**
     * @param args the command line arguments
     */
    Scanner scan = new Scanner(System.in);
    public static void main(String[] args) {
        // TODO code application logic here
        FillandTurn fill = new FillandTurn();
        fill.start();
    }

    public void start(){
        FillandTurn turn = FillandTurn();
        int[] array = turn.vullen();
        int[] array2 = turn.draaien(array);
    }
    public int[] fill(){
        int[] array = new int[10];
        int j = 0;
        for(int i = 0; i < array.length; i++ ){
            j++;
            array[i] = j;
        }


        for(int p = 0; p <= array.length-1; p++ ){
            System.out.println(array[p]);
        }

        return array;
    }
    public int[] turn(int[] array){
        int[] array2 = new int[10];
        for(int x = 0; x < array2.length; x++){
            for(int y = array.length-1; y >=0; y--){
                array2[x] = array[y];
            }
        }


        for(int p = 0; p <= array2.length-1; p++ ){
            System.out.println(array2[p]);
        }


       return array2;


    }

}

package FillandTurn；
导入java.util.Scanner；
/**
*
*@作者昆顿
*/
公共类FillandTurn{
/**
*@param指定命令行参数
*/
扫描仪扫描=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
FillandTurn fill=新FillandTurn（）；
fill.start（）；
}
公开作废开始（）{
FillandTurn turn=FillandTurn（）；
int[]数组=turn.vullen（）；
int[]array2=turn.draaien（数组）；
}
公共int[]填充（）{
int[]数组=新的int[10]；
int j=0；
for（int i=0；ifor（int p=0；p按规定使用for循环填充第一个数组，但第二个数组使用单独的for循环，从第一个数组的大小开始，每次迭代时递减，将元素放入新数组中
您尝试过从后向前读取数组吗

public int[] reverseArray(int[] array1) {
    int[] array2 = new int[array1.length];

    int pos = 0;

    for(int neg = array1.length; neg >= 0; neg--) {
        array2[pos] = array1[neg];
    }

    return array2;
}

这是一种简单的方法，可能有更好的方法可以做到这一点。
当您复制数组时，您只需要一个循环。使用嵌套循环意味着您要复制每个值N次，或者实际上第一个值覆盖所有其他值

你能行

class FillAndTurn {
    public static void main(String... args) {
        int[] array = new int[10];
        fill(array);
        int[] array2 = turn(array);
        IntStream.of(array).forEach(System.out::println);
        IntStream.of(array2).forEach(System.out::println);
    }

    static void fill(int[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = i + 1;
    }

    static int[] turn(int[] array) {
        int[] array2 = new int[array.length];
        for(int i = 0; i < array.length; i++)
            array2[array2.length - i - 1] = array[i];
        return array2;
    }
}

类FillAndTurn{
公共静态void main（字符串…参数）{
int[]数组=新的int[10]；
填充（数组）；
int[]阵列2=旋转（阵列）；
IntStream.of（array.forEach（System.out:：println）；
IntStream.of（array2）.forEach（System.out:：println）；
}
静态空白填充（int[]数组）{
for（int i=0；i
p