好像删不了，只能清空

楼主的代码有点乱，我拷贝过来编译都不通过。。
修改了下，楼主看看吧。

1. import java.io.BufferedReader;
   
2. import java.io.IOException;
   
3. import java.io.InputStreamReader;
   
4. 
   
5. public class Test {
   
6.         /**
   
7.          * 输入一个数字组成的数组，输出该数组的最大值和最小值 思路： 1，输入源：System.in
   
8.          * 2,以字符串的形式，通过键盘把数据输入，以“,”分割字符表示不同的数据 3，切割所字符串，并把结果存入字符数组中。
   
9.          * 4，把字符数组中的字符串转为对应的数值，并存入一个数组中； 5，编写一个查找组中最大最的方法，以及一个查找最小值的方法
   
10.          *
    
11.          * @throws IOException
    
12.          */
    
13.         public static void main(String[] args) {
    
14. 
    
15.                 // 建立输入流，读取键盘输入
    
16.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(
    
17.                                 System.in));
    
18. 
    
19.                 StringBuilder sb = new StringBuilder();
    
20.                 String line = null;
    
21.                 // 通过StringBuilder容器，接收键盘录入
    
22.                 try {
    
23.                         while ((line = bufr.readLine()) != null) {
    
24.                                 // 当输入“over”表示输入结束
    
25.                                 if ("over".equals(line))
    
26.                                         break;
    
27.                                 sb.append(line);
    
28.                         }
    
29.                 } catch (IOException e) {
    
30.                         e.printStackTrace();
    
31.                 } finally {
    
32.                         try {
    
33.                                 bufr.close();
    
34.                         } catch (IOException e) {
    
35.                                 e.printStackTrace();
    
36.                         }
    
37.                 }
    
38. 
    
39.                 // 切割字符串
    
40.                 String[] arrs = sb.toString().split(",");
    
41. 
    
42.                 // 把字符串数组，转换成对应的int型数组
    
43.                 int[] arr = new int[arrs.length];
    
44.                 for (int i = 0; i < arr.length; i++) {
    
45.                         arr[i] = Integer.parseInt(arrs[i]);//这里应该这样写，要带下标。。。
    
46.                         System.out.print(arr[i] + " ");
    
47.                 }
    
48.                 System.out.println();
    
49.                 // 打印数组中的最大值及最小值
    
50.                 System.out.println("min=" + getMin(arr));
    
51.                 System.out.println("max=" + getMax(arr));
    
52.                 System.out.println("min=" + getMin(arr));
    
53. 
    
54.         }
    
55. 
    
56.         /**
    
57.          * 定义一个获取数组中最大值的方法
    
58.          *
    
59.          * @param arr
    
60.          * @return
    
61.          */
    
62.         public static int getMax(int[] arr) {
    
63.                 int max = 0;//初始最大为0
    
64.                 for (int i = 0; i < arr.length; i++){
    
65.                         if (arr[i] > max) {//数组中有比它大的就替换最大值
    
66.                                 max = arr[i];
    
67.                         }
    
68.                 }
    
69.                 return max;
    
70.         }
    
71. 
    
72.         /**
    
73.          * 定义一个获取数组中最小值的方法
    
74.          *
    
75.          * @param arr
    
76.          * @return
    
77.          */
    
78.         public static int getMin(int[] arr) {
    
79.                 int min = 10000;//初始最小为10000
    
80.                 for (int i = 0; i < arr.length-1; i++) {
    
81.                        
    
82.                         if (arr[i] < min) {//比10000小，则替换最小
    
83.                                
    
84.                                 min = arr[i];
    
85.                         }
    
86.                 }
    
87. 
    
88.                 return min;
    
89.         }
    
90. }
    

复制代码

打印效果:
10,12,52,89,45
over
10 12 52 89 45
min=10
max=89
min=10

严格来讲，比较大小那里初始化最大最小值不严谨。。
但是修改后的代码。完成了楼主的需求，希望能帮到你。。

1. import java.io.BufferedReader;
   
2. import java.io.IOException;
   
3. import java.io.InputStream;
   
4. import java.io.InputStreamReader;
   
5. 
   
6. public class Test8 {
   
7.         /**
   
8.          * 输入一个数字组成的数组，输出该数组的最大值和最小值 思路：
   
9.          *  1，输入源：System.in
   
10.          *  2,以字符串的形式，通过键盘把数据输入，以“,”分割字符表示不同的数据
    
11.          *  3，切割所字符串，并把结果存入字符数组中。
    
12.          *  4，把字符数组中的字符串转为对应的数值，并存入一个数组中； 5，编写一个查找组中最大最的方法，以及一个查找最小值的方法
    
13.          *
    
14.          * @throws IOException
    
15.          */
    
16.         public static void main(String[] args) {
    
17. 
    
18.                 // 建立输入流，读取键盘输入
    
19.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(
    
20.                                 System.in));
    
21. 
    
22.                 StringBuilder sb = new StringBuilder();
    
23.                 String line = null;
    
24.                 // 通过StringBuilder容器，接收键盘录入
    
25.                 try {
    
26.                         while ((line = bufr.readLine()) != null) {
    
27.                                 // 当输入“over”表示输入结束
    
28.                                 if ("over".equals(line))
    
29.                                         break;
    
30.                                 sb.append(line);
    
31.                         }
    
32.                 } catch (IOException e) {
    
33.                         e.printStackTrace();
    
34.                 } finally {
    
35.                         try {
    
36.                                 bufr.close();
    
37.                         } catch (IOException e) {
    
38.                                 e.printStackTrace();
    
39.                         }
    
40.                 }
    
41. 
    
42.                 // 切割字符串
    
43.                 String[] arrs = sb.toString().split(",");
    
44. 
    
45.                 // 把字符串数组，转换成对应的int型数组
    
46.                 int[] arr = new int[arrs.length];
    
47.                 System.out.print("输入的数组为：[");
    
48.                 for (int i = 0; i < arr.length; i++) {//这里有错
    
49.                         arr[i] = Integer.parseInt(arrs[i]);//arr
    
50.                        
    
51.                         if(i<arr.length-1)
    
52.                                 System.out.print(arr[i]+",");
    
53.                         else
    
54.                                 System.out.println(arr[i]+"]");
    
55.                 }
    
56.                 System.out.println();
    
57.                 //int irr[] = { 12, 45, 67, 23 };
    
58.                 // 打印数组中的最大值及最小值
    
59.                 System.out.println("min=" + getMin(arr));// 如放有getMax前就能打印出正确结果
    
60.                 System.out.println("max=" + getMax(arr));
    
61.                 System.out.println("min=" + getMin(arr));// 如放有getMax后就能打印出错误的结查，好像没拿第一位比较
    
62.                 // 如：输入12,45,67,23
    
63.                 // over
    
64.                 // 打印出：12 45 67 23
    
65.                 // min=12
    
66.                 // max=67
    
67.                 // min=23
    
68.                 // 同一个数组，两次结果不一样
    
69. 
    
70.         }
    
71. 
    
72.         /**
    
73.          * 定义一个获取数组中最大值的方法
    
74.          *
    
75.          * @param arr
    
76.          * @return
    
77.          */
    
78.         public static int getMax(int[] arr) {
    
79.                 int max = 0;
    
80.                 for (int i = 0; i < arr.length; i++)
    
81.                         if (arr[i] > arr[max]) {
    
82.                                 int temp = arr[i];//这里有错
    
83.                                 arr[i] = arr[max];
    
84.                                 arr[max] = temp;
    
85.                                
    
86.                         }
    
87.                 return arr[max];
    
88.         }
    
89. 
    
90.         /**
    
91.          * 定义一个获取数组中最小值的方法
    
92.          *
    
93.          * @param arr
    
94.          * @return
    
95.          */
    
96.         public static int getMin(int[] arr) {
    
97.                 int min = 0;
    
98.                 for (int i = 1; i < arr.length; i++) {
    
99.                         // System.out.println("min:"+arr[min]);
    
100.                         if (arr[min] > arr[i]) {
     
101.                                 // System.out.println("min:"+arr[min]+"arr["+i+"]"+arr);
     
102.                                 int temp = arr[i];//这里有错
     
103.                                 arr[i] = arr[min];
     
104.                                 arr[min] = temp;
     
105.                         }
     
106.                 }
     
107. 
     
108.                 return arr[min];
     
109.         }
     
110. }
     

复制代码

咋都删不了

代码贴出来后才变得乱七八糟的，不是我干，系统干的

不要了

谢洋 发表于 2013-3-13 10:05
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;

谢谢，我是提交后才拿出来，也不一定技术分高就代表什么都能搞得明白，就是搞不明才拿出来的，那好吧，我把贴子删了！