1. class ForForDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int [] [] arr={{9,2,3,6},{12,2,34,23,1},{2,3,12,34,6},{2,4,13,12}};
   
6. 
   
7.         printArray(arr);
   
8.         bubbleSort(arr);
   
9.         printArray(arr);
   
10.                
    
11.                 int sum=getArray(arr);
    
12.                 System.out.println("sum="+sum);
    
13.         }
    
14.         public static int getArray(int[] []arr)
    
15.         {
    
16.                 int sum=0;
    
17.                 for (int x=0;x<arr.length ;x++ )
    
18.                 {
    
19.                         for (int y=0 ;y<arr[x].length ;y++ )
    
20.                         {
    
21.                                 sum =sum+arr[x][y];
    
22.                         }
    
23.                 }
    
24.                 return sum;
    
25.         }
    
26.         public static int bubbleSort(int [][]arr)
    
27.         {
    
28.                 for (int x=0;x<arr.length ;x++ )
    
29.                 {
    
30.                         for (int y=0;y<arr[x].length-1 ;y++ )
    
31.                         {
    
32.                                 for (int z=y+1;z<arr[x].length-y-1 ;z++ )
    
33.                                 {
    
34.                                         if (arr[y][z]>arr[y][z+1])
    
35.                                         {
    
36.                                                 int temp=arr[y][z];
    
37.                                                 arr[y][z]=arr[y][z+1];
    
38.                                                 arr[y][z+1]=temp;
    
39.                                         }
    
40. 
    
41.                                 }
    
42.                                
    
43.                
    
44.                         }
    
45.                 }
    
46.                 return -1;
    
47.         }
    
48.         public static int printArray(int [][]arr)
    
49.                
    
50.         {
    
51.                
    
52.                 for (int x=0; x<arr.length;x++ )
    
53.                 {
    
54.                         System.out.print("[");
    
55.                         for (int y=0;y<arr[x].length ;y++ )
    
56.                         {
    
57.                                 if (y!=arr[x].length-1)
    
58.                                 {
    
59.                                         System.out.print(arr[x][y]+",");
    
60.                                 }
    
61.                                 else System.out.println(arr[x][y]+"]");
    
62.                         }
    
63.                 }
    
64.                 return -1;
    
65.         }
    
66. }
    

复制代码

二维数组，多维数组怎么排序啊。最好写详细的过程

多维数组、数组的排序

多维数组可以理解为由若干低维数组组成的数组，例如，多个一维数组可以组合而成为“二维数组”，多个二维数组组成三维数组…

二维数组的结构：

s[i][j] j=0 j=1 j=2

i=0 67 89 53

i=1 77 98 68

i=2 57 66 73

i=3 80 88 94

i=4 84 92 90

多行多列、类型相同的数据组成的数据表

二维数组s的第一维的长度为5，即数组s是由5个一维整型数组类型（int[]）元素组成，分别标记为s[0] s[1] s[2]…，这5个一维数组的长度，即数组s的第二维的长度为3 。

要访问二维数组中的某个元素，需要知道该元素的位置（第几行、第几列）

二维数组的声明

格式：类型名（任意合法的Java数据类型

） 变量名[][];（标明声明的是二维数组

）   或   类型名[][]  变量名;（合法的Java语言标识符

）

例如，int[][] s;           Student  s[][];  

需注意：声明了数组类型变量，运行时系统只为引用变量分配引用空间，并没有创建对象，也不会为数组元素分配空间，因此尚不能使用任何数组元素。

静态初始化
格式：类型[][]  数组名={{第0行初值},…,{第n-1行初值}};
例如，int[][] s={{67，89，53}，{77，98，68}，{57，66，73}，{80，88，94}，{84，92，90}};

动态初始化

直接为每一维分配空间
例如，int [][] s=new int[5][3];

从最高维开始（必须从最高维开始），分别为每一维分配空间。例如,int[][] s=new int[5][];
s[0]=new int[3];   s[1]=new int[3];…

注意： Java中允许二维数组中每行的元素个数不同，即每行的列数可以不同。例如，int[][] s=new int[3][];

s[0]=new int[1];     s[1]=new int[2];     s[2]=new int[3];

注意：使用二维数组s的length属性可获得二维数组高维的大小，即行数；使用s[i].length属性可获得二维数组每一行的列数，即每一行的元素个数。

for(int i=0;i<s.length;i++){

           for(int j=0;j<s[i].length;j++)

                  sum+=s[i][j];

   }

在JDK的java.util包中定义的Arrays类提供了多种数组操作方法，实现了对数组元素的排序、填充、转换、增强检索和深度比较等功能，所有的这些方法都是static的。

数组元素的排序方法
      原型：public static void sort(<type>[] a);
       例如，int[] a={4，12，0，-5，45，-56};
                  Arrays.sort(a);

注意：数组元素的排序通常指一维数值型数组元素按升序排序，偶尔也会涉及一维String数组的排序，多维和其他引用类型的数组排序实用意义不大。