求教，为什么程序最大值输出为7，最小值却为2呢？
public class MaxMin {
    public static void main(String[] args) {
        int[] arr={1,5,3,4,2,7,6};
        MaxMin mm=new MaxMin();
        int max=mm.max(arr);
        System.out.println("max="+max);
        int min=mm.min(arr);
        System.out.println("min="+min);
        
    }
    public int min(int[] arr){
        int min=0;
        for(int i=1; i<arr.length; i++){
         if(arr[min]>arr){
                min=i;
            }
        }
        return arr[min];
    }
    public int max(int[] arr){
        for(int j=1; j<arr.length; j++){
            if(arr[0]<arr[j])
                arr[0]=arr[j];
        }
        return arr[0];
    }

}

中间min是
                for(int i=1; i<arr.length; i++){
                        if(arr[min]>arr[i]){
                                min=i;
                        }
不好意思，少复制了。

        public static void main(String[] args) {
                int[] arr = { 1, 5, 3, 4, 2, 7, 6 };
                MaxMin mm = new MaxMin ();
                int max = mm.max(arr);
                System.out.println("max=" + max);
                int min = mm.min(arr);
                System.out.println("min=" + min);

        }

        public int min(int[] arr) {
                int min =arr[0];
                for (int i = 1; i < arr.length; i++) {
                        if (min > arr) {
                                min=arr; //你这里的算法有问题，需要改为arr[min] = i;
                        }
                }
                return min        }

        public int max(int[] arr) {
                for (int j = 1; j < arr.length; j++) {
                        if (arr[0] < arr[j])
                                arr[0] = arr[j];
                }
                return arr[0];
        }

郭宝伦 发表于 2013-3-10 20:56
你的min方法的 if(arr[min]>arr)少了 应该改为 if(arr[min]>arr)
至于为什么是min 2 是因为 main方法 int  ...

我写了，但是我复制到贴上就没有实际上是有的

数组比较有两种方法，一种是交换下标，一种是交换数组中的元素。从楼主的代码可是看出，楼主似乎在尝试这两种方法，将max()方法稍加修改就好了。如下

非常抱歉，我刚才回答的是错的，我执行看了一下，你的代码算法是没有问题，程序输出也是正确的。
至于为什么min=2而不1。
原因是：数组是引用类型，你在求最大值的时候，将最大值赋值给arr[0]了，所以求了最大值后，数组的元素是{ 7, 5, 3, 4, 2, 7, 6 };此时最小的就是2了，所以输出min=2
你在min方法中添加
for (int i = 0; i < arr.length; i++) {
System.out.println("---"+arr[i]);       
}
你就会发现问题了，呵呵
希望对你有所帮助。

这个应该是你完整的方法吧。
public class MaxMin {
    public static void main(String[] args) {
        int[] arr={1,5,3,4,2,7,6};
        MaxMin mm=new MaxMin();
        int max=mm.max(arr);                                       
        System.out.println("max="+max);                             //先调用了max方法，第一次循环,把arr[0]中的值1,被arr[1]中的5覆盖了。
        int min=mm.min(arr);
        System.out.println("min="+min);
        
    }
    public int min(int[] arr){
        int min=0;
        for(int i=1; i<arr.length; i++){
            if(arr[min]>arr[i]){                  //这里求最小或最大值的时候，最好用数组交换。定义一个中间元素temp来互换数组元素
                min=i;                                  //否则，你的主函数，先调用的求最大值时，就会比较5比1大时，把arr[0]中的值1覆盖。再调用求最
                                                                              //小值的方法，就会只能得到2为最小值。
                                                                                                                          //不然，你在调用求min的时候，可以把max方法与max调用及max输出，全部注释掉就可以了。
            }
        }
        return arr[min];
    }
    public int max(int[] arr){
        for(int j=1; j<arr.length; j++){
            if(arr[0]<arr[j])
                arr[0]=arr[j];
        }
        return arr[0];
    }

}

1. class MaxMin{        
   
2.     public int min(int[] arr){
   
3.             //定义一个参数用来存储较小值
   
4.             int min = arr[0];
   
5.             for(int i=1; i<arr.length; i++){
   
6.                     if(min>arr[i])
   
7.                             min=arr[i];
   
8.             }
   
9.             return min;
   
10.     }
    
11.    
    
12.     //下面这个是降序的选择排序吧
    
13.     public int max(int[] arr){
    
14.         //定义一个参数用来存储较大值
    
15.         int max = arr[0];
    
16.         for(int j=1; j<arr.length; j++){
    
17.             if(max<arr[j])
    
18.                 max=arr[j];
    
19.         }
    
20.         return max;
    
21.     }
    
22. 
    
23. }
    
24. 
    
25. public class MaxMinTest{
    
26.         public static void main(String[] args){
    
27.                  
    
28.         int[] arr={1,5,3,4,2,7,6};
    
29.         
    
30.         MaxMin mm=new MaxMin();
    
31.         
    
32.         int max=mm.max(arr);
    
33.         System.out.println("max="+max);
    
34.         
    
35.         int min=mm.min(arr);
    
36.         System.out.println("min="+min);
    
37.         }
    
38. }

复制代码

觉得你的代码看起来怪怪的修改了一下。

因为数组在java中是引用型数据，即在调用函数传值时类似于C语言的指针，给过去的是地址，所以在所调用的函数中改变了数组的数据，原始的数据也就跟着发生了改变，你在调用max方法的时候将2赋值给了arr[0],所以原本a[0]中的数据就改变了

1. public class MaxMin {
   
2.     public static void main(String[] args) {
   
3.         int[] arr={1,5,3,4,2,7,6};
   
4.         for(int first = 0; first < arr.length;first++){
   
5.                 System.out.print(arr[first]+ " ");
   
6.         }
   
7.         MaxMin mm=new MaxMin();
   
8.         int max=mm.max(arr);
   
9.         System.out.println("max="+max);
   
10.         int min=mm.min(arr);
    
11.         for(int second = 0; second < arr.length;second++){
    
12.                 System.out.print(arr[second]+ " ");
    
13.                                                          }
    
14.         System.out.println("min="+min);
    
15.         for(int third = 0; third < arr.length;third++){
    
16.                 System.out.print(arr[third]+ " ");
    
17.         }
    
18.         
    
19.     }
    
20.     public int min(int[] arr){
    
21.         int min=0;
    
22.         for(int i=0; i<arr.length; i++){
    
23.          if(arr[min]>arr[i]){
    
24.                 min=i;
    
25.             }
    
26.         }
    
27.         return arr[min];
    
28.     }
    
29.     public int max(int[] arr){
    
30.         for(int j=1; j<arr.length; j++){
    
31.             if(arr[0]<arr[j])
    
32.                 arr[0]=arr[j];
    
33.         }
    
34.         return arr[0];
    
35.     }
    
36. 
    
37. }
    

复制代码

大哥，你的求最大值得方法，最后是把数组重新排序，你把最大值7 赋给了arr[0]，最小值1 被覆盖掉了，所以你第一次调用arr.max（） 的时候，数组的排序已经变化了，1 被 7 覆盖了，所以当你调用 arr.min（）的时候，是判断的新排列的数组，所以最小值是2了，我给你加了几个判断语句，可以显示调用前后的变化。提醒你一句，你可以引新变量变量，不要影响原数组，把 最大值最小值赋给新变量。希望能帮到你

public int max(int[] arr){
        for(int j=1; j<arr.length; j++){
            if(arr[0]<arr[j])//楼主这里的算法有问题，arr[0] 写死了，就是第一个元素
                arr[0]=arr[j];
        }
        return arr[0];
应该：
public static int getMax(int[] arr)
        {
                int max=0;
                for(int i=0;i<arr.length;i++)
                {
                        if(arr[i]>arr[max])
                                max=i;
                }
                return max;
        }
    }

呵呵同学:其实是你之前的求最大值方法出现了问题:

               int[] arr={1,5,3,4,2,7,6};
                System.out.println(Arrays.toString(arr));     //Arrays.toString(arr) 是返回int数组内容的字符串表示形式
                MaxMin mm=new MaxMin();
                int max=mm.max(arr);
                System.out.println("max="+max);
                System.out.println(Arrays.toString(arr));
                int min=mm.min(arr);
                System.out.println("min="+min);


输出:

[1, 5, 3, 4, 2, 7, 6]   这是原数组
max=7
[7, 5, 3, 4, 2, 7, 6]   这是求出最大值后的数组
min=2

发现:你获得最大值后,,数组改变了,,原因是:
public int max(int[] arr){
                for(int j=1; j<arr.length; j++){
                    if(arr[0]<arr[j])        
                        arr[0]=arr[j];    //当j=1时arr[0]=5,,后面继续比较再赋值,,最后arr[0]的值就是7
                }
                return arr[0];
            }

所以:  这句代码int max=mm.max(arr);执行后,数组就变为[7, 5, 3, 4, 2, 7, 6] ,,

当你执行 代码 int min=mm.min(arr)获取最小值时就返回2了,,,因为原来数组的最小值1被7替换掉了,,,,

解决办法:
获取数组中的最大值。
        思路：
        1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
        通过一个变量进行临储。
        2，让数组中的每一个元素都和这个变量中的值进行比较。
        如果大于了变量中的值，就用该该变量记录较大值。
        3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

        步骤：
        1，定义变量。初始化为数组中任意一个元素即可。
        2，通过循环语句对数组进行遍历。
        3，在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；


        public int max(int[] arr){
                int max = arr[0];   

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


第二种获取最大值的方式:    把那个临时变量初始化为数组中的任意一个角标。

    public int max(int[] arr){
                    int max = 0;  //0不作为元素存在而是作为角标存在

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


以上2中方式都可以.....你其余的代码都不需要修改,,只需修改 max(int[] arr)方法里面的代码就可以了
打印结果:
[1, 5, 3, 4, 2, 7, 6]
max=7
[1, 5, 3, 4, 2, 7, 6]
min=1