如题：二维数组怎么取出最大最小值·是从每一个一维数组中获取最值么？通过两个for循环？ 本人循环总是不会写返回值。求示例，在线等 急用

class Demo
{
        public static int getMax(int[] arr){
                for (int x=0;x<arr.length-1 ;x++ )
                {
                        for (int y=x+1;y<arr.length ;y++ )
                        {
                                if (arr[x]<arr[y])
                                {
                                        int temp=arr[x];
                                        arr[x]=arr[y];
                                        arr[y]=temp;
                                }
                        }
                }

                return arr[0];
        }

                public static void main(String[] args){
                        int[] arr={6,2,33,1,8,10};
                        System.out.println(new Demo().getMax(arr));
                }

}  

//不好意思 这是选择排序

//找数组最大值

class Demo
{
        public static int getMax(int[] arr){
                int num=arr[0];
                for (int x=0;x<arr.length-1 ;x++ )
                {
                        if (num<arr[x+1])
                        {
                                num=arr[x+1];
                        }
                }

                return num;
        }

                public static void main(String[] args){
                        int[] arr={6,2,33,1,8,10};
                        System.out.println(new Demo().getMax(arr));
                }

}

//  这回没看错题目了 二维数组最大值  哈哈

class Demo
{
        public static int getMax(int[][] arr){
                int num=arr[0][0];
                for (int x=0;x<arr.length ;x++ )
                {
                        for (int y=0;y<arr[x].length ;y++ )
                        {
                                if (num <arr[x][y])
                                {
                                        num=arr[x][y];
                                }
                        }
                }
                return num;
        }

                public static void main(String[] args){
                        int[][] arr={{6,2,33,1,108,10},{1,5,33,88,2}};
                        System.out.println(new Demo().getMax(arr));
                }

}

只给楼主提供思路：
最大值和最小值肯定得两方法
要想得到结果，肯定得遍历所有的元素
你可以定义一个变量，存储二维数组中某一个元素，然后去遍历整个二维数组，怎么遍历楼主自己想吧
拿变量中的值与数组中每个元素进行比较，然后把大的或者是小的存储到变量中
遍历完后，结果自然也就出来了

package test;

public class TestDemo01 {

public static void main(String[] args)
{
int[][] b = new int[][]{{30,40,89,67},{33,45,85,15},{50,46,88,11},{3,4,8,1}};
int len1 = b.length;          //求出第一维长度
int len2 = b[0].length;         //求出第二维长度
int max = b[0][0],min = b[0][0]; //max,min分别存放最大值，最小值  都初始化为第一个元素值
for(int i=0;i<len1;i++)
{
        for(int j=0;j<len2;j++){
                if(max<=b[i][j]){
                        max=b[i][j];
                }
                if(min>=b[i][j]){
                        min=b[i][j];
                }
        }

}
System.out.println(max);
System.out.println(min);
}

}

这个是获取二维数组最小值。

1. public class GetMin {
   
2.        
   
3.         //定义一个获取二维int数组中最小元素的函数
   
4.         public static int getMin(int[][] arr){
   
5.                 //初始化二维int数组中的角标
   
6.                 int min1 = 0;
   
7.                 int min2 = 0;
   
8.                 //对二维int数组进行遍历，并获取最小元素的角标，返回最小元素
   
9.                 for(int x=0; x<arr.length; x++){
   
10.                         for(int y=0; y<arr[x].length; y++){
    
11.                                 if(arr[x][y]<arr[min1][min2]){
    
12.                                         min1 = x;
    
13.                                         min2 = y;
    
14.                                 }               
    
15.                         }
    
16.                 }
    
17.                 return arr[min1][min2];
    
18.         }
    
19.        
    
20.        
    
21.         public static void main(String[] args){
    
22.                 //定义一个二维int数组
    
23.                 int[][] a = {{5,9,3},{6,8,7,3},{2,6,8,10,4}};
    
24.                 //调用名为getMin的函数来获取最小元素
    
25.                 System.out.println("min="+getMin(a));
    
26.         }
    
27. }

复制代码

public static int max(int[][] x)
        {
                int max=x[0][0];
                for(int[] i:x)
                {
                        for(int j:i)
                        {
                                if(j>max)
                                {
                                        max=j;
                                }
                        }
                }
                return max;
        }
这个是求最大的，相信你也会求最小的数了！

328078121 发表于 2013-8-28 23:35
public static int max(int[][] x)
        {
                int max=x[0][0];

我觉得用高级for应该更简单些~~~

public static void main(String[] args) {
  String [][] str={{"1","2"},{"3","4"}};
  
  List<HashMap> list=new ArrayList<HashMap>();
  for (int i = 0; i < str.length; i++) {
   HashMap hm=new HashMap();
   for (int j = 0; j < str[i].length; j++) {
    hm.put("one",str[i][j]);
   }
   list.add(hm);
  }
}

package cn.itcast.bolg;

/*
*
如题：二维数组怎么取出最大最小值·是从每一个一维数组中获取最值么？通过两个for循环？ 本人循环总是不会写返回值。求示例，在线等 急用
*
* */
public class ArrayGet {
          //关于返回值,首先要明确返回值类型和由谁来接收,知道这个就OL
        /*分析:
         * 1.首先要有个二维数组
         * 2.要两个变量分别记录最大值和最小值
         * 3.遍历(先得到所有的元素)
         * 3.返回值是接收的类型:  int   所以接收是也是int
         *
         * */
        public static void main(String[] args) {
                int[][] arr = new int[][] { { 4, 5, 8 }, { 4, 1, 2 } }; // 定义一个二维数组
                        int min=getMin(arr);                                //接收最小值min
                        int max=getMax(arr);                                                                //接收最大值max
                        System.out.println("最大值是:"+max+"  最小值是:"+min);    //打印输出
        }

        private static int getMax(int[][] arr) {
                int max = arr[0][0];                                                                         // 定义变量记录最大值
                for (int i = 0; i < arr.length; i++) {                                         // 这是二维数组中的一位数组中的个数
                        for (int j = 0; j < arr[i].length; j++) {                         // 这是一维数组中的元素个数
                                // System.out.println(arr[i][j]);                                 //在这可以先输出下数组的所有元素
                                if (max < arr[i][j]) {                                                    // 做比较,获取最大值
                                        max = arr[i][j];                                                         // 记录最大值
                                }
                        }
                }
                return max;                                             //返回最大值max
        }

        private static int getMin(int[][] arr) {
                int min = arr[0][0];                                                                         // 定义变量记录最小值
                for (int i = 0; i < arr.length; i++) {                                         // 这是二维数组中的一位数组中的个数
                        for (int j = 0; j < arr[i].length; j++) {                         // 这是一维数组中的元素个数
                                //System.out.println(arr[i][j]);                                 // 在这可以先输出下数组的所有元素
                                if (min > arr[i][j]) {                                                         // 做比较,获取最小值
                                        min = arr[i][j];                                                         // 记录最小值
                                }
                        }
                }
                return min;                                              //返回最小值min
        }
}

int[][] arr2 = new int[2][3];
                public  int  getMax(int[][] arr2){
                                                int max = int[0][0];
                        for(int i=0; i<arr2.length; i++){
                                for(int j=0; j<arr2[i].length; j++){
                                        if(arr2[i][j] > max){
}                                }
                                System.out.println();
                        }
                }

发表于 2 秒前 | 只看该作者 int[][] arr2 = new int[2][3];
                public  int  getMax(int[][] arr2){
                                                int max = int[0][0];
                        for(int i=0; i<arr2.length; i++){
                                for(int j=0; j<arr2[i].length; j++){
                                        if(arr2[i][j] > max){
                                         max = arr2[i][j];
                           }
                                                    }
  return max  ;

                }