/*复习，纯理解后记忆算法，手敲。效果不错，加油！
需求：将数组arr从小到大排列，用冒泡排序写。然后将数组arr从大到小排列，用选择排序写。
1、冒泡排序，相邻的角标0与1，1与2比较，....每次符合条件就元素换位。第一次冒泡完，最后一个角标位存放的元素必为最值。
函数：明确结果：无，void；明确是否有未知内容参与运算，有，未知数组，int[]。
2、选择排序，0角标与1角标比较，符合条件就换位，然后0角标继续与角标1、2...比较，第一圈选择完，0角标位存放的元素必为最值。*/

class  ArrSortTest
{
        public static void main(String[] args)
        {
                int[] arr1={0,1,2,3,5,4,8,7,9,10};
                int[] arr2={1,2,3,4,5,9,9,8};
                int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
                int[] arr=arr1;
                xuanArr(arr);
                arr=arr3;
                xuanArr(arr);
                arr=arr2;
                xuanArr(arr);
               
        }
        public static void xuanArr(int[] arr)
        {
                System.out.println("下边是数组"+arr+"的"+"遍历情况");
                readArr(arr);
                bubbleSort(arr);
                readArr(arr);
                selectSort(arr);
                readArr(arr);
                System.out.println("-------------华丽的分割线------------");
        }
        //遍历数组
        public static void readArr(int[] arr)
        {
                for (int x=0;x<arr.length ;x++ )
                {
                        if(x!=arr.length-1)
                        System.out.print(arr[x]+"； ");
                        else
                                System.out.println(arr[x]);
                }
        }
        //冒泡排序,小到大
        public static void bubbleSort(int[] arr)
        {
                for (int x=0; x<arr.length;x++ )
                {
                        for (int y=0;y<arr.length-x-1 ;y++ )
                        {
                                if(arr[y]>arr[y+1])
                                {
                                        diaohuan(arr,y,y+1);
                                        /*
                                int temp=arr[y];
                                arr[y]=arr[y+1];
                                arr[y+1]=temp;
                                        */
                                }

                        }
                }
                System.out.println("-------下边是冒泡排序，小到大-------");
        }
        //选择排序，大到小
        public static void selectSort(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])
                                {
                                        diaohuan(arr,x,y);
                                                /*
                                int temp=arr[x];
                                arr[x]=arr[y];
                                arr[y]=temp;
                                        */
                                }
                        }
                }
                System.out.println("-------下边是选择排序，大到小-------");
        }
        //将调换的代码封装成函数
        public static void diaohuan(int[] arr,int a,int b)
        {
                {
                int temp=arr[a];
                arr[a]=arr;
                arr=temp;
                }
        }
}

我知道输出结果的错误在哪，但我没想到怎么简单的把数组名输出来，虽然是小插曲，但也想弄明白

1. package com.itheima;
   
2. class  ArrSortTest
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int[] arr1={0,1,2,3,5,4,8,7,9,10};
   
7.                 int[] arr2={1,2,3,4,5,9,9,8};
   
8.                 int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
   
9.                 int[] arr=arr1;
   
10.                 xuanArr(arr);
    
11.                 arr=arr3;
    
12.                 xuanArr(arr);
    
13.                 arr=arr2;
    
14.                 xuanArr(arr);
    
15.                
    
16.         }
    
17.         public static void xuanArr(int[] arr)
    
18.         {
    
19.                 System.out.println("下边是数组"+arr+"的"+"遍历情况");
    
20.                 readArr(arr);
    
21.                 bubbleSort(arr);
    
22.                 readArr(arr);
    
23.                 selectSort(arr);
    
24.                 readArr(arr);
    
25.                 System.out.println("-------------华丽的分割线------------");
    
26.         }
    
27.         //遍历数组
    
28.         public static void readArr(int[] arr)
    
29.         {
    
30.                 for (int x=0;x<arr.length ;x++ )
    
31.                 {
    
32.                         if(x!=arr.length-1)
    
33.                         System.out.print(arr[x]+"； ");
    
34.                         else
    
35.                                 System.out.println(arr[x]);
    
36.                 }
    
37.         }
    
38.         //冒泡排序,小到大
    
39.         public static void bubbleSort(int[] arr)
    
40.         {
    
41.                 for (int x=0; x<arr.length;x++ )
    
42.                 {
    
43.                         for (int y=0;y<arr.length-x-1 ;y++ )
    
44.                         {
    
45.                                 if(arr[y]>arr[y+1])
    
46.                                 {
    
47.                                         diaohuan(arr,y,y+1);
    
48.                                         /*
    
49.                                 int temp=arr[y];
    
50.                                 arr[y]=arr[y+1];
    
51.                                 arr[y+1]=temp;
    
52.                                         */
    
53.                                 }
    
54. 
    
55.                         }
    
56.                 }
    
57.                 System.out.println("-------下边是冒泡排序，小到大-------");
    
58.         }
    
59.         //选择排序，大到小
    
60.         public static void selectSort(int[] arr)
    
61.         {
    
62.                 for (int x=0;x<arr.length-1 ;x++ )
    
63.                 {
    
64.                         for (int y=x+1;y<arr.length ;y++ )
    
65.                         {
    
66.                                 if(arr[x]<arr[y])
    
67.                                 {
    
68.                                         diaohuan(arr,x,y);
    
69.                                                 /*
    
70.                                 int temp=arr[x];
    
71.                                 arr[x]=arr[y];
    
72.                                 arr[y]=temp;
    
73.                                         */
    
74.                                 }
    
75.                         }
    
76.                 }
    
77.                 System.out.println("-------下边是选择排序，大到小-------");
    
78.         }
    
79.         //将调换的代码封装成函数
    
80.         public static void diaohuan(int[] arr,int a,int b)
    
81.         {
    
82.                 {
    
83.                 int temp=arr[a];
    
84.                 arr[a]=arr[b];
    
85.                 arr[b]=temp;
    
86.                 }
    
87.         }
    
88. }

复制代码

我看了,没哟普问题啊,你i昂首神马?搞不懂

这个你需要看java基础加强了,int[]被java虚拟机是当成一个对象来打印的

改变前下边是数组[I@1896d2c2的遍历情况
0； 1； 2； 3； 5； 4； 8； 7； 9； 10
-------下边是冒泡排序，小到大-------
0； 1； 2； 3； 4； 5； 7； 8； 9； 10
-------下边是选择排序，大到小-------
10； 9； 8； 7； 5； 4； 3； 2； 1； 0
-------------华丽的分割线------------
下边是数组[I@55e6cb2a的遍历情况
1； 2； 3； 5； 77； 444； 55； 66； 88； 77； 99
-------下边是冒泡排序，小到大-------
1； 2； 3； 5； 55； 66； 77； 77； 88； 99； 444
-------下边是选择排序，大到小-------
444； 99； 88； 77； 77； 66； 55； 5； 3； 2； 1
-------------华丽的分割线------------
下边是数组[I@23245e75的遍历情况
1； 2； 3； 4； 5； 9； 9； 8
-------下边是冒泡排序，小到大-------
1； 2； 3； 4； 5； 8； 9； 9
-------下边是选择排序，大到小-------
9； 9； 8； 5； 4； 3； 2； 1
-------------华丽的分割线------------





改成intent后下边是数组[Ljava.lang.Integer;@28b56559的遍历情况
0； 1； 2； 3； 5； 4； 8； 7； 9； 10
-------下边是冒泡排序，小到大-------
0； 1； 2； 3； 4； 5； 7； 8； 9； 10
-------下边是选择排序，大到小-------
10； 9； 8； 7； 5； 4； 3； 2； 1； 0
-------------华丽的分割线------------
下边是数组[Ljava.lang.Integer;@1d10caf0的遍历情况
1； 2； 3； 5； 77； 444； 55； 66； 88； 77； 99
-------下边是冒泡排序，小到大-------
1； 2； 3； 5； 55； 66； 77； 77； 88； 99； 444
-------下边是选择排序，大到小-------
444； 99； 88； 77； 77； 66； 55； 5； 3； 2； 1
-------------华丽的分割线------------
下边是数组[Ljava.lang.Integer;@397b6178的遍历情况
1； 2； 3； 4； 5； 9； 9； 8
-------下边是冒泡排序，小到大-------
1； 2； 3； 4； 5； 8； 9； 9
-------下边是选择排序，大到小-------
9； 9； 8； 5； 4； 3； 2； 1
-------------华丽的分割线------------

基本数据类型的数组都会当恒一个对象来打印,打印的都是地址,可以看看基础加强.

fenzheng 发表于 2014-5-31 14:59
我看了,没哟普问题啊,你i昂首神马?搞不懂

哥们你说点我能听懂的话，我知道我实现了排序的功能，我的代码我运行了没问题，但你看我cmd图，我想输出“下边是数组arr1/arr2/arr3”，但输出结果是内存地址，我也知道我那里写成+arr+是会让虚拟机打印出内存地址[I@~的。可我就是想知道怎么样实现动态输出对应的数组名而已。。。。。

fenzheng 发表于 2014-5-31 15:00
这个你需要看java基础加强了,int[]被java虚拟机是当成一个对象来打印的

老毕告诉我了。。。我是想知道如何实现动态输出对应数组名。我知道代码不对了，但我想知道怎么样是正确的。uno？

你给xuanArr方法传过去一个数组参数，它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递给方法的参数名。

或者麻烦点，改一下方法。

1.             public static void main(String[] args)
   
2.             {
   
3.                     int[] arr1={0,1,2,3,5,4,8,7,9,10};
   
4.                     int[] arr2={1,2,3,4,5,9,9,8};
   
5.                     int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
   
6.                     int[] arr=arr1;
   
7.                     xuanArr(arr,"arr1");
   
8.                     arr=arr3;
   
9.                     xuanArr(arr,"arr2");
   
10.                     arr=arr2;
    
11.                     xuanArr(arr,"arr3");
    
12.             }

复制代码

wangleixhlm 发表于 2014-5-31 15:43
你给xuanArr方法传过去一个数组参数，它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递 ...

int[] arr=arr1;》》》这句话是把arr1的起始内存地址给了arr，对么？你的方法我懂什么意思，但你这样改一下，arr2又不会出现了

wangleixhlm 发表于 2014-5-31 15:43
你给xuanArr方法传过去一个数组参数，它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递 ...

改了前边，对应的的冒泡函数和选择函数的参数变量要增加，并且被设定死了吧？还有就是你代码错了。。。。“arr2”和“arr3”放错了{:2_31:}。可以跟我说说反射的方法么，我还没看到。。我新手哦