/*
需求：给定一个数组{1,2,3,4,5,6,7,8,9}。获取数组中最大值和最小值

思想：1、获取最大值要进行比较，每一次比较都会获取一个最大值，该值不确定，定义一个变量进行存储。
          2、让数组中每一个元素和这个变量进行比较，如果大于该变量的值，就记录比较后的较大值。

步骤：1、定义一个变量，用数组中任意一个值做初始化值.明确结果，最大值是int类型
          2、通过循环语句对数组进行遍历,未知的内容，用数组 int[]
          3、在变量过程中定义判断条件，如果遍历到的元素比变量中的大，就赋值给该变量。
*/
class Shuzubj
{
public static void main(String[] args)
        {
                int[] arr={1,2,3,4,5,6,7,8,9};
                int big = getmax(arr);
                int sma = getmin(arr);
                System.out.println("big="+big);
                System.out.println("sma="+sma);
        }

        public static int getmax(int[] arr)
        {
                int big = 0;

                for (int x =1;x<arr.length ;x++ )
                {
                        if(arr[x]>arr[big])
                                big =x;
                }
                return arr[big];
        }
        public static int getmin(int[] arr)
        {
                int sma = 0;

                for (int x =1;x<arr.length ;x++ )
                {
                        if(arr[x]<arr[sma])
                                sma =x;
                }
                return arr[sma];
        }




} 我想的就是在提高复用性的前提先 能不能简化

可以，你可以把获取最大值和最小值、打印输出等方法都封装在一个工具类中，当然这些方法都用静态修饰，以便直接可以通过类名去调用。这样，你不仅在这个程序中能使用，在其他的程序你也可以直接调用。
下面这个是课堂上的一个实例，你可以看一下。

1. 
   
2. public class ArrayTool
   
3. {
   
4. 
   
5. //空参数构造函数。
   
6. private ArrayTool(){} //将构造函数私有化，以防止建立对象
   
7. 
   
8. //获取一个整形数组中的最大值。
   
9. public static int getMax(int[] arr)
   
10. {
    
11. int max = 0;
    
12. for(int x=1; x<arr.length; x++)
    
13. {
    
14. if(arr[x]>arr[max])
    
15. max = x;
    
16. }
    
17. return arr[max];
    
18. }
    
19. 
    
20. //获取一个整形数组中的最小值。
    
21. public static int getMin(int[] arr)
    
22. {
    
23. int min = 0;
    
24. for(int x=1; x<arr.length; x++)
    
25. {
    
26. if(arr[x]<arr[min])
    
27. min = x;
    
28. }
    
29. return arr[min];
    
30. }
    
31. 
    
32. //给int数组进行选择排序。
    
33. public static void selectSort(int[] arr)
    
34. {
    
35. for (int x=0; x<arr.length-1 ; x++ )
    
36. {
    
37. for(int y=x+1; y<arr.length; y++)
    
38. {
    
39. if(arr[x]>arr[y])
    
40. {
    
41. swap(arr,x,y);
    
42. }
    
43. }
    
44. }
    
45. }
    
46. 
    
47. //给int数组进行冒泡排序。
    
48. public static void bubbleSort(int[] arr)
    
49. {
    
50. for (int x=0; x<arr.length-1 ; x++ )
    
51. {
    
52. for(int y=0; y<arr.length-x-1; y++)
    
53. {
    
54. if(arr[y]>arr[y+1])
    
55. {
    
56. swap(arr,y,y+1);
    
57. }
    
58. }
    
59. }
    
60. }
    
61. 
    
62. //给数组中元素进行位置的置换。
    
63. private static void swap(int[] arr,int a,int b)
    
64. {
    
65. int temp = arr[a];
    
66. arr[a] = arr[b];
    
67. arr[b] = temp;
    
68. }
    
69. 
    
70. //用于打印数组中的元素。打印形式是
    
71. public static void printArray(int[] arr)
    
72. {
    
73. System.out.print("[");
    
74. for(int x=0; x<arr.length; x++)
    
75. {
    
76. if(x!=arr.length-1)
    
77. System.out.print(arr[x]+", ");
    
78. else
    
79. System.out.println(arr[x]+"]");
    
80. }
    
81. }
    
82. }
    

复制代码

最简单的用冒泡排序！升序降序我随你了！
取第一个最后一个就OK了！

这是最简单的方法：
class Shuzubj
{
public static void main(String[] args)
       {
                Integer[] arr={1,2,3,4,5,6,7,8,9};
               
              List<Integer> list= Arrays.asList(arr);
               
            int max=Collections.max(list);
            int min=Collections.min(list);
             System.out.println("max="+max);
             System.out.println("min="+min);              
        }

}

没有简化的方法，无论你用jdk提供的函数还是你上面自己写的函数，这已经是求最大值的时间复杂度最低的了，除非本来数组就是有序的，不然只有一个一个的比较。

1. /*
   
2. * 打印最大值和最小值。
   
3. * 由于你提供的数组里的元素已经排序好。
   
4. * 为了使getNum()表现的更明显，就第一位前和最后一位后分别加了一个数字。
   
5. * 步骤：可以将数组中的元素以升序排序。
   
6. * 获取最大值：为排序后数组中的最后一个元素。
   
7. * 获取最小值：为排序后数组中的第一个元素。
   
8. */
   
9. public class Shuzubj{
   
10.         public static void main(String[] args) {
    
11.                 Demo d = new Demo();
    
12.                 int[] arr={432, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,0};
    
13.                 d.selectSort(arr);//排序后
    
14.                 System.out.println("big = " + arr[arr.length -1]);//最大值是数组中最后一个元素。
    
15.                 System.out.println("sma = "+ arr[0]);//最小值是数组中第一个元素。
    
16.         }
    
17. }
    
18. class Demo{//工具类
    
19.         public static void selectSort(int[] arr){//选择排序：升序。
    
20.                 for (int i = 0; i < arr.length - 1; i++){
    
21.                         for (int j = i + 1; j < arr.length; j++){
    
22.                                 if (arr[i] > arr[j]){//如果第一个元素比第二个元素小。就置换位置。
    
23.                                 int temp = arr[i];
    
24.                                 arr[i] = arr[j];
    
25.                                 arr[j] = temp;
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.         }
    
30. }

复制代码

//用一个boolean值来判断你是取最大值，还是最小值。
class Shuzubj {
        public static void main(String[] args) {
                int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                int big = getMaxMin(arr, true);
                int sma = getMaxMin(arr, false);
                System.out.println("big=" + big);
                System.out.println("sma=" + sma);
        }

        public static int getMaxMin(int[]arr, boolean flag) {//用一个boolean值来判断你是取最大值，还是最小值。
                int num = 0;
                for (int x = 1; x < arr.length; x++) {
                        if (flag) {
                                if (arr[num] < arr[x]) {

                                }
                        } else {
                                if (arr[num] > arr[x]) {
                                }
                                num = x;
                        }
                }
                return arr[num];
        }
}

     用Arrays工具类的sort方法先把数组排序，之后获得一头一尾不就是最小值和最大值了吗，但也许这不是楼主想要的，不管怎么样，班门弄斧一下下。
     public static void main(String[] args) {
                int[] arr = {8,0,9,5,2,9,12,4};
                Arrays.sort(arr);
                int max = arr[arr.length-1];
                int min = arr[0];
                System.out.println(max+"------"+min);
        }

如果数组里的元素是无序的，就先把数组排序然后就能很容易的找出，最大和最小值
最快的是有 java.util包下的 Arrays类的 排序方法
或者用毕老师视频里的冒泡排序

1. public class Test2 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 //定义数组，并初始化
   
5.                 int[] a = { 7, 6, 20, 1, 5, 40, 33, 6, 7 };
   
6.                 //定义中间变量，方便调换数组中元素的位置
   
7.                 int temp = 0;
   
8.                 //数组长度
   
9.                 int len = a.length;
   
10.                 //遍历数组
    
11.                 for (int i = 0; i < a.length-1; i++) {
    
12.                        
    
13.                         for (int j = 0; j < a.length-1 - i; j++) {
    
14.                                 //比较相邻两个元素，值较大的往后移位
    
15.                                 if (a[j] > a[j + 1]) {
    
16.                                         temp = a[j];
    
17.                                         a[j] = a[j + 1];
    
18.                                         a[j + 1] = temp;
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.                
    
23.                
    
24.                 //最大值
    
25.                 System.out.println(a[0]);
    
26. 
    
27.                 //最小值
    
28.                 System.out.println(a[len-1]);
    
29.                
    
30.         }
    
31. }

复制代码