1 /*
 2   遍历数组，已经用for循环解决掉了
 3   数组越来越多
 4   如何去遍历呢
 5   采用函数的方式，将遍历数组的功能，定义在函数中
 6   直接调用函数的遍历功能就可以了
 7 */
 8 class ArrayDemo5{
 9     /*
10      分析步骤：
11       这个函数就负责遍历数组，并打印在命令行上
12       1. 有没有运算结果，没，void
13       2. 有没有未知数参与函数运算，就那数组
14     */
15 
16     /*
17     printArray函数，就负责遍历数组，打印数组
18     调用这个函数的时候，传递函数进来
19     */
20     public static void printArray(int[] arr)
21     {
22         for(int x = 0; x<arr.length ;x++){
23             if(x!=arr.length-1){
24                 System.out.print(arr[x]+",");
25             }
26             else{
27              System.out.print(arr[x]);
28             }
29     
30         }
31         System.out.println();
32     }
33     public static void main(String[] args) 
34     {
35         int[] arr ={34,435,324,324,3246,63,3};
36         int[] arr1 ={34,435,324,324,3246,63,3,5};
37         printArray(arr);
38     //    printArray(arr1);
39     }
40 }

 1 /*
 2   数组中获取最值的操作
 3   最大值，最小值
 4 */
 5 class  ArrayDemo6{
 6     public static void main(String[] args) {
 7         int[] arr = {4,3,2,6,1,0};
 8         int max = getMax(arr);
 9 
10         System.out.println("max="+max);
11     }
12     /*
13      定义函数，来获取数组中的最大值
14      1 明确函数计算后的结果是什么，int
15      2 未知数据就是数组
16     */
17 
18     public static int getMax(int[] arr){
19         //定义变量，记录数组中0下标上的数据
20         int max = 0;//4
21         //遍历数组，分别进行比较，保留最大值
22         for(int x = 0 ; x<arr.length;x++){
23             if(arr[max]<arr[x]){
24                max = x;   
25             }
26         }
27         return arr[max];
28     }
29 
30     public static int getMin(int[] arr){
31         int min = 0;//4
32         //遍历数组，分别进行比较，保留最大值
33         for(int x = 0 ; x<arr.length;x++){
34             if(arr[min]>arr[x])
35             {
36                min = x;  
37             }
38         }
39         return arr[min];
40     }
41 }

 1         /*
 2          选择排序的三个步骤
 3          1. 遍历数组，把数组中每个元素分别取出
 4          2. 出去后，进行大小的比较
 5          3. 进行数组的换位置
 6         */
 7         //选择排序
 8         for (int x = 0; x < arr.length - 1; x++) {
 9             for (int y = x + 1; y < arr.length; y++) {
10                 // x=1 y=1+1=2
11                 if (arr[x] > arr[y])// arr[1]>arr[2]
12                 {
13                     int temp = arr[x];
14                     arr[x] = arr[y];
15                     arr[y] = temp;
16                 }
17             }
18         }
19 
20         /*
21          定义函数实现冒泡排序
22          1. 确定函数运算后没有返回值
23          2. 不确定的数据就是数组
24 
25          说明：
26            内圈循环，-x是为了比较的次数一次一次在减少
27                       -1是为了防止数组越界异常
28           希尔排序，公认的效率最高的排序方式
29           插入形式的排序算法
30         */
31         //冒泡排序
32         for(int x =0 ;x<arr.length; x++){
33            for(int y = 0 ; y <arr.length-x-1;y++){
34               if(arr[y]>arr[y+1]){
35                  int temp = arr[y];
36                  arr[y] = arr[y+1];
37                  arr[y+1] = temp;
38               }
39            }
40         }