数组，常见算法和匿名内部类

数组

1.有关array的概念

1. Java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object

2. 数组实际上是有关容器，可以容纳多个元素。（数组是一个数据的集合）

3. 数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据

4. 数组因为是引用数据类型，所以数组对象是推内存当中。（数组是存储在堆内存当中的）

5. 数组当中如果存储的是“Java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储Java对象。

6. 数组一旦创建，在Java中规定，长度不可变。（数组长度不可变）

7. 数组的分类：一维数组，二维数组，三维数组，多维数组。。。

8. 所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数。

9. Java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型

10. 数组在内存方面存储的时候，数组中的元素内存地址（存储的每一个元素都是有规则的挨着排列的）是连续的，内存地址连续

    数组实际上是一种简单的数据结构。

11. 所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。（数组中首元素的内存地址作为整个数组对象的内存地址。）

12. 数组中的每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1

13. 数组优点和缺点：

    优点：查询某一个下标上的元素时效率极高，数组中元素查找是通过数学表达式计算出来的，算出一个内存地址，直接定位的。

    ​ 为什么检索效率高？

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

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

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

    缺点：

    ​ 第一：为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。（对数组最后一个元素增删，是没有效率影响的）

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

14. 定义一个数组：

    语法格式：int[] array1; double[] array2; 等

15. 初始化一个一维数组：

    包括两种方式：静态初始化一维数组，动态初始化一维数组

    静态初始化语法格式：

    int [] array = {100,20,29};

    动态初始化语法格式：

    int[] array = new int[5]; //5表示数组的元素个数

    ​ //初始化一个5个长度的int类型数组，每个元素默认值0

    String[] names = new String[6] ; //初始化6个长度的String类型数组，每个元素默认值null

16. 当创建数组的时候，确定数组存储哪些具体元素时，采用静态初始化方式

    当创建数组的时候，不确定将来数组中存储哪些数据，可以采用动态初始化的方式，预先分配内存空间。

2.main方法上面的“String[] args”

1.main方法上面的“String[] args”作用主要是用来接收用户输入参数的

3.一维数组（数组中存储的类型为：引用数据类型）

对于数组来说，实际上只能存储Java对象的“内存地址”。数组中存储的每个元素是“引用”。

4.一维数组的扩容

1. 在Java开发中，数组长度一旦确定不可变，数组满了，需要扩容。
2. Java中对数组的扩容是：先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
3. 【结论】数组扩容效率较低，因为涉及到拷贝的问题。所以在开发中尽可能少的进行数组的拷贝。可以在创建数组对象的时候预估价以下多长合适，最好预估准确，这样可以减少数组的扩容次数，提高效率。
4. 数组中如果存储的元素是引用也可以拷贝。这里拷贝的时候拷贝的是拷贝对象的地址

5.二维数组

1. 二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素有一个一维数组

2. 二维数组静态初始化：

   int[][]  array = {{100,20,39}{38,34,35,34}{6,4,4}{0}}
   

3. 二维数组动态初始化：

   int[][] array = new int [3][4]
   

6.常见的算法

排序算法：

​ 冒泡排序算法

1. 每次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的气泡）
2. ==核心：==拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。

​ 选择排序算法

1. 选择排序比冒泡排序的效率高，高在交换位置的次数上
2. 选择排序的交换位置是有意义的
3. ==核心：==每次从参与比较的数据中找出最小值，拿着这个最小值和最前面的元素交换位置

查找算法：

​ 二分法查找

1. 二分法查找是基于排序的基础上。
2. 二分法查找效率要高于“一个挨着一个”的这种查找方式
3. 二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素

内部类——匿名内部类

1. 内部类：在类的内部又定义了一个新的类，被称为内部类

2. 内部类的分类：

   静态内部类：类似于静态变量

   实例内部类：类似于实例变量

   局部内部类：类似于局部变量

3. 使用内部类编写的代码，可读性很差，能不用尽量不用

4. 匿名内部类是局部内部类的一种。

   因为这个类没有名字而得名，叫做匿名内部类

5. 匿名内部类的缺点：太复杂，太乱，可读性差。类没有名字，以后想重复使用，不能使用。