数组，选择排序，冒泡排序

数组的定义（概念）以及两种格式

定义：可以存放同一种数据类型的多个数据（元素）的一个容器
既可以存基本数据类型（8种：byte,short,int,long,float,double,boolean,char）
也可以存引用数据类型（类，接口，数组）

格式：
格式1：数据类型[] 数组名（变量名）
格式2：数据类型 数组名[]（变量名[]）

如何给数组初始化：
Java中的数组必须先初始化，然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
数组的索引值，是0开始计数
数组内存分配
一个数组变量的内存分配示意图

两个数组的内存分配

三个数组的内存分配

总结：

new出来的东西，永远是在堆上存储的
多次new出来的东西，永远都不一样（元素值一样，不能代表是同一个数组）

多个数组变量，可以同时指向同一块内存空间
数组的静态初始化问题：
格式：
数据类型[] 数组名（变量名）= new 数据类型[] {元素1，元素2...};

举例：

int[] array1 = new int[]{1,2,3}

简写格式：

int[] array1 = {1,2,3}

赋值：赋值时候不能够使用静态初始化的简写形式

int[] array3;
//array3 = {1,2,3};
array3 = new int[]{1,2,3};

数组操作时会发生的异常

数组索引越界：ArrayIndexOutOfBoundException 访问了不存在的·索引元素
空指针异常：NullPointerException 访问了在堆中不存在的元素内容
选择排序：（直接排序）数组第一个元素与其他元素 两两比大小：
小了啥也不做，
大了 就元素交换位置
重复上面的步骤，可以完成所有数组元素的排序

public static void main(String[] args) {

            int[] array1 = {5,7,13,2,9,11};

            //排序前，遍历数组元素
            printArray(array1);
            for(int j=0;j<array1.length-1;j++){//j=0,j=1
                  for(int i=j;i<array1.length-1;i++){//i=0,1,2,3,4,5
                        if(array1[j]>array1[i+1]){
                              int temp = array1[j];
                              array1[j] = array1[i+1];
                              array1[i+1] = temp;
                        }
                  }
            }
/*          //排序，做了5次比较
            for(int i=0;i<array1.length-1;i++){
                  if(array1[0]>array1[i+1]){
                        int temp = array1[0];
                        array1[0] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，做了4次比较
            for(int i=1;i<array1.length-1;i++){
                  if(array1[1]>array1[i+1]){
                        int temp = array1[1];
                        array1[1] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，做了3次比较
            for(int i=2;i<array1.length-1;i++){
                  if(array1[2]>array1[i+1]){
                        int temp = array1[2];
                        array1[2] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，做了2次比较
            for(int i=3;i<array1.length-1;i++){
                  if(array1[3]>array1[i+1]){
                        int temp = array1[3];
                        array1[3] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，做了1次比较
            for(int i=4;i<array1.length-1;i++){
                  if(array1[4]>array1[i+1]){
                        int temp = array1[4];
                        array1[4] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            */
            //排序后，遍历数组元素
            printArray(array1);
      }
      /**
       * 循环遍历数组元素
       * @param array1
       */
      public static void printArray(int[] array1){
            System.out.print("[");
            for(int i=0;i<array1.length;i++){
                  if(i == array1.length-1){
                        System.out.println(array1[i]+"]");
                  }else{
                        System.out.print(array1[i]+",");
                  }
            }
      }

冒泡排序：
数组的相邻两元素进行比较:
如果前面的元素小于后面的元素，不变
如果前面的元素大于后面的元素，交换
...
重复上面的步骤，可以实现数组的排序

public static void main(String[] args) {
            //原始数组
//          int[] array1 = {5,7,13,2,9,11};
            int[] array1 = {5,7,13,2,39,21,19,21};

            System.out.println("原始数组内容：");
            printArray(array1);

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

/*          //排序，冒泡排序，比了5次
            for(int i=0;i<array1.length-1-0;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，冒泡排序，比了4次
            for(int i=0;i<array1.length-1-1;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，冒泡排序，比了3次
            for(int i=0;i<array1.length-1-2;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，冒泡排序，比了2次
            for(int i=0;i<array1.length-1-3;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序，冒泡排序，比了1次
            for(int i=0;i<array1.length-1-4;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
*/                      
            System.out.println("排序后数组内容：");
            printArray(array1);
      }

      /**
       * 循环遍历数组元素
       * @param array1
       */
      public static void printArray(int[] array1){
            System.out.print("[");
            for(int i=0;i<array1.length;i++){
                  if(i == array1.length-1){
                        System.out.println(array1[i]+"]");
                  }else{
                        System.out.print(array1[i]+",");
                  }
            }
      }

Arrays 工具类的使用，jdk中折半查找的代码实现

在jdk中有个决定俗称的惯例： 类名+s,表示是一个工具类。
制作工具类的时候，喜欢（建议）将成员 设置为static

Arrays.sort(array);

对指定的 xx 型数组按数字升序进行排序。

binarySearch(array, value);

使用二分搜索法来搜索指定的 xx 型数组的范围，以获得指定的值。

二维数组的定义与使用

// 定义一个二维数组，3个一维数组，每一个一维数组中有两个元素
int[][] array1 = new int[3][2];
// 取 二维数组源 地址值
System.out.println(array1);
// 取二维数组中的第一个元素
System.out.println(array1[0]);

二维数组的第二种格式 数据类型[][] 变量名 = new 数据类型[m][];
m:二维数组中有几个一维数组（元素）

// 定义一个整型的二维数组，二维数组当中有三个一维数组（元素）
int[][] array2 = new int[3][];
// 给二维数组的元素赋值
array2[0] = new int[3];
// 如果想获取一个内存地址值，目前只能是new 数据类型接口[];
// 如何获取二维数组中的每一个一维数组元素的内容：数据类型[m][n]
// array2[2][2]：获取二维数组中第三个元素的一维数组中的第三个元素。

二维数组的第三种格式
数据类型[][] 变量名 = new 数据类型[][]{{元素1...},{元素1...},{元素1...}};

简化格式：

数据类型[][] 变量名 = {{元素1...},{元素1...},{元素1...}};

// 定义一个二维数组，并且初始化
int[][] array3 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };