编一个程序，输入10个整数，并放在数组中，先降序输出所有的数，再统计并输出其中正数、负数和零的个数

互相交流学习，楼主要是有更好的写法，或者别的思路，一起交流学习哈

1. package cn.tck.aaa;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /**
   
6. * 输入10个整数，并放在数组中，先降序输出所有的数，再统计并输出其中正数、负数和零的个数
   
7. *
   
8. * @author Administrator
   
9. *
   
10. */
    
11. public class Demo {
    
12. 
    
13.         public static void main(String[] args) {
    
14.                
    
15.                 // 初始化数据
    
16.                 int[] arr = new int[10];       
    
17.                
    
18.                 // 输入数据
    
19.                 inputData(arr);                       
    
20.                
    
21.                
    
22.                 System.out.println("未排序之前的数据");
    
23.                 printArr(arr);                
    
24.                
    
25.                 // 冒泡排序，降序输出排列       
    
26.                 int[] newArr = sortArr(arr);       
    
27.                
    
28.                 // 遍历数组
    
29.                 System.out.println("\n降序输出所有的数");
    
30.                 printArr(newArr);
    
31.                
    
32.                 // 统计数据
    
33.                 contNum(newArr);                                               
    
34.         }
    
35. 
    
36.         /*
    
37.          * 统计并输出其中正数、负数和零的个数
    
38.          *
    
39.          */
    
40.         public static void contNum(int[] newArr) {
    
41.                 int positiveNum = 0;
    
42.                 int minusNegativeNum = 0;
    
43.                 int zeroNum = 0;
    
44.                 for (int i : newArr) {
    
45.                         if (i > 0) {
    
46.                                 positiveNum++;
    
47.                         } else if (i < 0) {
    
48.                                 minusNegativeNum++;
    
49.                         } else {
    
50.                                 zeroNum++;
    
51.                         }
    
52.                 }
    
53.                 System.out.println("正数的个数：" + positiveNum + "负数的个数：" + minusNegativeNum
    
54.                                 + "零的个数：" + zeroNum);
    
55.         }
    
56. 
    
57.         /*
    
58.          * 冒泡排序
    
59.          */
    
60.         public static int[] sortArr(int[] arr) {
    
61.                 for (int i = 0; i < arr.length; i++) {
    
62.                         for (int j = i + 1; j < arr.length; j++) {
    
63.                                 if (arr[i] < arr[j]) {
    
64.                                         arr[i] = arr[i] ^ arr[j];
    
65.                                         arr[j] = arr[j] ^ arr[i];
    
66.                                         arr[i] = arr[i] ^ arr[j];
    
67.                                 }
    
68.                         }
    
69.                 }
    
70.                 return arr;
    
71.         }
    
72. 
    
73.         /*
    
74.          * 输入数据，保存到数组中
    
75.          */
    
76.         public static void inputData(int[] arr) {
    
77.                 Scanner sc = new Scanner(System.in);
    
78.                 for (int i = 0; i < arr.length; i++) {
    
79.                         arr[i] = sc.nextInt();
    
80.                 }
    
81.         }
    
82. 
    
83.         /*
    
84.          * 遍历数组
    
85.          */
    
86.         public static void printArr(int[] arr) {
    
87.                 for (int i : arr) {
    
88.                         System.out.print(i + "\t");
    
89.                 }
    
90.         }
    
91. 
    
92. }
    

复制代码

1. 
   
2. /*
   
3.         编一个程序:
   
4.         输入10个整数，并放在数组中，先降序输出所有的数，
   
5.         再统计并输出其中正数、负数和零的个数
   
6. 
   
7.         思路:
   
8.                 1.定义一个int型数组,存储循环输入的10个整数
   
9.                 2.调用Arrays.sort(int[] arr)方法对这个数组进行排序
   
10.                 3.循环遍历倒序输出数组中的元素,同时对元素进行判断,统计正数,负数,和零的个数
    
11. */
    
12. 
    
13. import java.util.Scanner;
    
14. import java.util.Arrays;
    
15. 
    
16. class Test_Arrays {
    
17. 
    
18.         public static void main(String[] args) {
    
19. 
    
20.                 //定义一个int型数组,存储循环输入的10个整数
    
21.                 int[] arr = new int[10];
    
22. 
    
23.                 Scanner sc = new Scanner(System.in);
    
24.                
    
25.                 int z = 0;                //统计正数个数
    
26.                 int f = 0;                //统计负数个数
    
27.                 int zero = 0;        //统计为零个数
    
28. 
    
29.                 //使用循环录入10个整数
    
30.                 for (int i=0; i<arr.length; i++) {
    
31.                         System.out.println("请输入第" + (i+1) + "个整数:");
    
32.                         arr[i] = sc.nextInt();
    
33.                 }
    
34. 
    
35.                 //调用Arrays中的sort()方法,对数组进行排序
    
36.                 Arrays.sort(arr);
    
37. 
    
38.                 //遍历倒序输出数组中的元素
    
39.                 for (int i=arr.length-1; i>=0; i--) {
    
40.                         System.out.print(arr[i] + " ");
    
41.                         //判断各个元素的大小,分别进行统计
    
42.                         if (arr[i] > 0) {        //大于0,z++
    
43.                                 z++;
    
44.                         } else if (arr[i] == 0) {        //等于0,zero++
    
45.                                 zero++;
    
46.                         } else {                        //小于0,f++
    
47.                                 f++;
    
48.                         }
    
49.                 }
    
50. 
    
51.                 System.out.println();
    
52. 
    
53.                 System.out.println(        "数组中正数的个数: " + z +
    
54.                                                         "    \n负数的个数: " + f +
    
55.                                                         "    \n零的个数: " + zero);
    
56.         }
    
57. }
    

复制代码