Mic*_*ott 224 java arrays idioms idiomatic
我试图在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;
}
这有什么问题？
Man*_*nur 293
使用Commons.Lang,您可以简单地使用
ArrayUtils.reverse(int[] array)
大多数情况下,当他们处理您的问题时,坚持使用已经过单元测试和用户测试的易于使用的库会更快,更安全.
3le*_*gos 272
要反转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;
}
你这样做,你交换每个元素两次,所以结果与初始列表相同.
Tar*_*rik 50
public class ArrayHandle {
public static Object[] reverse(Object[] arr) {
List<Object> list = Arrays.asList(arr);
Collections.reverse(list);
return list.toArray();
}
}
Bil*_*ard 39
如果你声明显式变量来跟踪你在循环的每次迭代中交换的索引,我认为遵循算法的逻辑会更容易一些.
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--;
}
}
esc*_*ram 39
Collections.reverse(Arrays.asList(yourArray));
java.util.Collections.reverse()可以反转java.util.Lists并java.util.Arrays.asList()返回一个包含您传递给它的特定数组的列表,因此yourArray在调用之后会反转Collections.reverse().
成本只是创建一个List对象,不需要额外的库.
在Tarik及其评论员的回答中提出了类似的解决方案,但我认为这个答案会更简洁,更容易解析.
Pat*_*ker 12
这里已经有很多答案,主要集中在就地修改数组.但是为了完整起见,这是使用Java流来保留原始数组并创建新的反向数组的另一种方法:
int[] a = {8, 6, 7, 5, 3, 0, 9};
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();
Zhe*_*lov 10
与番石榴:
Collections.reverse(Ints.asList(array));
简单的循环!
for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
这就是我个人将如何解决它。创建参数化方法背后的原因是允许对任何数组进行排序……而不仅仅是您的整数。
我希望你能从中有所收获。
@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;
}
小智 5
如果使用更原始的数据（即 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];
}
}
这会对你有所帮助
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;
}
for(int i=validData.length-1; i>=0; i--){
System.out.println(validData[i]);
}
对于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]
有两种方法可以解决该问题：
1. 反转空间中的数组。
步骤 1. 交换起始索引和结束索引处的元素。
步骤 2. 增加起始索引并减少结束索引。
步骤 3. 迭代步骤 1 和步骤 2，直到开始索引 < 结束索引
为此，时间复杂度为 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);
}