以下是一个数组间的排序，如果多个数组同时进行排序的话，应该怎么办啊。求用冒泡排序的方法解。

1. public class MaoPao {
   
2.         public static void main(String[] args) {
   
3.                 int[] a={3,6,4,2,9,5,8,1,7,0};
   
4.                 int temp=0;int flag=0;
   
5.                 for(int i=0;i<a.length-1;i++)
   
6.                 {
   
7.                         for(int j=0;j<a.length-i-1;j++)
   
8.                         {
   
9.                                 if(a[j]<a[j+1])
   
10.                                 {
    
11.                                         temp=a[j];
    
12.                                         a[j]=a[j+1];
    
13.                                         a[j+1]=temp;
    
14.                                         flag=1;
    
15.                                 }
    
16.                         }
    
17.                         if(flag==0)
    
18.                                 break;
    
19.                 }
    
20.                 for(int i=0;i<a.length;i++)
    
21.                 {
    
22.                         System.out.print(a[i]+" ");
    
23.                 }
    
24.         }
    
25. }
    

复制代码

可以把这个方法封装起来，在从新定义一个，你再试试，

public class BubbleSort {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
        int [] str={12,23,34,23};
                changeBubble(str);
   for(int i=0;i<str.length;i++){
           System.out.println(str);
   }

        }

        private static void changeBubble(int[] str) {
                // TODO Auto-generated method stub
                int temp=0;
                for(int i=0;i<str.length-1;i++)
                        for(int j=i+1;j<str.length;j++){
                                if(str>str[j]){
                                        temp=str;
                                        str=str[j];
                                        str[j]=temp;
                                       
                                }
                        }
        }

}

1. public class DaoFactory1 {
   
2.         public static void mian(String[] args) throws Exception {
   
3.                 int[] a={3,6,4,2,9,5,8,1,7,0};
   
4.                 int[] b={1,6,4,2,9,5,8,1,7,0};
   
5.                 int[] c={2,6,4,2,9,5,8,1,7,0};
   
6.                 int[] d={5,6,4,3,5,5,8,1,7,0};
   
7.                 System.out.println(a);//排序前
   
8.                 a = bubbleSort(a);//调用排序方法
   
9.                 System.out.println(a);//排序后
   
10. 
    
11.         }
    
12.         public static int[] bubbleSort(int[] arr) {//冒泡排序方法
    
13.                 int temp = 0;
    
14.                 int flag = 0;
    
15.                 for (int i = 0; i < arr.length - 1; i++) {
    
16.                         for (int j = 0; j < arr.length - i - 1; j++) {
    
17.                                 if (arr[j] < arr[j + 1]) {
    
18.                                         temp = arr[j];
    
19.                                         arr[j] = arr[j + 1];
    
20.                                         arr[j + 1] = temp;
    
21.                                         flag = 1;
    
22.                                 }
    
23.                         }
    
24.                         if (flag == 0)
    
25.                                 break;
    
26.                 }
    
27.                 for (int i = 0; i < arr.length; i++) {
    
28.                         System.out.print(arr[i] + " ");
    
29.                 }
    
30.                 return arr;
    
31.         }
    
32. }

复制代码

把重复使用的代码重构成方法,以便重复使用.

多个数组同时排序，都 用冒泡法，那就属于同一代码复用，可以封装成方法，重复调用。我们一般有这样的习惯就是，在main 中定义初始条件，再调用相应功能方法；方法单独封装，放到main外面，这样程序看起来有条理不乱，也容易查找错误。
========================
public staic void mian(String args[]){
。。。初始条件。。。
。。。sort（操作内容）。。。排序方法
。。。后续方法。。。
｝

public static 是否返回 sort(接收参数）｛
。。。方法实体。。。
｝
========================

只需要将你能实现排序的代码封装在一个方法里，
需要把public static void BubbleSort_1(int [] a)这个参数声明为数组型Int[]或者你所需要的类型;这样是不用返回值的

1. class BubbleSortDemo
   
2. {
   
3.         public static void main(String[] arge)
   
4.         {
   
5.                 int[] a = {5,3,2,1,0};
   
6.                 int[] b = {6,4,3,8,1};
   
7.                 BubbleSort_1(a);//调用排序方法
   
8.                 BubbleSort_1(b);
   
9.                 System.out.printf("a:");//输出排完序的数组a
   
10.                 for(int i=0;i<a.length;i++)
    
11.                 {
    
12.                         
    
13.                         System.out.printf("%d,",a[i]);
    
14.                 }
    
15.                 System.out.println();
    
16.                 System.out.printf("b:");//输出排完序的数组b
    
17.                 for(int i=0;i<a.length;i++)
    
18.                 {
    
19.                         
    
20.                         System.out.printf("%d,",b[i]);
    
21.                 }
    
22.                
    
23.         }
    
24.         public static void BubbleSort_1(int [] a)//冒泡排序方法
    
25.         {
    
26.                 int i;
    
27.                 int j;
    
28.                 int temp;
    
29.                 boolean flag = true;
    
30.                
    
31.                 for(i=1;i<a.length&&flag==true;i++)
    
32.                 {
    
33.                         flag = false;
    
34.                         for(j=0;j<a.length-i;j++)
    
35.                         {
    
36.                                 if(a[j]>a[j+1])
    
37.                                 {
    
38.                                         flag = true;
    
39.                                         temp = a[j];
    
40.                                         a[j] = a[j+1];
    
41.                                         a[j+1] = temp;
    
42.                                 }
    
43.                         }
    
44.                 }
    
45.         }
    
46. }

复制代码

提供一个思路：多个数组的话，首先可以把多个数组合并到一个数组，前提这些数组必须是同一个类型的；其次，对合并后的数组进行冒泡法排序。

希望对楼主有帮助。