如何在Java中反转int数组？
我试图在Java中反转一个int数组。
此方法不会反转数组。
for(int i = 0; i < validData.length; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}
它出了什么问题？
44 个答案:
答案 0 :(得分：285)
使用Commons.Lang，您只需使用
即可ArrayUtils.reverse(int[] array)
大多数情况下，坚持使用已经过单元测试并经过用户测试的易于使用的库可以更快，更安全地进行错误处理。
答案 1 :(得分：255)
要反转int数组，请将项目交换到中间点，如下所示：
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;
}
你这样做的方式，你交换每个元素两次，所以结果与初始列表相同。
答案 2 :(得分：47)
public class ArrayHandle {
public static Object[] reverse(Object[] arr) {
List<Object> list = Arrays.asList(arr);
Collections.reverse(list);
return list.toArray();
}
}
答案 3 :(得分：38)
如果您声明显式变量来跟踪您在循环的每次迭代中交换的索引，我认为遵循算法的逻辑会更容易一些。
public static void reverse(int[] data) {
for (int left = 0, right = data.length - 1; left < right; left++, right--) {
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
我也认为在while循环中执行此操作更具可读性。
public static void reverse(int[] data) {
int left = 0;
int right = data.length - 1;
while( left < right ) {
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
// move the left and right index pointers in toward the center
left++;
right--;
}
}
答案 4 :(得分：36)
Collections.reverse(Arrays.asList(yourArray));
java.util.Collections.reverse()可以反转java.util.List并且java.util.Arrays.asList()返回一个包含您传递给它的特定数组的列表，因此yourArray在调用{{Collections.reverse()后被撤消1}}。
成本只是创建一个List对象，不需要额外的库。
在Tarik及其评论员的回答中提出了类似的解决方案，但我认为这个答案会更简洁，更容易解析。
答案 5 :(得分：10)
这里已经有很多答案，主要集中在就地修改阵列。但是为了完整起见，这是使用Java流来保留原始数组并创建新的反向数组的另一种方法：
int[] a = {8, 6, 7, 5, 3, 0, 9};
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();
答案 6 :(得分：9)
使用番石榴：
Collections.reverse(Ints.asList(array));
答案 7 :(得分：7)
简单的循环！
for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
答案 8 :(得分：5)
这会对你有所帮助
int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
int temp = a[k];
a[k] = a[a.length-(1+k)];
a[a.length-(1+k)] = temp;
}
答案 9 :(得分：4)
这就是我亲自解决的问题。创建参数化方法的原因是允许对任何数组进行排序......而不仅仅是整数。
我希望你收集一些东西。
@Test
public void reverseTest(){
Integer[] ints = { 1, 2, 3, 4 };
Integer[] reversedInts = reverse(ints);
assert ints[0].equals(reversedInts[3]);
assert ints[1].equals(reversedInts[2]);
assert ints[2].equals(reversedInts[1]);
assert ints[3].equals(reversedInts[0]);
reverseInPlace(reversedInts);
assert ints[0].equals(reversedInts[0]);
}
@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
if (array == null) {
return (T[]) new ArrayList<T>().toArray();
}
List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
Collections.reverse(copyOfArray);
return copyOfArray.toArray(array);
}
private static <T> T[] reverseInPlace(T[] array) {
if(array == null) {
// didn't want two unchecked suppressions
return reverse(array);
}
Collections.reverse(Arrays.asList(array));
return array;
}
答案 10 :(得分：3)
对于 Java 8 ，我们也可以使用流来反转整数数组：
int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
.toArray(); //Output: [5, 4, 3, 2, 1]
答案 11 :(得分：3)
您的程序仅适用于length = 0, 1。
你可以尝试：
int i = 0, j = validData.length-1 ;
while(i < j)
{
swap(validData, i++, j--); // code for swap not shown, but easy enough
}
答案 12 :(得分：3)
如果使用更原始的数据（即char，byte，int等），那么你可以做一些有趣的XOR操作。
public static void reverseArray4(int[] array) {
int len = array.length;
for (int i = 0; i < len/2; i++) {
array[i] = array[i] ^ array[len - i - 1];
array[len - i - 1] = array[i] ^ array[len - i - 1];
array[i] = array[i] ^ array[len - i - 1];
}
}
答案 13 :(得分：2)
简单地向后迭代数组是最有效的。
我不确定Aaron的解决方案是否可以执行此操作v Collections.reverse(list);有人知道吗？
答案 14 :(得分：2)
public void getDSCSort(int[] data){
for (int left = 0, right = data.length - 1; left < right; left++, right--){
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
答案 15 :(得分：1)
这样做不会更容易出错吗？
int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] temp = new int[intArray.length];
for(int i = intArray.length - 1; i > -1; i --){
temp[intArray.length - i -1] = intArray[i];
}
intArray = temp;
答案 16 :(得分：1)
具有o（n）时间复杂度和o（1）空间复杂度的解决方案。
select "DateFinish" - "DateStart"
答案 17 :(得分：1)
public void display(){
String x[]=new String [5];
for(int i = 4 ; i > = 0 ; i-- ){//runs backwards
//i is the nums running backwards therefore its printing from
//highest element to the lowest(ie the back of the array to the front) as i decrements
System.out.println(x[i]);
}
}
答案 18 :(得分：0)
使用泛型的实现。
//Reverse and get new Array -preferred
public static final <T> T[] reverse(final T[] array) {
final int len = array.length;
final T[] reverse = (T[]) Array.newInstance(array.getClass().getComponentType(), len);
for (int i = 0; i < len; i++) {
reverse[i] = array[len-(i+1)];
}
return reverse;
}
//Reverse existing array - don't have to return it
public static final <T> T[] reverseExisting(final T[] array) {
final int len = array.length;
for (int i = 0; i < len/2; i++) {
final T temp = array[i];
array[i] = array[len-(i+1)];
array[len-(i+1)] = temp;
}
return array;
}
答案 19 :(得分：0)
有两种方法可以解决问题：
<强> 1。在空间中反转数组。
步骤1.在开始和结束索引处交换元素。
步骤2.增加起始索引减少结束索引。
步骤3.迭代步骤1和步骤2直到开始索引＆lt;结束指数
为此，时间复杂度为O（n），空间复杂度为O（1）
在空间中反转数组的示例代码如下：
public static int[] reverseAnArrayInSpace(int[] array) {
int startIndex = 0;
int endIndex = array.length - 1;
while(startIndex < endIndex) {
int temp = array[endIndex];
array[endIndex] = array[startIndex];
array[startIndex] = temp;
startIndex++;
endIndex--;
}
return array;
}
<强> 2。使用辅助数组反转数组。
步骤1.创建一个大小等于给定数组的新数组。
步骤2.从起始索引开始，将元素插入到新数组中 给定数组从结束索引开始。
为此，时间复杂度为O（n），空间复杂度为O（n）
使用辅助数组反转数组的示例代码如下：
public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
int[] reversedArray = new int[array.length];
for(int index = 0; index < array.length; index++) {
reversedArray[index] = array[array.length - index -1];
}
return reversedArray;
}
此外，我们可以使用Java中的Collections API来执行此操作。
Collections API内部使用相同的空间反向方式。
使用Collections API的示例代码如下：
public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
List<Integer> arrayList = Arrays.asList(array);
Collections.reverse(arrayList);
return arrayList.toArray(array);
}
答案 20 :(得分：0)
static int[] reverseArray(int[] a) {
int ret[] = new int[a.length];
for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
ret[i] = a[j];
return ret;
}
答案 21 :(得分：0)
public static int[] reverse(int[] array) {
int j = array.length-1;
// swap the values at the left and right indices //////
for(int i=0; i<=j; i++)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
j--;
}
return array;
}
public static void main(String []args){
int[] data = {1,2,3,4,5,6,7,8,9};
reverse(data);
}
答案 22 :(得分：0)
public static void main(String args[]) {
int [] arr = {10, 20, 30, 40, 50};
reverse(arr, arr.length);
}
private static void reverse(int[] arr, int length) {
for(int i=length;i>0;i--) {
System.out.println(arr[i-1]);
}
}
答案 23 :(得分：0)
上面有一些很好的答案，但这是我的方法：
public static int[] test(int[] arr) {
int[] output = arr.clone();
for (int i = arr.length - 1; i > -1; i--) {
output[i] = arr[arr.length - i - 1];
}
return output;
}
答案 24 :(得分：0)
答案 25 :(得分：0)
一种无需附加库，导入或静态引用即可进行反转的简短方法。
int[] a = {1,2,3,4,5,6,7,23,9}, b; //compound declaration
var j = a.length;
b = new int[j];
for (var i : a)
b[--j] = i; //--j so you don't have to subtract 1 from j. Otherwise you would get ArrayIndexOutOfBoundsException;
System.out.println(Arrays.toString(b));
当然，如果您实际上需要a作为反转数组，只需使用
a = b; //after the loop
答案 26 :(得分：0)
以下是精简版：
我的解决方案创建了一个新的反向阵列 对于i的每次迭代，for循环将最后一个索引[array.length-1]插入当前索引[i] 然后通过从最后一个索引减去当前迭代array [（array.length-1）-i]并将元素插入反向数组的下一个索引来继续相同的过程！
private static void reverse(int[] array) {
int[] reversed = new int[array.length];
for (int i = 0; i < array.length; i++) {
reversed[i] = array[(array.length - 1) - i];
}
System.out.println(Arrays.toString(reversed));
}
答案 27 :(得分：0)
只是为了它。人们在处理流和集合时通常只需要以相反的顺序在数组或列表上有一个“视图”，而不是一个完全不需要的数组，而是在原始数组/集合上有一个“相反”的视图。 ，最好创建一个在列表/数组上具有反向视图的工具包。
因此，创建您的Iterator实现，该实现采用数组或列表并提供输入。
for i in $FILES
do
echo -n \""$i\": "
awk 'BEGIN {
output="";
outputlength=0
}
/(^ *[0-9]+)/ { # process only lines that start with a number
if (length(substr($10, 2)) > outputlength) { # if line has more hashes, store it
output=$0;
outputlength=length(substr($10, 2))
}
}
END {
print output # output the resulting line
}' "$i"
done
数组情况的实现非常相似。当然，迭代器也可以是流或集合的源。
因此，并非总是最好创建一个新数组，仅当您要遍历数组/列表或将其馈送到流或新的集合/数组中时，才提供反向视图。
答案 28 :(得分：0)
这有两个解决方案
循环
递归
公共类_1_ReverseArray {
public static void main(String[] args) { int array[] = {2, 3, 1, 4, 9}; //reverseArray(array, 0, array.length - 1); reverseArrayWhileLoop(array, 0, array.length - 1); printArray(array); } private static void printArray(int[] array) { for (int a : array) { System.out.println(a); } } private static void reverseArray(int[] array, int start, int end) { if (start > end) { return; } else { int temp; temp = array[start]; array[start] = array[end]; array[end] = temp; reverseArray(array, start + 1, end - 1); } } private static void reverseArrayWhileLoop(int[] array, int start, int end) { while (start < end) { int temp; temp = array[start]; array[start] = array[end]; array[end] = temp; start++; end--; } }}
答案 29 :(得分：0)
以下是我的想法：
// solution 1 - boiler plated
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];
int lastIdx = original.length -1;
int startIdx = 0;
for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
reverse[startIdx] = original[endIdx];
System.out.printf("reverse form: %s", Arrays.toString(reverse));
// solution 2 - abstracted
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);
答案 30 :(得分：0)
这是一个简单的实现，可以反转任何类型的数组，以及完整/部分支持。
import java.util.logging.Logger;
public final class ArrayReverser {
private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());
private ArrayReverser () {
}
public static <T> void reverse(T[] seed) {
reverse(seed, 0, seed.length);
}
public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
if (seed == null || seed.length == 0) {
LOGGER.warning("Nothing to rotate");
}
int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
int end = Math.min(seed.length, endIndexExclusive) - 1;
while (start < end) {
swap(seed, start, end);
start++;
end--;
}
}
private static <T> void swap(T[] seed, int start, int end) {
T temp = seed[start];
seed[start] = seed[end];
seed[end] = temp;
}
}
这是相应的单元测试
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
public class ArrayReverserTest {
private Integer[] seed;
@Before
public void doBeforeEachTestCase() {
this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}
@Test
public void wholeArrayReverse() {
ArrayReverser.<Integer>reverse(seed);
assertThat(seed[0], is(8));
}
@Test
public void partialArrayReverse() {
ArrayReverser.<Integer>reverse(seed, 1, 5);
assertThat(seed[1], is(5));
}
}
答案 31 :(得分：0)
使用XOR解决方案来避免临时变量，您的代码应该看起来像
for(int i = 0; i < validData.length; i++){
validData[i] = validData[i] ^ validData[validData.length - i - 1];
validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1];
validData[i] = validData[i] ^ validData[validData.length - i - 1];
}
请参阅此链接以获得更好的解释：
http://betterexplained.com/articles/swap-two-variables-using-xor/
答案 32 :(得分：0)
下面的
是在您的机器上运行的完整程序。
public class ReverseArray {
public static void main(String[] args) {
int arr[] = new int[] { 10,20,30,50,70 };
System.out.println("reversing an array:");
for(int i = 0; i < arr.length / 2; i++){
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
对于使用数组this will be the good source的矩阵上的程序。浏览链接。
答案 33 :(得分：-1)
import java.util.Scanner;
class ReverseArray
{
public static void main(String[] args)
{
int[] arra = new int[10];
Scanner sc = new Scanner(System.in);
System.out.println("Enter Array Elements : ");
for(int i = 0 ; i <arra.length;i++)
{
arra[i] = sc.nextInt();
}
System.out.println("Printing Array : ");
for(int i = 0; i <arra.length;i++)
{
System.out.print(arra[i] + " ");
}
System.out.println();
System.out.println("Printing Reverse Array : ");
for(int i = arra.length-1; i >=0;i--)
{
System.out.print(arra[i] + " ");
}
}
}
答案 34 :(得分：-1)
由于我打算保留原始数组，我按以下方式解决了这个问题：
List<Integer> normalArray= new ArrayList<>();
List<Integer> reversedArray = new ArrayList<>();
// Fill up array here
for (int i = 1; i <= normalArray.size(); i++) {
reversedArray .add(normalArray.get(normalArray.size()-i));
}
所以基本上循环遍历初始数组并将所有值以相反的顺序添加到新的（反向）数组中。列表的类型可以是任何内容。 我多次尝试使用此代码，这会导致其他一些解决方案失效。
答案 35 :(得分：-1)
两种反转数组的方法。
-
使用For循环并将元素交换到中点，时间复杂度为O（n / 2）。
private static void reverseArray() { int[] array = new int[] { 1, 2, 3, 4, 5, 6 }; for (int i = 0; i < array.length / 2; i++) { int temp = array[i]; int index = array.length - i - 1; array[i] = array[index]; array[index] = temp; } System.out.println(Arrays.toString(array));}
-
使用内置函数（Collections.reverse（））
private static void reverseArrayUsingBuiltInFun() { int[] array = new int[] { 1, 2, 3, 4, 5, 6 }; Collections.reverse(Ints.asList(array)); System.out.println(Arrays.toString(array));}
输出：[6,5,4,3,2,1]
答案 36 :(得分：-1)
这是一个简单快速的解决方案。希望它有所帮助！
{{1}}
答案 37 :(得分：-1)
试试这段代码：
int arr[] = new int[]{1,2,3,4,5,6,7};
for(int i=0;i<arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[(arr.length-1)-i];
arr[(arr.length-1)-i] = temp;
}
System.out.println(Arrays.toString(arr));
答案 38 :(得分：-1)
在JAVA中试用这个程序： -
import java.util.Scanner;
public class Rev_one_D {
static int row;
static int[] trans_arr = new int[row];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
row = n;
int[] arr = new int[row];
for (int i = 0; i < row; i++) {
arr[i] = sc.nextInt();
System.out.print(arr[i] + " ");
System.out.println();
}
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
for (int i = 0; i < row; i++) {
System.out.print(arr[i] + " ");
System.out.println();
}
}
}
答案 39 :(得分：-1)
public class TryReverse {
public static void main(String[] args) {
int [] array = {2,3,4,5,6,7,8,9};
reverse(array);
for(int i=0; i<array.length; ++i)
System.out.print(array[i] + " ");
}
public static void reverse (int [] array){
for(int start=0, end=array.length-1; start<=end; start++, end--){
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
}
}
答案 40 :(得分：-1)
private static int[] reverse(int[] array){
int[] reversedArray = new int[array.length];
for(int i = 0; i < array.length; i++){
reversedArray[i] = array[array.length - i - 1];
}
return reversedArray;
}
答案 41 :(得分：-1)
public static void main (String args[]){
//create array
String[] stuff ={"eggs","lasers","hats","pie","apples"};
//print out array
for(String x :stuff)
System.out.printf("%s ", x);
System.out.println();
//print out array in reverse order
for(int i=stuff.length-1; i >= 0; i--)
System.out.printf("%s ",stuff[i]);
}
答案 42 :(得分：-2)
您可以使用此
public final class ReverseComparator<T extends Comparable<T>> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return o2.compareTo(o1);
}
}
简单
Integer[] a = {1,6,23,4,6,8,2}
Arrays.sort(a, new ReverseComparator<Integer>());
答案 43 :(得分：-5)
int[] arrTwo = {5, 8, 18, 6, 20, 50, 6};
for (int i = arrTwo.length-1; i > 0; i--)
{
System.out.print(arrTwo[i] + " ");
}
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？