数组

数组

创建数组

• 声明数组：int[] a 或者 int a[] 均可声明数组；[] 表示该变量是一个数组，int 表示数组里的每一个元素都是一个整数，a 是变量名

• 创建数组：创建数组时要指明数组长度，new int[5]

public class HelloWorld {
    public static void main(String[] args) {
        //声明一个引用
        int[] a; 
        //创建一个长度是5的数组，并且使用引用a指向该数组
        a = new int[5];        
        int[] b = new int[5]; //声明的同时，指向一个数组   
    }
}

初始化数组

前面都只是给数组分配空间，并没有进行赋值，下例将数组进行赋值操作：

• 分配空间与赋值分步

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = new int[5]; //分配了长度是5的数组，但是没有赋值
         
        //没有赋值，那么就会使用默认值
        //作为int类型的数组，默认值是0
        System.out.println(a[0]);
         
        //进行赋值
        a[0] = 100;
        a[1] = 101;
        a[2] = 103;
        a[3] = 120;
        a[4] = 140;
    }
}

• 分配空间与赋值同步

public class HelloWorld {
    public static void main(String[] args) {
        //写法一： 分配空间同时赋值
        int[] a = new int[]{100,102,444,836,3236};
 
        //写法二： 省略了new int[],效果一样
        int[] b = {100,102,444,836,3236};
         
        //写法三：同时分配空间，和指定内容
        //在这个例子里，长度是3，内容是5个，产生矛盾了
        //所以如果指定了数组的内容，就不能同时设置数组的长度
        int[] c = new int[3]{100,102,444,836,3236};       
    }
}

选择法与冒泡法排序

• 选择法排序的思路：

  • 把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来
    比较完后，第一位就是最小的；
  • 然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来
    比较完后，第二位就是第二小的。

• 冒泡法排序的思路：

  • 从第一位开始，把相邻两位进行比较，如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的；

  • 再来一次，只不过不用比较最后一位，以此类推。

• 例子：创建一个长度是5的数组,并填充随机数。首先用选择法正排序，然后再对其使用冒泡法倒排序

public class sort{
	//创建一个长度是5的数组,并填充随机数。
	//首先用选择法正排序，然后再对其使用冒泡法倒排序
	
	public static void main(String[] args){
		int []a = new int[5];
		System.out.println("未排序数组为：");
		for (int i = 0; i <= a.length - 1; i++){
			a[i] = (int)(Math.random()*100);//对数组赋值随机数
			System.out.print(a[i]+" ");
		}
		
		//选择法排序
		//把第一位和其他所有的进行比较，只要比第一位大的，就换到第一个位置来 ,依次类推
		System.out.println("
" + "选择法排序后：");
		for (int i = 0; i < a.length - 1; i++){
			for (int j = i+1; j < a.length; j++){
				if (a[i] < a[j]){
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}		
		for (int i = 0; i <= a.length-1; i++){
			System.out.print(a[i] + " ");
		}
		
		//冒泡法排序
		//从第一位开始，把相邻两位进行比较，如果发现前面的比后面的大，就把大的数据交换在后面，
		//循环比较完毕后，最后一位就是最大的 ，依此类推，只不过不用比较最后一位 
		System.out.println("
" + "冒泡法排序后：");
		for (int i = 0; i < a.length; i++){
			for (int j = 0; j < a.length-i-1; j++){
				if (a[j] > a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
		for (int i = 0; i <= a.length-1; i++){
			System.out.print(a[i] + " ");
		}
//		增强型for循环可遍历数组
//		for (int i : a)
//			System.out.print(i + " ");
		
	}	
}

二维数组

public class HelloWorld {
	public static void main(String[] args) {
	   //初始化二维数组，
	   int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
	   a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
	     
	   //只分配了二维数组
	   int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
	   b[0]  =new int[3]; //必须事先分配长度，才可以访问
	   b[0][2] = 5;
	   
	   //指定内容的同时，分配空间
	   int[][] c = new int[][]{
			   {1,2,4},
			   {4,5},
			   {6,7,8,9}
	   };
    }
}

Arrays

• 数组复制： Arrays.copyOfRange 方法进行数组复制。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。
• 转为字符串：Arrays.toString，直接把一个数组，转换为字符串，这样方便观察数组的内容。
• 排序：Arrays.sort 可直接排序。
• 搜索：Arrays.binarySearch 可查找元素所在位置，使用binarySearch之前，必须先使用sort进行排序，且如果数组中有多个相同的元素，查找结果是不确定的。
• 判断是否相同：Arrays.equals。
• 填充：Arrays.fill 可使用同一个值，填充整个数组 。

import java.util.Arrays; 
public class arrays {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };
        
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] c = Arrays.copyOfRange(a, 0, 3);
        System.out.println(Arrays.toString(c));//输出[18, 62, 68]
        
        //排序
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));
        
        //搜索
        System.out.println("68出现的位置是：" + Arrays.binarySearch(a, 68));
        
        //判断
        System.out.println(Arrays.equals(a, b));
        
        //填充
        int d[] = new int[10];       
        Arrays.fill(d, 5);//数组c全填充为5
        System.out.println(Arrays.toString(d));
  
    }
}