1. 4.分析以下需求，并用代码实现：（扩展）
   
2.         (1)键盘录入6个int类型的数据存数数组arr中
   
3.         (2)将arr数组中的内容反转
   
4.         (3)将翻转后的数组角标为奇数的互相交换 1和3换, 3和5换,以此类推
   
5.         (4)最后将数组最后一个角标为奇数的元素 和数组中第一个角标为奇数的元素交换
   
6.         (5)打印最终的数组(实现了1-4步之后的数组)
   
7.         (6)如：用户输入的6个int数字为[1,2,3,4,5,6],最后输出的结果为[6, 5, 4, 1, 2, 3]

复制代码

有点绕，但代码还是简单的

1. import java.util.*;
   
2. class ArrTest
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Scanner s = new Scanner(System.in);
   
7.                 int[] arr = new int[6];
   
8.                 for(int x = 0;x<6;x++)
   
9.                 {
   
10.                         int a = s.nextInt();
    
11.                         arr[x] = a;
    
12.                 }
    
13.                 reverseArray(arr);
    
14.                 bianLi(arr);
    
15.                 for(int x = 0;x<4;x++)//x<4防止角标越界
    
16.                 {
    
17.                         if(x%2==0)
    
18.                                 continue;
    
19.                         swap(arr,x,x+2);
    
20.                         bianLi(arr);
    
21.                        
    
22.                 }
    
23.                 for(int x = 0;x<arr.length;x++)
    
24.                 {
    
25.                         if(x%2==1)
    
26.                         {
    
27.                                 for(int y = arr.length-1;y>0;y--)
    
28.                                 {
    
29.                                         if(x%2==1)
    
30.                                         {
    
31.                                                 swap(arr,x,y);
    
32.                                                 break;//产生结果就结束循环
    
33.                                         }
    
34.                                 }
    
35.                                 break;//产生结果就结束循环
    
36.                         }
    
37.                        
    
38.                 }
    
39.                 bianLi(arr);
    
40.                
    
41.         }
    
42.        
    
43.         public static void reverseArray(int[] arr)
    
44.         {
    
45.                 for(int start=0,end=arr.length-1; start<end ; start++,end--)
    
46.                 {
    
47.                         swap(arr, start, end);
    
48.                 }
    
49.         }
    
50.        
    
51.         public static void swap(int[] arr, int a, int b)
    
52.         {
    
53.                 int temp = arr[a];
    
54.                 arr[a] = arr[b];
    
55.                 arr[b] = temp;
    
56.         }
    
57.        
    
58.         public static void bianLi(int[] arr)
    
59.         {
    
60.                 for(int x = 0;x<arr.length;x++)
    
61.                 {
    
62.                         System.out.print(arr[x]);
    
63.                 }       
    
64.                 System.out.println();
    
65.         }
    
66. }

复制代码

看黑马Java入门视频，足以解决这个问题。

qt520 发表于 2016-3-9 09:32
有点绕，但代码还是简单的

看了下 代码写的还行。怎么不写点注释啊？

1. /*
   
2. 需求：分析以下需求，并用代码实现
   
3.         (1)键盘录入6个int类型的数据存数数组arr中
   
4.         (2)将arr数组中的内容反转
   
5.         (3)将翻转后的数组角标为奇数的互相交换 1和3换, 3和5换,以此类推
   
6.         (4)最后将数组最后一个角标为奇数的元素 和数组中第一个角标为奇数的元素交换
   
7.         (5)打印最终的数组(实现了1-4步之后的数组)
   
8.         (6)如：用户输入的6个int数字为[1,2,3,4,5,6],最后输出的结果为[6, 5, 4, 1, 2, 3]
   
9. 思路：
   
10.         1.因为要键盘录入数据，所以要用到Scanner对象。有因为要将录入的数据存入数组中，所以我用静态初始化的方式定义数组。
    
11.         2.反转数组中的数据其实就是将第一个元素和最后一个元素调换，然后再将第二个元素与倒数第二个元素调换……………………，由此可以看出每进行一次调换就有两个元素发生了变化。
    
12.                 所以只需要操作数组长度的二分之一次就可以完成反转，这里我用for循环完成。
    
13.         3.因为要对数组角标为奇数的元素位置互换（1和3换  3和5换），所以我从3角标开始往后循环，然后判断当前角标%2时候为1如果为1就和当前角标-2角标所对应的元素互换。
    
14.         4.又因为最后一个角标为奇数的元素还要和第一个角标为奇数的元素（1角标）位置进行互换，所以在上一步的循环中还要判断当前为奇数的角标是不是最一个奇数角标，
    
15.                 如果是就在和1角标互换一次。
    
16.         5.将数组中的每个元素打印输出。
    
17. */
    
18. 
    
19. import java.util.Scanner;                                                                                                        //导包
    
20. class Day05Task4 {
    
21.         public static void main(String[] args) {
    
22.                 int[] arr = new int[6];
    
23.                 Scanner sc = new Scanner(System.in);                                                                //创建键盘录入对象
    
24.                 //思路中的第1步：初始化数组。
    
25.                 for (int x = 0; x < arr.length; x++) {
    
26.                         System.out.println("请输入第 " + (x + 1) + " 个整数：");
    
27.                         arr[x] = sc.nextInt();                                                                                        //接受键盘录入的数据，并放到素组中。
    
28.                 }
    
29.                 printArray(arr);                                                                                                        //打印数组中的元素
    
30. 
    
31.                 //思路中的第2步：反转数组。
    
32.                 for (int x = 0; x < arr.length / 2; x++) {
    
33.                         changeArray(arr, x, arr.length - 1 - x);
    
34.                 }
    
35. 
    
36.                 //思路中的第3步：奇数角标的互换 + 第4步：最后一个奇数与第一个奇数角标的值互换。
    
37.                 for (int x = 3; x < arr.length; x++) {
    
38.                         if (x % 2 == 1) {
    
39.                                 changeArray(arr, x, x-2);                                                                        //位置互换
    
40.                                 if (x == arr.length-1 || ++x == arr.length - 1) {                        //如果x已经是最大角标，或者x+1为最大角标，就说明x是最后一个奇数角标
    
41.                                         changeArray(arr, x, 1);
    
42.                                 }
    
43.                         }
    
44.                 }               
    
45.                 printArray(arr);                                                                                                        //打印数组中的元素
    
46.         }
    
47. 
    
48.         //定义一个函数，函数的功能是转换数组元素的位置
    
49.         public static void changeArray(int[] arr, int a, int b) {                                //需要三个参数，int一维数组、int、int。没有返回值。
    
50.                 int temp = arr[a];
    
51.                 arr[a] = arr[b];
    
52.                 arr[b] = temp;
    
53.         }
    
54. 
    
55.         //定义一个函数，功能是遍历打印数组
    
56.         public static void printArray(int[] arr) {                                                                //需要一个参数，int一维数组。没有返回值。
    
57.                 System.out.println("数组中的元素有（0~" + arr.length + "角标)：");
    
58.                 for (int x = 0; x < arr.length; x++) {
    
59.                         System.out.print(arr[x] + "  ");
    
60.                 }
    
61.                 System.out.println("\n");
    
62.         }
    
63. }

复制代码

感觉好难，还没学

好他妈的男啊 ，，，，，，，，，，