Java基础核心-数组

数组的定义

数组的概念

数组是内存空间中连续的一块区域，存储同一种数据类型的多个元素。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组是一组相关数据的集合，一个数组实际上就是一连串的变量。

声明数组的方式

		//数组声明
        //第一种   先声明数组,后赋值
        int[] array = new int[5];
        array[0] = 1;
        array[1] = 3;
        array[2] = 5;
        array[3] = 7;
        array[4] = 9;
        //第二种
        int[] array2 = new int[]{1,3,5,7,9};
        //第三种
        int[] array3 ={1,3,5,7,9};

注意：

1. [ ]中5就是数组array的长度，数组的长度一旦给定，就不能修改。
2. 数组使用下标(角标)来访问元素(保存元素) 下标从0开始。

数组的使用

1. 数组的长度——数组名.length
2. 数组的索引——从0开始，最大索引值：数组名.length-1

数组的遍历

for(int i =0;i<数组名.length;i++{
System.out.println(数组名[索引])
}

数组的工具类

1 Arrays.toString(array) 数组的打印
System.out.println(Arrays.toString(array));

		// 一般在服务器上打印日志的时候，会使用到这个方法
		int[] ages = {22,24,16,20,19,18};
	    System.out.println(Arrays.toString(ages));  //打印数组
	    结果：
	   		[22, 24, 16, 20, 19, 18]

2 Arrays.sort(array); 数组的排序(升序)
会在原来的数组上修改

		// 一般有自然排序的时候，会使用到这个方法
		int[] ages = {22,24,16,20,19,18};
		Arrays.sort(ages);  //数组升序排序
	    System.out.println(Arrays.toString(ages));
	    结果：
	    	[16, 18, 19, 20, 22, 24]

3 Arrays.copyOf(要复制的数组，指定新数组的长度)
会得到一个新的数组

		//一般在数组扩容的时候，会使用到这个方法
		int[] ages = {22,24,16,20,19,18};
		int[] ints = Arrays.copyOf(ages,10);  //数组复制,并指定新数组的长度为10
	    System.out.println(Arrays.toString(ints));
	    结果：
	    	[22, 24, 16, 20, 19, 18, 0, 0, 0, 0]

求数组中的最大值

		int[] stu1 = {77,80,5,100,21,15};
	    int max1 = stu1[0];
	        for (int i = 0; i < stu1.length; i++) {
	            if ( max1 < stu1[i]){
	                max1 = stu1[i];
	            }
	        }
	        System.out.println("该数组中的最大值为:"+max1);
	        结果：
	        	该数组中的最大值为:100

求数组中的最小值

		int[] stu1 = {77,80,5,100,21,15};
	    int min1 = stu1[0];
	        for (int i = 0; i < stu1.length; i++) {
	            if (min1 > stu1[i]){
	                min1 = stu1[i];
	            }
	        }
	        System.out.println("该数组中的最小值为:"+min1);
	        结果：
	        	该数组中的最小值为:5

数组元素位移

		int[] arrays = {1, 2, 3, 4, 5};
        for (int i = 0; i < arrays.length; i++) {
            int temp = arrays[0];
            arrays[0] = arrays[i];
            arrays[i] = temp;
        }
        System.out.println(Arrays.toString(arrays));
        结果：
        	[5, 1, 2, 3, 4]

冒泡排序

		int[] arrays = {11, 6, 3, 8, 99, 25, 43};
        for (int i = 0; i < arrays.length-1; i++) {
            for (int j = 0; j < arrays.length-1-i; j++) {
                if(arrays[j]<arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
        结果：
        	[99, 43, 25, 11, 8, 6, 3]

常见错误

1. 编译出错，没有写明数组的大小。

		int[] array = new int[];
		int[] array = new int[5];  //正确代码

2. 编译出错，数组越界。

		int[] array = new int[5];
	    array[0] = 1;
	    array[1] = 3;
	    array[2] = 5;
	    array[3] = 7;
	    array[4] = 9;
	    array[5] = 11;   //错误代码

3. 编译出错，创建数组并赋值的方式必须在一条语句中完成。

		int[] array = new int[5];
	    array = {1,2,3,4,5};   //报错