Java学习笔记---数组

数组

知识框架：

数组概要

• 数组是一种引用数据类型。
• 数组使一组数据的集合
• 数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型。
• 数组作为对象，数组中的元素作为对象的属性，除此之外数组还包括一个成员属性 length， length 表示数组的长度。
• 数组的长度在数组对象创建后就确定了，就无法再修改了。
• 数组元素是有下标的，下标从 0 开始，也就是第一个元素的下标为 0，依次类推最后一个元素的下标为 n-1，我们可以通过数组的下标来访问数组的元素。

一维数组

一维数组的声明格式有以下两种：

1. 数组元素的类型[] 变量名称
2. 数组元素的类型 变量名称[]

数组元素的类型，可以是 java 中的任意类型，变量名称可以是任意合法的标识符，上面两种格式较常用的是第一种，例如：
int [] a;
Student[] stu
在一行中也可以声明多个数组，例如：
int[] a, b, c

一维数组的创建

数组有两种创建方式
第一种，使用 new 操作符来创建数组。
格式为：new 数组元素的数据类型[数组元素的个数]
例如：

public class ArrayTest01 {
    public static void main(String[] args) {
    //声明 int 类型的数组，长度为 5
    //数组中的元素必须为 int 类型
    int[] data = new int[5];
    //对数组中的元素进行赋值，如果不赋值默认为该类型的默认值，以上数组默认为 0
    data[0] = 1;
    data[1] = 2;
    data[2] = 3;
    data[3] = 4;
    data[4] = 5;
    //输出数组中的元素，变量名[下标]   
    System.out.println(data[0]);  
    System.out.println(data[1]); 
    System.out.println(data[2]); 
    System.out.println(data[3]);
    System.out.println(data[4]);

第二种，使用数组的初始化语句，格式为：数组元素的类型[] 变量名称 = {数组元素 1， 数组元素 2,…数组元素 n}或数组元素的类型 变量名称[] = {数组元素 1，数组元素 2,…数组元素 n}
例如：

public class ArrayTest02 {
   public static void main(String[] args) {
   //静态初始化
   int[] data = {1, 2, 3, 4, 5};
   for (int i=0; i<data.length; i++) {   
   System.out.println(data[i]);
}

二位数组

二维数组属于多维数组，当数组元素的类型是数组时就成了多维数组， 二维数组的声明格式如下：
1.数组元素的数据类型[][] 变量名；
2.数组元素的数据类型 变量名[][]；
其中方括号的个数就是数组的维数，声明二维数组如下：
int [][] data;

二位数组的创建

1.采用 new 关键字直接创建
例如：

public class ArrayTest03 {
   public static void main(String[] args) {
   //声明二维数组
   int[][] data = new int[2][3];
   //对二维数组赋值
   data[0][0] = 1;
   data[0][1] = 2;
   data[0][2] = 3;
   data[1][0] = 4;
   data[1][1] = 5;
   data[1][2] = 6;
   //输出二维数组
   for (int i=0; i<data.length; i++) {
      for (int j=0; j<data[i].length; j++) {    
      System.out.println(data[i][j];
      }
   }
 }
}

2.从高维开始逐维创建
例如：

public class ArrayTest04 {
    public static void main(String[] args) {
    //从高维开始逐维创建
    int[][] data = new int[2][]; 
    data[0] = new int[2]; 
    data[1] = new int[4];
    data[0][0] = 1;
    data[0][1] = 2;
    data[1][0] = 1;
    data[1][1] = 2;
    data[1][2] = 3;
    data[1][3] = 4;
    //输出二维数组
    for (int i=0; i<data.length; i++) {
        for (int j=0; j<data[i].length; j++) {      
           System.out.println(data[i][j];
            }
        }
    }
}

3.采用初始化语句块创建数组对象
例如：

public class ArrayTest05 {
    public static void main(String[] args) {
    //静态初始化
    // 多个数组之间用逗号隔开
    int[][] data = {{1,2},{1,2,3,4}};
    for (int i=0; i<data.length; i++) {
        for (int j=0; j<data[i].length; j++) {
             System.out.println(data[i][j];
             }
        }
    }
}

数组的排序

1.冒泡排序
冒泡排序的特点：

1. 每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边（冒出最大的那个气泡）。
2. 核心：用最左边的数字和右边的数字进行比较，当左边>右边的时候，交换位置。
   冒泡排序的代码实现：

public class ArraySortTest01 {
    public static void main(String[] args) {
    int[] data = {3,1,6,2,5};
    for (int i=data.length-1; i>0; i--) { 
        for (int j=0; j<i; j++) {
            if (data[j] > data[j+1])
                {int temp = data[j];
                 data[j] = data[j+1]; 
                 data[j+1] = temp;
                 }
            }
       }
    for (int i=0; i<data.length; i++) {      
           System.out.println(data[i]);
           }
 }

2.选择排序
选择排序的特点：
循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据“交换位置”。
选择排序比冒泡排序的效率高（高在交换位置的次数上）.
选择排序的代码实现：

public class ArraySortTest02 {
    public static void main(String[] args) {
    int[] data = {3,1,6,2,5};
    for (int i=0; i<data.length; i++) 
        { int min = i;
        for (int j=i+1; j<data.length; j++)
           { if (data[j] < data[min]) { 
                min = j;
               }
           }
        //进行位置的交换
        if (min != i) {
        int temp = data[i];
        data[i] = data[min];
        data[min] = temp;
        }
    }
    for (int i=0; i<data.length; i++) {   
      System.out.println(data[i]);
      }
    }
}

数组的查找

二分法（折半）查找
如果一个数组已经排好序，那么我们可以采用效率比较高的二分查找或叫折半查找算法。
二分查找的代码实现：

public class BinarySearchTest01 {
    public static void main(String[] args) {
        int[] data = {11,12,13,14,15,16,17,18,19,20};
        int index = binarySearch(data, 18);   
        System.out.println(index);
        }
    //采用折半法查询，必须建立在排序的基础上
    private static int binarySearch(int[] data, int value) {
    //开始下标
    int beginPos = 0;
    //结束下标
    int endPos = data.length - 1;
    while (beginPos <=endPos) {
    int midPos = (beginPos + endPos)/2; 
    if (value == data[midPos]) {
        return midPos;
    }else if (value > data[midPos]) {
     beginPos = midPos + 1;
    }else if (value < data[midPos]) { 
     endPos = midPos - 1;
     }
    }
    return -1;
 }
}