JavaSE之数组

一维数组：一条线

一维数组

二维数组：一个面

二维数组

三维数组：一个立方体，三维数组使用较少，这里不提及。

一维数组

数组的创建

声明方式：如int a[]; 或者 int [] a;
Java中使用new关键字创建数组对象，格式为
int [] s = new int[5];
那么创建数组时，内存中的情况如何呢？

首先是基本类型的数组的创建：

图片.png

然后是引用类型的数组的创建：看这样一段代码

class Date{
    int year,month,day;
    Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}
public class TestArray {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Date[] days ;
        days = new Date[3];
        for(int i = 0;i < 3;i++){
            days[i] =  new Date(2018,9,21);
        }
    }
}

这段代码执行时，内存是如何变化的呢？

图片.png

数组的初始化 （数组是：必须把空间分配好了，才可以往里面装值）

动态初始化

数组定义与数组元素分配空间和赋值的操作分开进行。
如：int[] a = new int[3];

静态初始化

在定义数组的同时就为数组元素分配空间并赋值。
如：int [] a = {3,9,8};

数组元素默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。也就是说int类型的初始化为0，引用类型初始化为null等。

数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：arrayName[index],index为数组元素下标，可以是整型常量或者整型表达式。如a[3]，b[i]，c[6*i]。数组元素的下标从0开始，长度为n的数组合法取值范围为：0~n-1。每个数组的length属性都能指明其长度。

冒泡排序：

冒泡排序的原理就是：（从小到大）将每一个元素与其之后的一个元素比较，即a[i]与a[i+1]进行比较，如果a[i] > a[i+1]，定义一个中间变量temp，使temp = a[i];a[i] = a[i+1];a[i+1] = temp;将a[i]和a[i+1]的值交换。因为每一个数都要与其之后的每个数进行比较，因此，需要进行嵌套循环，代码如下：

 //冒泡排序
            int temp ;//中间变量
            for(int k = 0 ; k < arrays.length ; k++){
                for (int i = 0 ; i < arrays.length - 1 ; i++) {
                    if(arrays[i] > arrays[i+1]){
                        temp = arrays[i];
                        arrays[i] = arrays[i+1];
                        arrays[i + 1] = temp;
                    }
                }
            }

选择排序

从小到大排序，拿出第一个数，与后面的每个数进行比较，如果第一个数大于后面的数，就进行交换，这样下来就把最小的数找出了，再拿出第二个数与后面的每个数进行比较...依次类推，每一个数都与其后的每个数进行比较，如果大就交换，那么循环完成，排序就完成了，代码如下：

                int temp;
         for(int i= 0;i<arrays.length;i++){
             for(int j = i+1;j<arrays.length;j++){
                 if(arrays[i]>arrays[j]){
                     temp = arrays[i];
                     arrays[i] = arrays[j];
                     arrays[j] = temp;
                 }
             }
         }

选择排序高效率版

原理：一次遍历只做一次交换，标记最小值的位置，用一个变量记录该位置，之前遍历交换值，现在交换位置，遍历完成之后，再将值进行交换。

int k,temp;
         for (int i = 0; i < arrays.length; i++) {
             k = i;
             for(int j = k+1;j<arrays.length;j++){
                 if(arrays[j] < arrays[k]){
                     k = j;//position的交换，经过循环，可以把最小值的位置找出
                 }
             }
             if(k != i){
                 //找出最小的位置后，如果不是被比较的数，那么再把位置上的数进行交换
                 temp = arrays[i];
                 arrays[i] = arrays[k];
                 arrays[k] = temp;
             }
        }

练习：500个人拉成一圈，循环123报数，逢3退1，最后500个人只剩一人，请问，这个最后剩下的人一开始是第几个人？

        /**
         * 500个人拉成一圈，循环123报数，逢3退1，
         * 最后500个人只剩一人，
         * 请问，这个最后剩下的人一开始是第几个人？
         * 
         * 使用数组的思路
         */
        
        boolean[] arr = new boolean[500];//只要还在圈里的 都是true
        
        for(int i = 0; i< arr.length;i++){
            //一开始全部都在圈里
            arr[i] = true;
        }
        
        int leftCount = arr.length;//剩下的人数 初始化为500
        int countNum = 0;//记录报数的变量
        int index = 0;//position
        
        while(leftCount > 1){
            //只要剩下的人数>1个，就进入循环
            if(arr[index] == true){
                countNum ++;//只要在圈中就要报数
                if(countNum == 3){
                    //报数到3
                    countNum = 0;//清零 再重新报数
                    arr[index] = false;//报数到3 置为false 相当于出圈
                    leftCount -- ;//剩下的人-1
                }
                
            }
            
            index ++;//每循环一次，index+1
            if(index == arr.length){
                //一圈下来，index置为0，再开始新的一圈
                index = 0;
            }
        }
        
        //循环结束，圈里还剩一个人为true，找出这个人
        for(int i = 0;i < arr.length; i++){
            if(arr[i] == true){
                System.out.println(i+"  ");
            }
        }

二分查找法

查找都是在排序排好的基础上进行的，所谓二分查找法，是在排序排好的数组中，从中间的位置开始找，直到找到要找的值为止。

         //二分查找
     public static int binarySearch(int[] a,int i){ 
         if(a.length == 0){
             return -1;
         }
         int startPos = 0;
         int endPos = a.length - 1;
         int m = (startPos + endPos) / 2;
         while(startPos <= endPos){
             if(i == a[m]){
                 //如果要查找的值，刚好等于中间值
                 return m;
             }
             if(i > a[m]){
                 //如果要查找的值，比中间值大，说明在中间值的右边
                 startPos = m + 1;//更改起始位置
             } 
             if(i < a[m]){
                //如果要查找的值，比中间值小，说明在中间值的左边
                 endPos = m - 1;//更改结束位置
             } 
            //一次循环结束，更改m
             m = ( startPos + endPos ) / 2;
         }
         return -1;
     }

二维数组

二维数组可以看成已数组为元素的数组。如：
int a[][] = {{1,2},{3,4,5},{7,8,9}};
二维数组的声明和初始化应该从高维到低维的顺序进行（也就是从左到右），如：
int a[][] = new int[3][];//合法
int a[][] = new int[][4];//非法
二维数组在内存中的情况如下：

二维数组在内存中的情况

二维数组的初始化

静态初始化

int a[][] = {{1,2},{3,4,5},{7,8,9}};

动态初始化

int a[][] = new int[3][5];
int b[][] = new int[3][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];

数组的拷贝

System.arraycopy(Object srcArr,int srcPos,Object dest,int destPos,int length);
数组srcArr从srcPos项元素开始的length个元素拷贝到dest数组从destPos项开始的length个位置。

数组结束。下一章常用类

欢迎关注个人公众号，加入进来一起学习吧！

平头哥写代码