遇到这样一个题目，按照我自己的思路，有一步需要将一个int数组取出一个后前后两部分反转，重新构成一个新的数组

1. /*
   
2. 思路：
   
3. 有1到x的一个int型数组，把第y个数字去掉（y>x时，再次遍历数组，如此往复直到数到y），
   
4. 将数组y之后的数挪到前面、y前面的数挪到后面，从新组成一个长为x-2的数组
   
5. */
   

复制代码

我试了很多次，也想了集合的方法，但因基础不牢固，没找到合适的方法。
希望各位朋友帮忙解决一下。

我写了两种方法，你都看看吧

  

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. import java.util.Collections;
   
4. import java.util.List;
   
5. 
   
6. public class Test {
   
7. public static void main(String[] args) {
   
8. 
   
9. Integer[] arrays = new Integer[] { 1, 2, 3, 4, 5 };
   
10. 
    
11. arrays = operation1(arrays, 9);
    
12. 
    
13. for (int i = 0; i < arrays.length; i++) {
    
14. System.out.println(arrays[i]);
    
15. }
    
16. }
    
17. 
    
18. private static Integer[] operation1(Integer[] arrays, int index) {
    
19. 
    
20. index = index % arrays.length;//取整计算index
    
21. 
    
22. List<Integer> list = new ArrayList<Integer>();
    
23. //List<Integer> list = Arrays.asList(arrays);
    
24. 
    
25. for (int i = 0; i < arrays.length; i++) {
    
26. list.add(arrays[i]);
    
27. }
    
28. 
    
29. List<Integer> list1 = list.subList(0, index-1);
    
30. List<Integer> list2 = list.subList(index, list.size());
    
31. 
    
32. list2.addAll(list1);
    
33. 
    
34. Integer[] retVal = new Integer[arrays.length - 1];
    
35. 
    
36. return list2.toArray(retVal);
    
37. }
    
38. 
    
39. private static Integer[] operation2(Integer[] arrays, int index) {
    
40. 
    
41. index = index % arrays.length;//取整计算index
    
42. 
    
43. Integer[] retVal = new Integer[arrays.length - 1];
    
44. 
    
45. for (int i = 0; i <= retVal.length - index; i++) {
    
46. retVal[i] = arrays[index + i];
    
47. }
    
48. 
    
49. for (int i = retVal.length - index + 1; i < retVal.length; i++) {
    
50. retVal[i] = arrays[i - arrays.length + index];
    
51. }
    
52. 
    
53. return retVal;
    
54. }
    
55. 
    
56. }

复制代码

//不知道符不符合题意
package com.ccsu.xie.test;

import java.util.Iterator;
import java.util.LinkedList;

public class ArrayReverse {
        private LinkedList<Integer> li = new LinkedList<Integer>();//存储预操作数组
        private LinkedList<Integer> result = new LinkedList<Integer>(); //存储结果数据
        public static void main(String[] args) {
                int [] array ={1,2,3,4,5,6,7};
                ArrayReverse ar = new ArrayReverse();
                ar.put(array);
                ar.dReverse(3); //删除4
                ar.show();  //输出5,6,7,1,2,3
        }
       
        public void put(int [] array){
                for(int num : array){
                        li.add(num);
                }
        }
       
       
        public void dReverse(int index){
                if(index>li.size())
                        throw new RuntimeException("已超出当前容器容量");
       
                for(int j =index+1;j<li.size();j++){
                        result.add(li.get(j));
                }
                for(int i =0;i<index;i++){
                        result.add(li.get(i));
                }
               
               
        }
       
        public void show(){
                Iterator<Integer> it = result.iterator();
                while(it.hasNext()){
                        System.out.print(it.next()+" ");
                }
        }

}

黄小贝 发表于 2013-4-9 02:27
我写了两种方法，你都看看吧

谢谢，和我想要的一样，嘿嘿，要是多点注释就更好了。谢谢~

谢达 发表于 2013-4-9 09:38
//不知道符不符合题意
package com.ccsu.xie.test;

删除的数不是直接给出的，如果y小于x时y就是要删除的元素，如果y大于数组x时是循环遍历数组得出要删除的元素的。还是很感谢你！