blocks|key|1133145|text|要反转int数组，您可以向上交换项目，直到到达中点，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133146|for(int+i+=+0;+i+<+validData.length+/+2;+i%2B%2B)
{
++++int+temp+=+validData[i];
++++validData[i]+=+validData[validData.length+-+i+-+1];
++++validData[validData.length+-+i+-+1]+=+temp;
}|code-block|syntax|javascript|1133147|这样做的方法是，将每个元素交换两次，因此结果与初始列表相同。|1133148|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

To reverse an int array, you swap items up until you reach the midpoint, like this:

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

The way you are doing it, you swap each element twice, so the result is the same as the initial list.

blocks|key|1133340|text|使用Commons.Lang，您可以简单地使用|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1133341|ArrayUtils.reverse(int[]+array)|code-block|syntax|javascript|1133342|大多数情况下，坚持使用已经过单元测试和用户测试的容易获得的库来解决您的问题会更快，也更安全。|1133343|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/lang/^0|2|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

With <a href="http://commons.apache.org/lang/" rel="noreferrer">Commons.Lang</a>, you could simply use 

<pre><code>ArrayUtils.reverse(int[] array)
</code></pre>

Most of the time, it's quicker and more bug-safe to stick with easily available libraries already unit-tested and user-tested when they take care of your problem.

blocks|key|1134009|text|Collections.reverse(Arrays.asList(yourArray));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1134010|java.util.Collections.reverse()可以颠倒java.util.List，java.util.Arrays.asList()返回一个包含您传递给它的特定数组的列表，因此yourArray在调用Collections.reverse()之后是颠倒的。|unstyled|offset|length|style|CODE|1134011|成本只是一个列表对象的创建，不需要额外的库。|1134012|在Tarik和他们的评论员的回答中也提出了类似的解决方案，但我认为这个答案会更简洁，更容易解析。|1134013|entityMap^0|0|0|V|Z|E|1E|P|2P|9|31|L|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]|$G|Y|H|Z|I|J]|$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>Collections.reverse(Arrays.asList(yourArray));
</code></pre>

<code>java.util.Collections.reverse()</code> can reverse <code>java.util.List</code>s and <code>java.util.Arrays.asList()</code> returns a list that wraps the the specific array you pass to it, therefore <code>yourArray</code> is reversed after the invocation of <code>Collections.reverse()</code>.

The cost is just the creation of one List-object and no additional libraries are required.

A similar solution has been presented in the answer of Tarik and their commentors, but I think this answer would be more concise and more easily parsable.

blocks|key|1348484|text|public+class+ArrayHandle+{
++++public+static+Object[]+reverse(Object[]+arr)+{
++++++++List<Object>+list+=+Arrays.asList(arr);
++++++++Collections.reverse(list);
++++++++return+list.toArray();
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1348485|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class ArrayHandle {
 public static Object[] reverse(Object[] arr) {
 List&lt;Object&gt; list = Arrays.asList(arr);
 Collections.reverse(list);
 return list.toArray();
 }
}
</code></pre>

blocks|key|1133395|text|我认为，如果您声明显式变量来跟踪您在每次循环迭代中交换的索引，那么遵循算法的逻辑会更容易一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133396|public+static+void+reverse(int[]+data)+{
++++for+(int+left+=+0,+right+=+data.length+-+1;+left+<+right;+left%2B%2B,+right--)+{
++++++++//+swap+the+values+at+the+left+and+right+indices
++++++++int+temp+=+data[left];
++++++++data[left]++=+data[right];
++++++++data[right]+=+temp;
++++}
}|code-block|syntax|javascript|1133397|我也认为在while循环中做这件事更具可读性。|1133398|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%2B%2B;
++++++++right--;
++++}
}|1133399|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think it's a little bit easier to follow the logic of the algorithm if you declare explicit variables to keep track of the indices that you're swapping at each iteration of the loop.

<pre><code>public static void reverse(int[] data) {
 for (int left = 0, right = data.length - 1; left &lt; right; left++, right--) {
 // swap the values at the left and right indices
 int temp = data[left];
 data[left] = data[right];
 data[right] = temp;
 }
}
</code></pre>

I also think it's more readable to do this in a while loop.

<pre><code>public static void reverse(int[] data) {
 int left = 0;
 int right = data.length - 1;

 while( left &lt; 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--;
 }
}
</code></pre>

blocks|key|1134125|text|这里已经有很多答案，主要集中在就地修改数组上。但为了完整起见，这里是另一种使用Java+streams保留原始数组并创建新的反转数组的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134126|++++int[]+a+=+{8,+6,+7,+5,+3,+0,+9};
++++int[]+b+=+IntStream.rangeClosed(1,+a.length).map(i+->+a[a.length-i]).toArray();|code-block|syntax|javascript|1134127|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are already a lot of answers here, mostly focused on modifying the array in-place. But for the sake of completeness, here is another approach using Java streams to preserve the original array and create a new reversed array:

<pre><code> int[] a = {8, 6, 7, 5, 3, 0, 9};
 int[] b = IntStream.rangeClosed(1, a.length).map(i -&gt; a[a.length-i]).toArray();
</code></pre>

blocks|key|1349482|text|使用Guava：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349483|Collections.reverse(Ints.asList(array));|code-block|syntax|javascript|1349484|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

With Guava:

<pre><code>Collections.reverse(Ints.asList(array));
</code></pre>

blocks|key|1133651|text|简单的for循环！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133652|for+(int+start+=+0,+end+=+array.length+-+1;+start+<=+end;+start%2B%2B,+end--)+{
++++int+aux+=+array[start];
++++array[start]=array[end];
++++array[end]=aux;
}|code-block|syntax|javascript|1133653|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple for loop!

<pre><code>for (int start = 0, end = array.length - 1; start &lt;= end; start++, end--) {
 int aux = array[start];
 array[start]=array[end];
 array[end]=aux;
}
</code></pre>

blocks|key|1133685|text|for(int+i=validData.length-1;+i>=0;+i--){
++System.out.println(validData[i]);
+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1133686|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>for(int i=validData.length-1; i&gt;=0; i--){
 System.out.println(validData[i]);
 }
</code></pre>

blocks|key|1348912|text|这会对你有帮助|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348913|int+a[]+=+{1,2,3,4,5};
for+(int+k+=+0;+k+<+a.length/2;+k%2B%2B)+{
++++int+temp+=+a[k];
++++a[k]+=+a[a.length-(1%2Bk)];
++++a[a.length-(1%2Bk)]+=+temp;
}|code-block|syntax|javascript|1348914|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This will help you

<pre><code>int a[] = {1,2,3,4,5};
for (int k = 0; k &lt; a.length/2; k++) {
 int temp = a[k];
 a[k] = a[a.length-(1+k)];
 a[a.length-(1+k)] = temp;
}
</code></pre>

blocks|key|1348932|text|这就是我个人解决这个问题的方法。创建参数化方法的原因是允许对任何数组进行排序...而不仅仅是你的整数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348933|我希望你能从中学到点什么。|1348934|@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;
}|code-block|syntax|javascript|1348935|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is how I would personally solve it. The reason behind creating the parametrized method is to allow any array to be sorted... not just your integers.

I hope you glean something from it.

<pre><code>@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 &lt;T&gt; T[] reverse(T[] array) {
 if (array == null) {
 return (T[]) new ArrayList&lt;T&gt;().toArray();
 }
 List&lt;T&gt; copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
 Collections.reverse(copyOfArray);
 return copyOfArray.toArray(array);
}

private static &lt;T&gt; T[] reverseInPlace(T[] array) {
 if(array == null) {
 // didn't want two unchecked suppressions
 return reverse(array);
 }

 Collections.reverse(Arrays.asList(array));
 return array;
}
</code></pre>

blocks|key|1133473|text|如果要处理更原始的数据(例如char、byte、int等)，那么可以进行一些有趣的XOR操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133474|public+static+void+reverseArray4(int[]+array)+{
++++int+len+=+array.length;
++++for+(int+i+=+0;+i+<+len/2;+i%2B%2B)+{
++++++++array[i]+=+array[i]+%5E+array[len+-+i++-+1];
++++++++array[len+-+i++-+1]+=+array[i]+%5E+array[len+-+i++-+1];
++++++++array[i]+=+array[i]+%5E+array[len+-+i++-+1];
++++}
}|code-block|syntax|javascript|1133475|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If working with data that is more primitive (i.e. char, byte, int, etc) then you can do some fun XOR operations.

<pre><code>public static void reverseArray4(int[] array) {
 int len = array.length;
 for (int i = 0; i &lt; 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];
 }
}
</code></pre>

blocks|key|1133262|text|您的程序将仅适用于length+=+0,+1。您可以尝试：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1133263|int+i+=+0,+j+=+validData.length-1+;+
while(i+<+j)
{
+++++swap(validData,+i%2B%2B,+j--);++//+code+for+swap+not+shown,+but+easy+enough
}|code-block|syntax|javascript|1133264|entityMap^0|9|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Your program will work for only <code>length = 0, 1</code>.
You can try :

<pre><code>int i = 0, j = validData.length-1 ; 
while(i &lt; j)
{
 swap(validData, i++, j--); // code for swap not shown, but easy enough
}
</code></pre>

blocks|key|1134253|text|上面有一些很好的答案，但我是这样做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134254|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;
}|code-block|syntax|javascript|1134255|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are some great answers above, but this is how I did it:

<pre class="lang-java prettyprint-override"><code>public static int[] test(int[] arr) {

 int[] output = arr.clone();
 for (int i = arr.length - 1; i &gt; -1; i--) {
 output[i] = arr[arr.length - i - 1];
 }
 return output;
}
</code></pre>

blocks|key|1133199|text|简单地向后迭代数组是最有效的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133200|我不确定Aaron的解决方案是不是这个叫做Collections.reverse(list);，有人知道吗？|offset|length|style|CODE|1133201|entityMap^0|0|L|Q|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It is most efficient to simply iterate the array backwards.

I'm not sure if Aaron's solution does this vi this call <code>Collections.reverse(list);</code> Does anyone know?

blocks|key|1349159|text|public+void+getDSCSort(int[]+data){
++++++++for+(int+left+=+0,+right+=+data.length+-+1;+left+<+right;+left%2B%2B,+right--){
++++++++++++//+swap+the+values+at+the+left+and+right+indices
++++++++++++int+temp+=+data[left];
++++++++++++data[left]++=+data[right];
++++++++++++data[right]+=+temp;
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1349160|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public void getDSCSort(int[] data){
 for (int left = 0, right = data.length - 1; left &lt; right; left++, right--){
 // swap the values at the left and right indices
 int temp = data[left];
 data[left] = data[right];
 data[right] = temp;
 }
 }
</code></pre>

blocks|key|1134175|text|具有o(n)时间复杂度和o(1)空间复杂度的解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134176|void+reverse(int[]+array)+{
++++int+start+=+0;
++++int+end+=+array.length+-+1;
++++while+(start+<+end)+{
++++++++int+temp+=+array[start];
++++++++array[start]+=+array[end];
++++++++array[end]+=+temp;
++++++++start%2B%2B;
++++++++end--;
++++}
}|code-block|syntax|javascript|1134177|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Solution with o(n) time complexity and o(1) space complexity.

<pre><code>void reverse(int[] array) {
 int start = 0;
 int end = array.length - 1;
 while (start &lt; end) {
 int temp = array[start];
 array[start] = array[end];
 array[end] = temp;
 start++;
 end--;
 }
}
</code></pre>

blocks|key|1133491|text|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]);
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1133492|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public void display(){
 String x[]=new String [5];
 for(int i = 4 ; i &gt; = 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]);
 }
}
</code></pre>

blocks|key|1133578|text|这样做不是更不可能出现错误吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133579|++++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;|code-block|syntax|javascript|1133580|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Wouldn't doing it this way be much more unlikely for mistakes?

<pre><code> 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 &gt; -1; i --){
 temp[intArray.length - i -1] = intArray[i];
 }
 intArray = temp;
</code></pre>

blocks|key|1134216|text|++++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]);+
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1134217|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> 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&gt;0;i--) { 
 System.out.println(arr[i-1]); 
 }
 }
</code></pre>

blocks|key|1133599|text|下面是在你的机器上运行的完整程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133600|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%2B%2B){
++++++++++++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%2B%2B)+{
++++++++++++System.out.println(arr[i]);
++++++++}+++
++++}
}|code-block|syntax|javascript|1133601|对于矩阵上的程序，通过链接使用数组this+will+be+the+good+source.Go。|offset|length|1133602|entityMap|0|LINK|mutability|MUTABLE|url|http://javabynataraj.blogspot.in/2014/08/matrix-multiplication-using-arrays-in.html^0|0|0|H|S|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

below is the complete program to run in your machine.

<pre><code>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 &lt; 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 &lt; arr.length; i++) {
 System.out.println(arr[i]);
 } 
 }
}
</code></pre>

For programs on matrix using arrays <a href="http://javabynataraj.blogspot.in/2014/08/matrix-multiplication-using-arrays-in.html" rel="nofollow">this will be the good source</a>.Go through the link.

blocks|key|1349017|text|private+static+int[]+reverse(int[]+array){
++++int[]+reversedArray+=+new+int[array.length];
++++for(int+i+=+0;+i+<+array.length;+i%2B%2B){
++++++++reversedArray[i]+=+array[array.length+-+i+-+1];
++++}
++++return+reversedArray;
}+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1349018|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>private static int[] reverse(int[] array){
 int[] reversedArray = new int[array.length];
 for(int i = 0; i &lt; array.length; i++){
 reversedArray[i] = array[array.length - i - 1];
 }
 return reversedArray;
} 
</code></pre>

blocks|key|1133628|text|使用XOR解决方案来避免temp变量，您的代码应该如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133629|for(int+i+=+0;+i+<+validData.length;+i%2B%2B){
++++validData[i]+=+validData[i]+%5E+validData[validData.length+-+i+-+1];
++++validData[validData.length+-+i+-+1]+=+validData[i]+%5E+validData[validData.length+-+i+-+1];
++++validData[i]+=+validData[i]+%5E+validData[validData.length+-+i+-+1];
}|code-block|syntax|javascript|1133630|有关更好的解释，请参阅此链接：|1133631|http://betterexplained.com/articles/swap-two-variables-using-xor/|offset|length|1133632|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|1T|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

Using the XOR solution to avoid the temp variable your code should look like

<pre><code>for(int i = 0; i &lt; 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];
}
</code></pre>

See this link for a better explanation:

<a href="http://betterexplained.com/articles/swap-two-variables-using-xor/" rel="nofollow">http://betterexplained.com/articles/swap-two-variables-using-xor/</a>

blocks|key|1134141|text|下面是我的想法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134142|//+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%2B%2B)
+++reverse[startIdx]+=+original[endIdx];

System.out.printf("reverse+form:+%25s",+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:+%25s",+l);|code-block|syntax|javascript|1134143|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is what I've come up with:

<pre><code>// 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 &gt;= 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&lt;Integer&gt; l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);
</code></pre>

blocks|key|1349595|text|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%2B%2B,+j--)
+++++++++ret[i]+=+a[j];
+++++return+ret;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1349596|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>static int[] reverseArray(int[] a) {
 int ret[] = new int[a.length];
 for(int i=0, j=a.length-1; i&lt;a.length &amp;&amp; j&gt;=0; i++, j--)
 ret[i] = a[j];
 return ret;
}
</code></pre>

blocks|key|1134198|text|+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%2B%2B)
++++++++{
+++++++++++++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);

++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1134199|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> 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&lt;=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);

 }
</code></pre>

blocks|key|1134433|text|使用非基元类型数组的泛型的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134434|++++//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%2B%2B)+{
++++++++++++reverse[i]+=+array[len-(i%2B1)];
++++++++}
++++++++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%2B%2B)+{
++++++++++++final+T+temp+=+array[i];
++++++++++++array[i]+=+array[len-(i%2B1)];
++++++++++++array[len-(i%2B1)]+=+temp;
++++++++}
++++++++return+array;
++++}|code-block|syntax|javascript|1134435|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A implementation using generics for arrays of non primitive types.
<pre><code> //Reverse and get new Array -preferred
 public static final &lt;T&gt; 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 &lt; len; i++) {
 reverse[i] = array[len-(i+1)];
 }
 return reverse;
 }
 
 //Reverse existing array - don't have to return it
 public static final &lt;T&gt; T[] reverseExisting(final T[] array) {
 final int len = array.length;
 for (int i = 0; i &lt; len/2; i++) {
 final T temp = array[i];
 array[i] = array[len-(i+1)];
 array[len-(i+1)] = temp;
 }
 return array;
 }
</code></pre>

blocks|key|1134321|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134322|📷|atomic|offset|length|1134323|1134324|轻而易举。我这样做是为了字符串，但是，它没有太大的不同|1134325|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/32d7a28d3a7a6b6433fc3ce1a81050b0.png|imageAlt^0|0|0|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@$E|U|F|V|1|W]]|A|$]]|$1|G|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

<a href="https://i.stack.imgur.com/4mTDB.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/4mTDB.png" alt="enter image description here" /></a>
a piece of cake.
i did it for string but, it's not much different

blocks|key|1134351|text|一种无需额外的库、导入或静态引用即可进行反向操作的快捷方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134352|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));|code-block|syntax|javascript|1134353|当然，如果您确实需要a作为反转数组，那么只需使用|offset|length|style|CODE|1134354|a+=+b;+//after+the+loop|1134355|entityMap^0|0|0|A|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A short way to reverse without additional libraries, imports, or static references.
<pre><code>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));
</code></pre>
Of course if you actually need <code>a</code> to be the reversed array just use
<pre><code>a = b; //after the loop
</code></pre>

blocks|key|1134405|text|只是为了这件事。人们通常只需要一个倒序的数组或列表上的“视图”，而不是在处理流和集合时完全不需要倒数组，而是需要在原始数组/集合上的“倒置”视图。，最好创建一个在列表/数组上具有反向视图的工具包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1134406|因此，创建接受数组或列表并提供输入的Iterator实现。|1134407|///+Reverse+Iterator
public+class+ReverseIterator<T>+implements+Iterator<T>+{
++private+int+index;
++private+final+List<T>+list;
++public+ReverseIterator(List<T>+list)+{
+++++this.list+=+list;
+++++this.index+=+list.size()+-+1;
++}
++public+boolean+hasNext()+{
++++return+index+>=+0+?+true+:+false;
++}
++public+T+next()+{
++++if(index+>=+0)+
++++++return+list.get(index--);
++++else+
++++++throw+new+NoSuchElementException();
++}
}|code-block|syntax|javascript|1134408|数组情况的实现与此非常相似。当然，迭代器也可以是流或集合的源代码。|1134409|因此，当您想要做的只是迭代数组/列表或将其送入流或新的集合/数组时，最好创建一个新的数组，以便提供一个反向视图。|1134410|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Just for the sake of it. People often do only need a 'view' on an array or list in reversed order instead of a completely do not need a reversed array when working with streams and collections but a 'reversed' view on the original array/collection. , it is best to create a toolkit that has a reverse view on a list / array.
So create your Iterator implementation that takes an array or list and provide the input.
<pre><code>/// Reverse Iterator
public class ReverseIterator&lt;T&gt; implements Iterator&lt;T&gt; {
 private int index;
 private final List&lt;T&gt; list;
 public ReverseIterator(List&lt;T&gt; list) {
 this.list = list;
 this.index = list.size() - 1;
 }
 public boolean hasNext() {
 return index &gt;= 0 ? true : false;
 }
 public T next() {
 if(index &gt;= 0) 
 return list.get(index--);
 else 
 throw new NoSuchElementException();
 }
}
</code></pre>
An implementation for the array situation is quite similar. Of cause an iterator can be source for a stream or a collection as well.
So not always it is best to create a new array just to provide a reverse view when all you want to do is iterating over the array / list or feed it into a stream or a new collection / array.

blocks|key|1133646|text|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;+%2B%2Bi)
++++++++++++System.out.print(array[i]+%2B+"+");
++++}
++++public+static+void+reverse+(int+[]+array){
++++++++for(int+start=0,+end=array.length-1;+start<=end;+start%2B%2B,+end--){
++++++++++++int+aux+=+array[start];
++++++++++++array[start]=array[end];
++++++++++++array[end]=aux;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1133647|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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&lt;array.length; ++i)
 System.out.print(array[i] + " ");
 }
 public static void reverse (int [] array){
 for(int start=0, end=array.length-1; start&lt;=end; start++, end--){
 int aux = array[start];
 array[start]=array[end];
 array[end]=aux;
 }
 }
}
</code></pre>

blocks|key|1133671|text|在JAVA中试用此程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133672|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%2B%2B)+{

++++++++++++arr[i]+=+sc.nextInt();
++++++++++++System.out.print(arr[i]+%2B+"+");

++++++++++++System.out.println();
++++++++}

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

++++++++}

++++++++for+(int+i+=+0;+i+<+row;+i%2B%2B)+{
++++++++++++System.out.print(arr[i]+%2B+"+");
++++++++++++System.out.println();
++++++++}
++++}
}|code-block|syntax|javascript|1133673|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this program in JAVA :-

<pre><code>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 &lt; row; i++) {

 arr[i] = sc.nextInt();
 System.out.print(arr[i] + " ");

 System.out.println();
 }

 for (int i = 0; i &lt; 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 &lt; row; i++) {
 System.out.print(arr[i] + " ");
 System.out.println();
 }
 }
}
</code></pre>

blocks|key|1133754|text|尝试以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1133755|++++int+arr[]+=+new+int[]{1,2,3,4,5,6,7};
++++for(int+i=0;i<arr.length/2;i%2B%2B){
++++++++int+temp+=+arr[i];
++++++++arr[i]+=+arr[(arr.length-1)-i];
++++++++arr[(arr.length-1)-i]+=+temp;
+++++}
+++++System.out.println(Arrays.toString(arr));|code-block|syntax|javascript|1133756|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this code: 

<pre><code> int arr[] = new int[]{1,2,3,4,5,6,7};
 for(int i=0;i&lt;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));
</code></pre>

blocks|key|1349349|text|这里有一个简单而快速的解决方案。希望它能帮上忙！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349350|public+int[]+reverse(int[]+arr)+{
++++for(int+i+=+arr.length;+i+>+0+;+i--){
++++++++System.out.print(arr[i-1]+%2B+"+");
++++}
++++return+arr;
}|code-block|syntax|javascript|1349351|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple an quick solution. Hope it helps!.

<pre><code>public int[] reverse(int[] arr) {
 for(int i = arr.length; i &gt; 0 ; i--){
 System.out.print(arr[i-1] + " ");
 }
 return arr;
}
</code></pre>

blocks|key|1349427|text|反转数组的另一种方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349428|public+static+int+[]reversing(int[]+array){
++++int+arraysize+=+array.length;
++++int[]+reverse+=+new+int+[arraysize%2B1];
++++for(int+i=1;+i+<=+arraysize+;+i%2B%2B){
++++++++int+dec=+arraysize+-i;
++++++++reverse[i]+=+array[dec];
++++}
++++return+reverse;
}|code-block|syntax|javascript|1349429|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another way to reverse array 

<pre><code>public static int []reversing(int[] array){
 int arraysize = array.length;
 int[] reverse = new int [arraysize+1];
 for(int i=1; i &lt;= arraysize ; i++){
 int dec= arraysize -i;
 reverse[i] = array[dec];
 }
 return reverse;
}
</code></pre>

blocks|key|1349511|text|因为我打算保持我的原始Array不变，所以我用以下方式解决了这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349512|List<Integer>+normalArray=+new+ArrayList<>();
List<Integer>+reversedArray+=+new+ArrayList<>();

//+Fill+up+array+here

for+(int+i+=+1;+i+<=+normalArray.size();+i%2B%2B)+{
++reversedArray+.add(normalArray.get(normalArray.size()-i));
}|code-block|syntax|javascript|1349513|因此，基本上循环通过初始数组，并将所有值以相反的顺序添加到新的(颠倒的)数组中。列表的类型可以是任何类型。我多次使用此代码，这导致其他一些解决方案不起作用。|1349514|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As I intended to keep my original Array as it was, I solved this problem in the following manner:

<pre><code>List&lt;Integer&gt; normalArray= new ArrayList&lt;&gt;();
List&lt;Integer&gt; reversedArray = new ArrayList&lt;&gt;();

// Fill up array here

for (int i = 1; i &lt;= normalArray.size(); i++) {
 reversedArray .add(normalArray.get(normalArray.size()-i));
}
</code></pre>

So basically loop through the initial array and add all the values in reversed order to the new (reversed) array. The type of the list can be anything.
I work my way through this code multiple times, this causes some of the other solutions not to work.

blocks|key|1134184|text|+++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%2B%2B)
++++++++{
++++++++++++arra[i]+=+sc.nextInt();
++++++++}

++++++++System.out.println("Printing++Array+:+");
++++++++for(int+i+=+0;+i+<arra.length;i%2B%2B)
++++++++{
++++++++++++System.out.print(arra[i]+%2B+"+");
++++++++}

++++++++System.out.println();
++++++++System.out.println("Printing++Reverse+Array+:+");
++++++++for(int+i+=+arra.length-1;+i+>=0;i--)
++++++++{
++++++++++++System.out.print(arra[i]+%2B+"+");
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1134185|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> 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 &lt;arra.length;i++)
 {
 arra[i] = sc.nextInt();
 }

 System.out.println("Printing Array : ");
 for(int i = 0; i &lt;arra.length;i++)
 {
 System.out.print(arra[i] + " ");
 }

 System.out.println();
 System.out.println("Printing Reverse Array : ");
 for(int i = arra.length-1; i &gt;=0;i--)
 {
 System.out.print(arra[i] + " ");
 }
 }
}
</code></pre>

blocks|key|1348899|text|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("%25s+",+x);
++++++++++++System.out.println();

++++++++++++//print+out+array+in+reverse+order
++++++++++++for(int+i=stuff.length-1;+i+>=+0;+i--)
++++++++++++++++System.out.printf("%25s+",stuff[i]);++

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1348900|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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 &gt;= 0; i--)
 System.out.printf("%s ",stuff[i]); 

}
</code></pre>

blocks|key|1349120|text|你可以使用这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349121|public+final+class+ReverseComparator<T+extends+Comparable<T>>+implements++Comparator<T>+{
++@Override
++public+int+compare(T+o1,+T+o2)+{++++++
++++return+o2.compareTo(o1);
++}
}|code-block|syntax|javascript|1349122|一个简单的|1349123|Integer[]+a+=+{1,6,23,4,6,8,2}
Arrays.sort(a,+new+ReverseComparator<Integer>());|1349124|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use this

<pre><code>public final class ReverseComparator&lt;T extends Comparable&lt;T&gt;&gt; implements Comparator&lt;T&gt; {
 @Override
 public int compare(T o1, T o2) { 
 return o2.compareTo(o1);
 }
}
</code></pre>

An simply

<pre><code>Integer[] a = {1,6,23,4,6,8,2}
Arrays.sort(a, new ReverseComparator&lt;Integer&gt;());
</code></pre>

blocks|key|1349531|text|int[]+arrTwo+=+{5,+8,+18,+6,+20,+50,+6};

++++for+(int+i+=+arrTwo.length-1;+i+>+0;+i--)
++++{
++++++++System.out.print(arrTwo[i]+%2B+"+");
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1349532|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int[] arrTwo = {5, 8, 18, 6, 20, 50, 6};

 for (int i = arrTwo.length-1; i &gt; 0; i--)
 {
 System.out.print(arrTwo[i] + " ");
 }
</code></pre>

I am trying to reverse an int array in Java.

This method does not reverse the array. 

<pre><code>for(int i = 0; i &lt; validData.length; i++)
{
 int temp = validData[i];
 validData[i] = validData[validData.length - i - 1];
 validData[validData.length - i - 1] = temp;
}
</code></pre>

What is wrong with it?

How do I reverse an int array in Java?

单元测试

Java

我正在尝试在Java中反转一个整型数组。此方法不反转数组。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

问如何在Java中反转int数组？
EN

回答 40

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中反转int数组？EN

回答 40

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中反转int数组？
EN