//需求寻找4个数中最大值
/*
分析:要寻找4个数中最大值,需要用到比较运算符,所以用if语句


*/
class IfTest{
        public static void main(String[] args) {
                int x = 10;
                int y = 111;
                int z = 100;
                int a = 12;
                if(x > y) {
                        if(x > z){
                                if(x > a){
                                        System.out.println("x="+x);
                                }
                                else{
                                        System.out.println("a="+a);
                                }
                       
                       
                        }
                        else{
                                if(z > a){
                                        System.out.println("z="+z);
                                }
                                else{
                                        System.out.println("a="+a);
                                }
                       
                        }
               
                }
                else{
                        if(y > z){
                                if(y > a){
                                        System.out.println("y="+y);
                                }
                                else{
                                        System.out.println("a="+a);
                                }
                       
                       
                        }
                        else{
                                if(z > a){
                                        System.out.println("z="+z);
                                }
                                else{
                                        System.out.println("a="+a);
                                }
                       
                        }
               
               
                }
       
       
       
        }

}

@author e10my
class  If
{
        public static void main(String[] args)
        {                        int x = 10;
                int y = 111;
                int z = 100;
                int a = 12;
                        
                                int[] array = {x,y,z,a}; //楼主可以在输入数据的时候就存放在数组中
                                        int max = array[0];
                                for(int i = 0;i<4;i++) //打印所有数据
                                        System.out.println(array);   //这里应该是 array【i】  不知道为何，我写上去之后自己就把【i】去掉了
                                
                                for(int i = 0 ; i < array.length ; i++){ //array.length 取数组长度
                                        if(array>max)
                                                max = array;

                                }
                                
               
                System.out.println("max="+max);
        }
}

class IfTest{         public static void main(String[] args) {              
   int x = 10;        
     int y = 111;      
      int z = 100;        
     int a = 12;                  
        int result = (x>y?x:y)>(z>a?z:a)?(x>y?x:y):(z>a?z:a);         
    System.out.println(result);         }  }

class IfTest{
        public static void main(String[] args) {
                int x = 10;
            int y = 111;
            int z = 100;
            int a = 12;
            
            int result = (x>y?x:y)>(z>a?z:a)?(x>y?x:y):(z>a?z:a);
            System.out.println(result);
        }

}

唉，其实java早就把这些求值问题考虑到了，所以我们拿来主义，两三行代码搞定：【仅供参考】

1. import java.util.*;
   
2. public class GetMax
   
3. {
   
4.         public static void main(String[]args)
   
5.         {
   
6.                 int intArr[] = {8,4,5,1};
   
7.                 Arrays.sort(intArr);
   
8.                 System.out.println("最大值为:"+intArr[intArr.length-1]);
   
9.         }
   
10. }
    

复制代码

1. class IfTest
   
2. {
   
3.         public static void main(String [] args)
   
4.         {
   
5.                 int [] a = {1,8,11,9};
   
6. 
   
7. 
   
8.                 System.out.println("max = " + getMax(a));
   
9. 
   
10.         }
    
11. 
    
12.         public static int getMax(int [] arr)
    
13.         {
    
14.                 int max = 0;
    
15.                 for(int i = 1; i < arr.length; i++)
    
16.                 {
    
17.                         max = (arr[max] < arr[i]) ? i : max;
    
18.                 }
    
19.                 return arr[max];
    
20.         }
    
21. }

复制代码

简单不代表简洁。。简单应该是简洁+易理解。

public class Test {
         public static void main(String args[]){
            getMax(10,111,100,12);


        }
              static void getMax(int...args){                 //可变参数，
                    int max=args[0];
                    for(int i=1;i<args.length;i++){
                               if(args[i]>max)
                                     max=args[i]; }   
                                                                     
                 System.out.println( args);;      
                   

        }   

}

波涛 发表于 2014-5-29 12:14
唉，其实java早就把这些求值问题考虑到了，所以我们拿来主义，两三行代码搞定：【仅供参考】

效率不高噢。

Alan_Kwan 发表于 2014-5-29 12:56
效率不高噢。

大神可以给解答一下有关Arrays效率问题么？
另外还可以这样的，我们利用冒泡的思路来思考也很简单吧，冒一次泡，将最大值冒出，代码如下：

1. public class GetMax
   
2. {
   
3.         public static void main(String[]args)
   
4.         {
   
5.            int intArr[] = {3,4,5,8,5,10,9};       //待排数组，可自定义个数
   
6.            BubbleSort bs = new BubbleSort();
   
7.            bs.sort(intArr);
   
8.            System.out.println("最大数为:"+intArr[intArr.length-1]);
   
9.         }
   
10. }
    
11. 
    
12. class BubbleSort //简化的冒泡，仅冒一次泡，将最大值"冒出"
    
13. {
    
14.    public int[] sort(int [] arr)
    
15.   {
    
16.         int temp;//中间变量,做交换用的"篮子"
    
17.                   for(int j=0; j<arr.length-1; j++)
    
18.                   {
    
19.                      if(arr[j]>arr[j+1])
    
20.                          {
    
21.                              temp = arr[j+1];
    
22.                                  arr[j+1] = arr[j];
    
23.                                  arr[j] = temp;
    
24.                          }
    
25.                   }
    
26.                 return arr;
    
27.   }
    
28. }

复制代码

波涛 发表于 2014-5-29 13:25
大神可以给解答一下有关Arrays效率问题么？
另外还可以这样的，我们利用冒泡的思路来思考也很简单吧，冒一 ...

首先~~我不是大神。。:L
然后，我说的效率不高，不是指你用sort()效率不高，而是指在这个需求里面的效率不高，因为这里的需求仅仅是要求输出N个数中的最大值，而你是先把值作了排序然后再输出，这里效率的差距就很明显了。

其次，你的貌似不是冒泡法，你的sort方法里面最终仅仅是把数组中最大的值排到了最后的位置，还差一套循环才会成为冒泡法。

Alan_Kwan 发表于 2014-5-29 16:20
首先~~我不是大神。。
然后，我说的效率不高，不是指你用sort()效率不高，而是指在这个需求里面的效率 ...

嗯，对的，那不是冒泡，因为只要最大值，所以没必要走完全部冒泡流程，冒一次就够了；故意把外层循环去掉了，姑且称作简化版本"冒泡”吧，只是为了好理解就这么叫了！

波涛 发表于 2014-5-29 16:52
嗯，对的，那不是冒泡，因为只要最大值，所以没必要走完全部冒泡流程，冒一次就够了；故意把外层循环去掉 ...

如果只要最大值用你的那个sort也有效率问题，如果仅仅是要最大值，那没必要找到最大值的过程中做那么多次数据交换。

Alan_Kwan 发表于 2014-5-29 16:56
如果只要最大值用你的那个sort也有效率问题，如果仅仅是要最大值，那没必要找到最大值的过程中做那么多次 ...

额~ 我没有考虑效率的问题，确实没必要做交换，哦，那就算了，别看我的了，用你们的吧。