在Java中反转数组的程序

我试图用下面显示的代码反转一个数组，但没有成功。该程序的输出是

7,0,0

，而不是其预期的

7,1,2

代码：

导入java.util.array；
公共类反向通道
{
公共静态void main（字符串[]args）
{
int[]数据={1,2,7}；
int[]dataR=reversearlay（数据）；
System.out.println（“原始数组：“+Arrays.toString（数据））；
System.out.println（“反向数组：“+Arrays.toString（dataR））；
}
公共静态int[]反向数组（int[]数据）
{
int[]reversedData=newint[data.length]；
int i；
对于（i=0；i

感谢您的帮助。

这是您的问题：

for(i=0; i < data.length; i++);

for（i=0；i

删除

。按照您编写它的方式，首先有一个循环将
i
计数到
data.length
，然后是一个作用域块，它尝试访问
reversedData[data.length]
恰好一次。那不会飞的

有趣的是：最初，我们可能没有人看到问题所在；在IDE中使用格式化规则会很快告诉您出了什么问题：您会发现，当按照您习惯的规则进行格式化时，您的代码看起来与预期的不一样。
您应该使用临时变量交换数组中的值。例如：

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

所有描述都有问题。
抓得好，G.巴赫。我也不确定你问题的第一部分。看起来原始数组是
1,2,7
。相反的是不是
7,2,1
，而不是
7,1,2

也就是说，似乎每次访问
data.length
都会减慢速度。我可能会创建一个局部变量：

public static int[] reverseArray(int[] data)
{
    int arr_length = data.length
    int[] reversedData = new int[arr_length];
    int j = arr_length - 1;
    for(int i=0; i < arr_length; i++);
    {
        reversedData[i] = data[j--];
    }
    return reversedData;
}

publicstaticint[]reversearlay（int[]data）
{
int arr_length=data.length
int[]反向数据=新int[arr_length]；
int j=arr_长度-1；
对于（int i=0；i

请注意，
j
在被访问后是如何自动递减的，以保持事物的整洁。此外，我们还将数组的长度保存到一个局部变量中，以便更高效地访问；
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner in=new Scanner(System.in);
        int size=in.nextInt();
        int array[]=new int[size];

        for(int i=0;i<size;i++){
            array[i]=in.nextInt();
        }
        for(int i=size-1;i>=0;i--)
        {
            System.out.print(array[i]+" ");
        }


        }

        }

导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态void main（字符串[]args）{
/*在此处输入代码。从STDIN读取输入。将输出打印到STDOUT。您的类应命名为Solution*/
扫描仪输入=新扫描仪（系统输入）；
int size=in.nextInt（）；
int数组[]=新的int[size]；
对于（int i=0；i=0；i--）
{
System.out.print（数组[i]+“”）；
}
}
}

导入java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类反向通道
{
公共静态void main（字符串[]args）
{
System.out.println（“输入数组大小”）；
扫描仪输入=新扫描仪（系统输入）；
int size=in.nextInt（）；
System.out.println（“输入数组元素”）；
int数组[]=新的int[size]；
对于（int i=0；i=0；i--）
{
System.out.print（数组[i]+“”）；
}
}
}

输入：

public class Test{

    public static void main(String[] args){

         System.out.println("Enter the number of values to reverse");

         Scanner sc = new Scanner(System.in);

         int n  = sc.nextInt();
         int num[] = new int[n];    
         for(int i=0; i < num.length; i++) 
             num[i] = sc.nextInt();

         reverseArray(num, n-1);

    }

    private static void reverseArray(int num[], int end) {
        int start = 0;
        int temp;

        while(start < end) {
            temp = num[start];
            num[start] = num[end];
            num[end] = temp;
            start++;
            end--;
            System.out.println("Reversed Array :"+ Arrays.toString(num));

        }


    }


}

输入要反转的值的数目 七,

1234678

输出： 反向数组：[8,2,3,4,6,7,1]

反向数组：[8,7,3,4,6,2,1]

反向数组：[8,7,6,4,3,2,1]

编码：

public class Test{

    public static void main(String[] args){

         System.out.println("Enter the number of values to reverse");

         Scanner sc = new Scanner(System.in);

         int n  = sc.nextInt();
         int num[] = new int[n];    
         for(int i=0; i < num.length; i++) 
             num[i] = sc.nextInt();

         reverseArray(num, n-1);

    }

    private static void reverseArray(int num[], int end) {
        int start = 0;
        int temp;

        while(start < end) {
            temp = num[start];
            num[start] = num[end];
            num[end] = temp;
            start++;
            end--;
            System.out.println("Reversed Array :"+ Arrays.toString(num));

        }


    }


}

公共类测试{
公共静态void main（字符串[]args）{
System.out.println（“输入要反转的值的数目”）；
扫描仪sc=新的扫描仪（System.in）；
int n=sc.nextInt（）；
int num[]=新的int[n]；
for（int i=0；i

是否要求您手工操作？你能使用类似于

Collections.reverse（Collections.toArray（data））.toArray（new int[data.length]）

的东西吗？@BheshGurung我说的是“类似的东西”：P-试图确定这是不是家庭作业；）嗯，他没有交换任何东西，他正在构建一个全新的阵列。它还需要在到达data.length的一半时停止，否则它会反转阵列，然后取消反转：P@Patashu：不，它正在构建一个新的数组，而不是交换。啊，我的略读错误：）让JVM的JIT来处理它。（'sides，您仍然在

i

中每次访问

data.length

）。哦，是的，因为长度可能在循环体期间发生了变化，因此必须进行检查。说得好。^^；请在你的回答中添加一些解释。

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class ReverseArray 
{

    public static void main(String[] args) 
    {

        System.out.println("Enter the array Size");
        Scanner in=new Scanner(System.in);
        int size=in.nextInt();
        System.out.println("Enter the array Elements");
        int array[]=new int[size];

        for(int i=0;i<size;i++){
            array[i]=in.nextInt();
        }
        System.out.println("reverse of entered are given below for Size : " +size );
        for(int i=size-1;i>=0;i--)
        {
            System.out.print(array[i]+" ");
        }


        }

}

public class Test{

    public static void main(String[] args){

         System.out.println("Enter the number of values to reverse");

         Scanner sc = new Scanner(System.in);

         int n  = sc.nextInt();
         int num[] = new int[n];    
         for(int i=0; i < num.length; i++) 
             num[i] = sc.nextInt();

         reverseArray(num, n-1);

    }

    private static void reverseArray(int num[], int end) {
        int start = 0;
        int temp;

        while(start < end) {
            temp = num[start];
            num[start] = num[end];
            num[end] = temp;
            start++;
            end--;
            System.out.println("Reversed Array :"+ Arrays.toString(num));

        }


    }


}