02数组（一维，二维）

2.1数组概要

数组是一种引用数据类型，在内存中存储示意图如下：

 

        数组是一组数 据的集合

        数组作为一种引用类型

        数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型

        数组作为对象，数组中的元素作为对象的属性，除此之外数组还包括一个成员属性

length ， length 表示数组的长度

        数组的长度在数组对象创建后就确定了，就无法再修改了

        数组在内存方面存储的时候，内存地址是连续的

        数组中首元素的内存地址作为整个数组对象的内存地址

        数组元素是有下标的，下标从 0 开始，也就是第一个元素的下标为 0 ，依次类推最后一

个元素的下标为 n-1 ，我们可以通过数组的下标来访问数组的元素

 

2.2一维数组的声明和使用

2.2.1数组的声明

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

        

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

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

数组元素的类型，可以是 java 中的任意类型，变量名称可以是任意合法的标识符，上面两

种格式较常用的是第一种，例如：

int [] a;

Student[] stu

在一行中也可以声明多个数组，例如：

int[] a, b, c

2.2.2数组的创建

两种方式：

        第一种，使用 new 操作符来创建数组。

        

格式为：

        new 数组元素的数据类型 [ 数组元素的个数]

int[] nums = new int[5];

1.基本类型的数组

 数组为引用类型，它在堆中分配

2.引用类型的数组

public class Test20 {
    public static void main(String[] args) {
        //声明引用类型的数组
        Student[] student = new Student[2];
        //出现空指针
        //因为引用类型的数组，它采用 null 作为默认的初始化值
        student[0].id = 1001;
        student[0].name = "张三";
        student[1].id = 1002;
        student[1].name = "李四";
    }
}

 

 修正空指针

public class Test20 {
    public static void main(String[] args) {
        //声明引用类型的数组
        Student[] student = new Student[2];
        //出现空指针
        //因为引用类型的数组，它采用 null 作为默认的初始化值
        /*student[0].id = 1001;
        student[0].name = "张三";
        student[1].id = 1002;
        student[1].name = "李四";
        */
        //可以采用如下方式赋值
        Student zhangsan = new Student();
        zhangsan.id = 1001;
        zhangsan.name = "张三";
        student[0] = zhangsan;
        Student lisi = new Student();
        lisi.id = 1002;
        lisi.name = "李四";
        student[1] = lisi;

    }
}

class Student {
    int id;
    String name;
}

 

第二种，使用数组的初始化语句，格式为：数组元素的类型 [] 变量名称 = { 数组元素 1 ，

数组元素 2,...... 数组元素 n} 或数组元素的类型 变量名称 [] = { 数组元素 1 ，数组元素 2,......

数组元素 n}

//静态初始化

int[] nums = {1, 2, 3, 4, 5};

 //静态初始化

Student[] students = {zhangsan, lisi};

2.3二维数组的声明和使用

二维数组属于多维数组，那么什么是多维数组呢，当数组元素的类型是数组时就成了多维数

组，二维数组的声明格式如下：

        数组元素的数据类型[][] 变量名；

        数组元素的数据类型 变量名[][] ；

其中方括号的个数就是数组的维数。

声明二维数组如下：

        int [][] data;

三种二维数组的创建方式 ：

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

// 声明二维数组

int[][] data = new int[2][3];

 2.从高维开始逐维创建

        int[][] data = new int[2][];

        data[0] = new int[2];

        data[1] = new int[4];

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

//静态初始化

// 多个数组之间用逗号隔开

int[][] data = {{1,2},{1,2,3,4}};

2.4Arrays工具类

2.4.1  Arrays.sort 的使用

1.Arrays.sort(int[] a)

这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。

public class Main {
    public static void main(String[] args) {

        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + " ");
        }
    }

}

运行结果如下：

0 1 2 3 4 5 6 7 8 9

2、Arrays.sort(int[] a, int fromIndex, int toIndex)

这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序！

public class Main {
    public static void main(String[] args) {

        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, 0, 3);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + " ");
        }
    }

}

运行结果如下：

7 8 9 2 3 4 1 0 6 5

3、public static void sort(T[] a,int fromIndex,int toIndex, Comparator c)

上面有一个拘束，就是排列顺序只能是从小到大，如果我们要从大到小，就要使用这种方式，其实就是多了一个Comparator类型的参数而已。

 public class Main {
 public static void main(String[] args) {
                        //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
                         //而要使用它们对应的类
                        Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
                         //定义一个自定义类MyComparator的对象
                        Comparator cmp = new MyComparator();
                         Arrays.sort(a, cmp);
                         for(int i = 0; i < a.length; i ++) {
                                 System.out.print(a[i] + " ");
                             }
                     }
 }
         //Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
         //而不是extends Comparator
         class MyComparator implements Comparator<Integer>{
     @Override
    public int compare(Integer o1, Integer o2) {
                         //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
                         //这样颠倒一下，就可以实现反向排序了
                         if(o1 < o2) {
                                 return 1;
                            }else if(o1 > o2) {
                                 return -1;
                             }else {
                                 return 0;
                           }
                    }

运行结果如下：

9 8 7 6 5 4 3 2 1 0

2.4.2  Arrays.binarySearch 的使用

通过二分法在已经排好序的数组中查找指定的元素，并返回该元素的下标

1.如果数组中存在该元素，则会返回该元素在数组中的下标

public class binarySearch {
        public static void main(String[] args) {
        int[] scores = {1, 20, 30, 40, 50};
        //在数组scores中查找元素20
        int res = Arrays.binarySearch(scores, 20);
        //打印返回结果
        System.out.println("res = " + res);
    }
   }

 运行结果： res = 1

2.如果数组中不存在该元素，则会返回 -(插入点 + 1)
这里的插入点具体指的是：如果该数组中存在该元素，那个元素在该数组中的下标

public class binarySearch {
    public static void main(String[] args) {
        int[] scores = {1, 20, 30, 40, 50};
        //1.在数组scores中查找元素25
        //从数组中可以看出 25位于20与30之间，
        //由于20的下标为1，所以25的下标为2，
        //最后的返回值就为：-(2 + 1) = -3
        int res1 = Arrays.binarySearch(scores, 25);
        //2.同理在该数组中查找-2
        //可以看出-2比数组中的任何一个元素都要小
        //所以它应该在数组的第一个，所以-2的下标就应该为0
        //最后的返回值就为：-(0 + 1) = -1
        int res2 = Arrays.binarySearch(scores, -2);
        //3.又例如在该数组中查找55
        //由于55比数组中的任何一个元素都要大
        //所以他应该位于数组的最后一个，它的下标就为5
        //最后的返回值就为：-(5 + 1) = -6
        int res3 = Arrays.binarySearch(scores, 55);
        //打印返回结果
        System.out.println("res1 = " + res1);
        System.out.println("res1 = " + res2);
        System.out.println("res1 = " + res3);
    }
}

运行结果：
res1 = -3
res1 = -1
res1 = -6

数组这种数据结构的优点和缺点是什么?

        优点:查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。
为什么检索效率高?

        第一:每一个元素的内存地址在空间存储上是连续的。

        第二;每一个元秦类型相同，所以占用空间大小一样。

        第三;知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。

数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个内存地址，查接定位的。)

缺点:

        第一:由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。

        第二:数组不能存储大数据量，为什么?
        因为很难在内存空间上找到一块特别大的连续的内存空间。

注意:对于数组中最后一个元素的增删，是没有效率影响的。