Java中的数组及冒泡排序与选择排序

一、数组中的二维数组

二维数组举例：
int [][] a = {{1,2},{3,4,0,9},{5,6,7}};
Java中多维数组不必须是规则矩阵形式

二维数组其实就是把这些一维数组用大括号括起来，这就是二维数组。

上面的这个二维数组中{1,2}{3,4,0,9}{5,6,7}就是一维数组。

public class TwoArray{
	public static void main(String[] args){
		int[] array1 = new int[5];
		int[][] array2 = new int[3][];
		array2[0] = new int[2];
		array2[1] = new int[4];
		array2[2] = new int[3];
		
		array2[0][0] = 1;
		array2[0][1] = 2;
		
		array2[1][0] = 10;
		array2[1][1] = 20;
		array2[1][2] = 30;
		array2[1][3] = 40;
		
		array2[2][0] = 100;
		array2[2][1] = 200;
		array2[2][2] = 300;
		
		for(int i = 0; i <array2.length;i++){
			for(int j = 0; j <array2[i].length; j++ ){
				System.out.print(array2[i][j] + "\t");
			}
		}
    }
}

 这个就是一个二维数组的代码

二、数组的拷贝

1.使用java.lang.System类的静态方法
public static void arraycopy
                  (Object src,int srcPos,Object dest,int destPos,int length)
2.可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。
3.如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException 异常（数据越界异常）。

public class ArrayTest7 {
public static void main(String args[]) {
        String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for(int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+" ");
        }
        System.out.println();
        int[][] intArray = {{1,2},{1,2,3},{3,4}};
        int[][] intArrayBak = new int[3][];
        System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
        intArrayBak[2][1] = 100;
        for(int i = 0;i<intArray.length;i++){
            for(int j =0;j<intArray[i].length;j++){
            System.out.print(intArray[i][j]+" ");
            }
            System.out.println();
        }
    }
}

三、命令行参数

在启动Java应用程序时可以一次性地向应用程序中传递0~多个参数----命令行参数

  – 命令行参数使用格式：
        java ClassName lisa "bily" "Mr Brown“
       – 由参数args接收
       – 空格将参数分开
       – 若参数包含空格，用双引号引起来

代码如下：

public class Test {
        public static void main(String[] args) {
        for ( int i = 0; i < args.length; i++ ) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

      

 当编译通过后运行时后面输入参数，注意要用空格隔开，当参数中有空格时要用双引号引起来。

四、冒泡排序

冒泡排序（Bubble Sort），它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从小到大）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

冒泡排序算法的原理如下： 

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class yx1{
	public static void main(String[] args){
		int[] a = new int[]{12,5,23,6,2};
		for(int i = 0;i < 4;i++){
			for(int j = 0;j < 4-i;j++){
				if(a[j]>a[j+1]){
					int t = a[j];
					a[j] =a[j+1];
					a[j+1]=t;
				}
			}
		}
		for(int i = 0;i < 5;i++){
			System.out.print(a[i]+"\t");
		}
    }
}

这个代码就是将12，5，23，6，2这几位数字从小到大排序。

五、选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

选择排序的思路：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

public class ArraySort{
    public static void main(String[] args){
        int[] array = new int[]{1,3,5,7,2,9,8,4,6};
        for(int i = 0; i<array.length;i++){
			 int index = i;
			 for(int j = i; j<array.length ; j++){
				 if(array[j] < array[index]){
					  index = j;
				  }
			  } 
			  int temp = array[index];
			  array[index] = array[i];
			  array[i] = temp;
		 }
	}
}

这就是选择排序将数组中的数进行从小到大排序。

就冒泡排序与选择排序两种算法来说，冒泡排序算法还是比较稳定的。