数组简介、创建、应用、数组工具类常用方法使用、冒泡排序、选择排序及二分查找

1、数组

    1.1、数组的优点和缺点，并且要理解为什么。
        第一：空间存储上，内存地址是连续的。
        第二：每个元素占用的空间大小相同。
        第三：知道首元素的内存地址。
        第四：通过下标可以计算出偏移量。
        通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。

        优点：检索效率高。
        缺点：随机增删效率较低，数组无法存储大数据量。
        注意：数组最后一个元素的增删效率不受影响。

    1.2、一维数组的静态初始化和动态初始化
        静态初始化：

            int[] arr = {1,2,3,4};
            Object[] objs = {new Object(), new Object(), new Object()};

        动态初始化：

            int[] arr = new int[4]; // 4个长度，每个元素默认值0
            Object[] objs = new Object[4]; // 4个长度，每个元素默认值null

    1.3、一维数组的遍历

        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }

    1.4、二维数组的静态初始化和动态初始化
        静态初始化：

   int[][] arr = {
                                    {1,2,34},
                                    {54,4,34,3},
                                    {2,34,4,5}
                                };

            Object[][] arr = {
                                    {new Object(),new Object()},
                                    {new Object(),new Object()},
                                    {new Object(),new Object(),new Object()}
                                };

        动态初始化：

  int[][] arr = new int[3][4];
  int[][]num=new int[4][];//列可空，行必须填否则报错。
  Object[][] arr = new Object[4][4];
  Animal[][] arr = new Animal[3][4];
  // Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型都可以。
  Person[][] arr = new Person[2][2];
  

    1.5、二维数组的遍历

   for(int i = 0; i < arr.length; i++){ // 外层for循环负责遍历外面的一维数组。
            // 里面这个for循环负责遍历二维数组里面的一维数组。
            for(int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j]);
            }
            // 换行。
            System.out.println();
        }

    1.6、数组的拷贝：System.arraycopy()方法的使用
        数组有一个特点：长度一旦确定，不可变。
        所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组，
        将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。

public class ArrayKuoRong {
    public static  void main(String[]args){
        int[] src={1,12,1234,4234,345,1243};
        int[]dest=new int[20];
        /**
         * 第一个参数源数组
         * 第二个原数组起始位置开始拷贝
         * 第三个目的数组
         * 第四个目的数组拷贝开始地方
         * 第五个拷贝长度*/
        System.arraycopy(src,2,dest,10,4);
    for(int i=0;i<dest.length;i++)
        System.out.print(dest[i]+" ");
    }
}

输出结果如下：

0 0 0 0 0 0 0 0 0 0 1234 4234 345 1243 0 0 0 0 0 0 

    1.7、数组内存结构图

2、数组中常见的算法

 2.1、常见的算法：

        排序算法：
            冒泡排序算法
            选择排序算法

        查找算法：
            二分法查找
        以上算法在以后的java实际开发中我们不需要使用的，因为java已经封装好了，直接调用就行。
    
    2.2、算法实际上在java中不需要精通，因为java中已经封装好了，要排序就调用方法就行。例如：java中提供了一个数组工具类：java.util.Arrays。
            Arrays是一个工具类。
            其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。

3、冒泡排序：

参与比较的数据：9 8 10 7 6 0 11
第1次循环：
8 9 10 7 6 0 11 (第1次比较：交换)
8 9 10 7 6 0 11 (第2次比较：不交换)
8 9 7 10 6 0 11 (第3次比较：交换)
8 9 7 6 10 0 11 (第4次比较：交换)
8 9 7 6 0 10 11 (第5次比较：交换)
8 9 7 6 0 10 11 (第6次比较：不交换)
最终冒出的最大数据在右边：11

参与比较的数据：8 9 7 6 0 10
第2次循环：
8 9 7 6 0 10（第1次比较：不交换）
8 7 9 6 0 10（第2次比较：交换）
8 7 6 9 0 10（第3次比较：交换）
8 7 6 0 9 10（第4次比较：交换）
8 7 6 0 9 10（第5次比较：不交换）

参与比较的数据：8 7 6 0 9
第3次循环：
7 8 6 0 9（第1次比较：交换）
7 6 8 0 9（第2次比较：交换）
7 6 0 8 9（第3次比较：交换）
7 6 0 8 9（第4次比较：不交换）

参与比较的数据：7 6 0 8
第4次循环：
6 7 0 8（第1次比较：交换）
6 0 7 8（第2次比较：交换）
6 0 7 8（第3次比较：不交换）

参与比较的数据：6 0 7
第5次循环：
0 6 7（第1次比较：交换）
0 6 7（第2次比较：不交换）

参与比较的数据：0 6
第6次循环：
0 6 （第1次比较：不交换）

for(int i = 6; i > 0; i--){ // 6次
    //7条数据比6次
    //6条数据比5次
    //5条数据比4次
    //4条数据比3次
    //3条数据比2次
    //2条数据比1次
    for(int j = 0; j < i; j++){
    
    }
}

代码如下：

public class MaoPao {
    public static void main(String[]args){
        int[]a={12,131,42,566,455,1234,235,768};
        int temp;
        for(int i=a.length-1;i>0;i--)
            for (int j=0;j<i;j++){
                if(a[i]<a[j]){
                    temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
}

结果如下：

12 42 131 235 455 566 768 1234 

4、选择排序：

    选择排序比冒泡排序的效率高。
    高在交换位置的次数上。
    选择排序的交换位置是有意义的。

    循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和
    最前面的数据“交换位置”。

    参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0）
    第1次循环之后的结果是：
    1 3 6 2 5 

    参与比较的数据：3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1）
    第2次循环之后的结果是：
    2 6 3 5 

    参与比较的数据：6 3 5 （这一堆参加比较的数据中最左边的元素下标是2）
    第3次循环之后的结果是：
    3 6 5 

    参与比较的数据：6 5 （这一堆参加比较的数据中最左边的元素下标是3）
    第4次循环之后的结果是：
    5 6

    注意：5条数据，循环4次。

代码如下：

public class XuanZe {
    //选择排序
    public static void main(String[]args){
        int[]a={12,131,42,566,455,1234,235,768};
        int temp;
        for(int i=0;i<a.length;i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++)
                if (a[min] > a[j])
                    min = j;
            if (min != i) {
                temp = a[min];
                a[min] = a[i];
                a[i] = temp;
            }
        }
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
}

结果如下：

12 42 131 235 455 566 768 1234 

5、二分法查找（折半查找）：
    
    第一：二分法查找建立在排序的基础之上。
    第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
    第三：二分法查找原理？
        10(0下标) 23 56 89 100 111 222 235 500 600(下标9) arr数组
        
        目标：找出600的下标
            (0 + 9) / 2 --> 4（中间元素的下标）
        
        arr[4]这个元素就是中间元素：arr[4]是 100
        100 < 600
        说明被查找的元素在100的右边。
        那么此时开始下标变成：4 + 1

            (5 + 9) / 2 --> 7（中间元素的下标）
            arr[7] 对应的是：235
            235 < 600
            说明被查找的元素在235的右边。
        
        开始下标又进行了转变：7 + 1
            (8 + 9) / 2 --> 8
            arr[8] --> 500
            500 < 600
            开始元素的下标又发生了变化：8 + 1
            (9 + 9) / 2 --> 9
            arr[9]是600，正好和600相等，此时找到了。
            

代码如下：

public class ErFen {
    //二分查找
    public static void main(String[]args){
        int[]a={12,14,16,45,57,67,78,89};
        int index=binarySerach(a,12);
        System.out.println(index);
    }
    public static int binarySerach(int[] a, int x){
       int begin=0;
       int end=a.length-1;
       while(begin<=end){
           int mid=(begin+end)/2;
           if(a[mid]>x){
                end =mid-1;
           }else if(a[mid]<x){
                begin=mid+1;
           }else
               return mid;

       }
       return  -1;
    }
}

执行结果为0，表示在数组中存在12这个数据。

6、介绍一下java.util.Arrays工具类，所有方法都是静态的，直接用类名调用主要使用的是两个方法：二分法查找，排序。

代码如下：

public class ArrayUtil {
    public static void main(String[]args){
        int[]a={12,131,42,566,455,1234,235,768};
        //sort升序排序
        Arrays.sort(a);
        for (int i=0; i<a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
        System.out.println("----------------");
        //倒序输出
        for (int i=a.length-1; i>=0; i--) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
        System.out.println("----------------");
        //binary二分查找 //a已排好序
        int index = Arrays.binarySearch(a, 455);
        System.out.println("数字455下标->"+index);
    }
}

结果如下：

12 42 131 235 455 566 768 1234 
----------------
1234 768 566 455 235 131 42 12 
----------------
数字455下标->4