我是这样想的：既然比较数组值，那就for循环角标值比较提取到的值 然后来个判断 将最大值赋给一个变量。
打印这个变量。
但是看过毕老师视频，又构造了一个函数。

两个方法 确实是比较清晰明了，但是可以定义在一个方法内实现么？

在一个方法可以用比较简单的方式实现么？

什么时候考虑再创建一个方法呢？求指点迷津，万分感谢！

错误代码如下：

1. class IntDemo{
   
2.         public static void main(String [] args){
   
3.         int [] i = {2,7,9,1,0,4};
   
4.         
   
5.                 for(int x = 0;x<i.length;x++){
   
6.                         int max = 0;
   
7.                         if(i[x]>i[x++]){
   
8.                                   max = i[x];
   
9.                                  
   
10.                                 }
    
11.                                 System.out.println(max);
    
12.                                 
    
13.                                 }}
    
14. }

复制代码

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 // 定义一个数组
   
4.                 int array[] = new int[] {19, 2, 3, 4, 5, 6,88 ,1};
   
5.                 //定义一个int属性的值来接收最大值
   
6.                 int maxInt = 1;
   
7.                 //定义一个int属性的值，来接收最小值，这里需要赋值array数组下标为0的值,直接赋值0会被判断自小的永远为0
   
8.                 int minInt = array[0];
   
9.                 //利用一个for循环，得到数组全部的值
   
10.                 for (int i = 0; i < array.length; i++) {
    
11.                         //利用Math类自带的方法max求出数组最大值
    
12.                         maxInt=Math.max(maxInt,array[i]);       
    
13.                         //利用Math类自带的方法min求出数组最小值
    
14.                         minInt=Math.min(minInt,array[i]);
    
15.                 }
    
16.                 System.out.println("最大值是"+maxInt);
    
17.                 System.out.println("最小值是"+minInt);
    
18.         }
    
19. }
    

复制代码

Sword 发表于 2013-4-12 00:59
你这个问题跟入学测试题有点类似，源码和注释已经给出，希望对你有帮助 ...

这么繁琐。

直接自定义方法  for循环  遍历数组比较角标获取的值 取出最大不就完事么？

1. package com.itheima;
   
2. 
   
3. /**
   
4. * 第六题：输入一个数字组成的数组，输出该数组的最大值和最小值
   
5. *@author Sword
   
6. */
   
7. import java.io.BufferedReader;
   
8. import java.io.InputStreamReader;
   
9. import java.io.IOException;
   
10. 
    
11. public class Test6 {
    
12. 
    
13.         public static void main(String[] args) throws IOException {
    
14.                 System.out.println("请输入一组数字(数字之间用空格隔开)：");
    
15.                 // 创建输入流对象
    
16.                 BufferedReader reader = new BufferedReader(new InputStreamReader(
    
17.                                 System.in));
    
18.                 // 读取一行信息
    
19.                 String input = reader.readLine();
    
20.                
    
21.                 // 以空格为分隔符，转换成数组
    
22.                 String[] numbers = input.split(" ");
    
23.                 int[] values = new int[numbers.length];
    
24.                 for (int j = 0; j < numbers.length; j++) {
    
25.                         values[j] = Integer.parseInt(numbers[j]);
    
26.                 }
    
27.                 // 回收numbers数组的资源
    
28.                 numbers = null;
    
29. 
    
30.                 // 获取接收到的数组里面的最大、最小数值
    
31.                 // 获取最大值和获取最小值分别写成了两个函数的话，就等于是多遍历了一遍这个数组，效率降低了，可扩展性增强了
    
32.                 System.out.printf("最大值(MAX):%d, 最大值(MIN):%d\n", getMax(values), getMin(values));
    
33.         }
    
34. 
    
35.         public static int getMax(int[] values) {
    
36.                 int tmp = Integer.MIN_VALUE;
    
37. 
    
38.                 if (values!=null) {
    
39.                         tmp = values[0];
    
40.                         for (int i = 0; i < values.length; i++) {
    
41.                                 if (tmp < values[i]) {
    
42.                                         tmp = values[i];
    
43.                                 }
    
44.                         }
    
45.                 }
    
46. 
    
47.                 return tmp;
    
48.         }
    
49. 
    
50.         public static int getMin(int[] values) {
    
51.                 int tmp = Integer.MIN_VALUE;
    
52. 
    
53.                 if (values!=null) {
    
54.                         tmp = values[0];
    
55.                         for (int i = 0; i < values.length; i++) {
    
56.                                 if (tmp > values[i]) {
    
57.                                         tmp = values[i];
    
58.                                 }
    
59.                         }
    
60.                 }
    
61. 
    
62.                 return tmp;
    
63.         }
    
64. }

复制代码

你这个问题跟入学测试题有点类似，源码和注释已经给出，希望对你有帮助{:soso_e112:}

1. class  TestArray
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {2,7,9,1,0,4};
   
6.                 //将原数组打印出来，以便于检验得到的最值是否正确。
   
7.                 printArray(arr);
   
8.                 System.out.println("Max="+getMax(arr));
   
9.                 System.out.println("Min="+getMin(arr));
   
10.         }
    
11.         //次方法用于打印数组
    
12.         public static void printArray(int[] arr)
    
13.         {
    
14.                 System.out.print("[");
    
15.                 for(int x=0; x<arr.length; x++)
    
16.                 {
    
17.                         if(x!=arr.length-1)
    
18.                                 System.out.print(arr[x]+", ");
    
19.                         else
    
20.                                 System.out.println(arr[x]+"]");
    
21.                 }
    
22.         }
    
23.         //此方法用于获取数组的最小值
    
24.         public static int getMin(int[] arr)
    
25.         {
    
26.                 int min = 0;
    
27.                 for(int x=1; x<arr.length; x++)
    
28.                 {
    
29.                         if(arr[x]<arr[min])
    
30.                                 min = x;
    
31.                 }
    
32.                 return arr[min];
    
33.         }
    
34.         //此方法用于获取数组的最大值
    
35.         public static int getMax(int[] arr)
    
36.         {
    
37.                 int max = 0;
    
38.                 for(int x=1; x<arr.length; x++)
    
39.                 {
    
40.                         if(arr[x]>arr[max])
    
41.                                 max = x;
    
42.                 }
    
43.                 return arr[max];
    
44.         }
    
45.        
    
46. }
    
47. 
    
48. 我觉这样比较好，提高了程序的复用性；而且方法只有在执行时才占用内存，比较节省内存空间。

复制代码

一般我们代码都是将要实现的功能封装在一个方法体中，比如像上面你要求上面的数组中的最大值，一般我们就创建一个getMax(int a[])方法，当然函数名你随便写，但可读性要强哦
public void getMax(int a[]){
int max;
for(int i=0;i<a.length;i++){
  if(max<a[i]){
max = a[i]
      }
   }
system.out.println(“数组” + a +"中的最大元素是" + max);
}
以后不管你想判断哪个数组中的最大值，直接就可以将该数组传进去就是了，如：判断数组arr中的最大元素直接调用 getMax(arr);
还有你上面的代码写的不规范，你要慢慢调整过来哦、、

求数组中的最值由很多种方式，
我比较常用的是Arrays.sort（）
让一个数组排好序之后，去arr[0]就是最小了arr[arr.length-1]就是最大了
当然可以使用很多种函数实现，
在方法内实现当然可以
package day1;


public class Day1 {


        

               
               
                 public static void main(String [] args){
                        int [] i = {2,7,9,1,0,4};
                        int max = 0;
                                for(int x = 0;x<i.length-1;x++){
                                       
                                        if(i[x]>max){
                                                  max = i[x];
                                          
                                                }
                                                
                                               
                                                }
                                System.out.println(max);               
                 }
}



自己思考。。