Java基础学习之数组

数组:指的是一组相关变量的集合

声明：

数据类型 数组名称[] = new 数据类型[长度]{}

数据类型 []数据名称 = new 数据类型[长度]{}

分步完成：

|-声明数组：数据类型 数组名称 [] = null

|-开辟数组：数据类型 = new 数据类型[长度]

数组定义结构使用的是动态初始化的方式：即数组会首先开辟内存空间，但是数组中的内容都是其对应数据类型的默认值。

虽然数组的操作比较简单，但是其最麻烦的问题在于，他也属于引用数据类型，所以以上代码依然需要牵扯到内存分配，与对象保存唯一的区别在于：对象的堆内存保存的是属性，而数组中堆内存保存的是一组信息

引用传递的本质：同一块堆内存空间可以被不同的栈所访问。

动态初始化的操作特点：先开辟数组空间，而后维数组内容进行赋值。那么 在数组定义之中还提供有静态初始化的操作，即：数组定义的同时就设置好了相应的数据内容。

格式一：简化格式：数据类型  数据名称[] ={}

格式二：数据类型  数据名称[] =new 数据类型[]{}

在实际的工作之中，数组是会存在的，但是他的内容大部分情况下都是通过传递的数据而动态生成的，很少会出现这种新开辟数组而后去使用的情况。

虽然数组支持顺序的数据访问操作，但是数组有一个最大的缺点--长度不能改变，所以呢正因为如此，在开发之中，才不会直接去应用数组，但是会使用到数组的概念

数组与方法参数的传递：

动态初始化数组：开辟之后对象数组的内容都是null值；

声明对象数组：类名称 对象数组名称 []=null；

开辟对象数组：对象数组名称 = new 类名称[长度]

静态初始化：类名称 对象数组名称[]= new 类名称[]{实例化对象，实例化对象。。}

二维数组：

动态初始化：数据类型 数组名称 [] [] = new 数据类型[行的个数][列的个数]

静态初始化：数据类型 数组名称 [] [] = new 数据类型 [] [] {{值1,值2,值3}{值1,值2,值3}{值1,值2,值3}}

一维数组：数组中的每一个元素都是一个值（基本类型和引用类型的值）

二维数组：数组中的每一个元素又是一个一维数组

三维数组：数组中的每一个元素又是一个二维数组

数组的排序：（升序）排序的基本原理

    原始数据： 2、1、9、0、5、3、7、6、8；

    第一次排序：1、2、0、5、3、7、6、8、9；

    第二次排序：1、0、2、3、5、6、7、8、9；

    第三次排序：0、1、2、3、5、6、7、8、9；

根据数据的不同会出现不同的排序次数，但是不管有多少个数据总的排序不会超过数组的长度。所以只要排序的次数达到了“长度 * 长度”，那么所有的数据一定可以排序成功

数组的转置（首尾交换）

原始数组： 1、2、3、4、5、6、7、8；

转置后的数组： 8、7、6、5、4、3、2、1；

    利用算法，在一个数组上完成转置；

    原始数组： 1、2、3、4、5、6、7、8；

    第一次转置： 8、2、3、4、5、6、7、1；

    第二次转置： 8、7、3、4、5、6、2、1；

    第三次转置： 8、7、6、4、5、3、2、1；

    第四次转置： 8、7、6、5、4、3、2、1；

        但是以上给出的数组长度是一个偶数，如果是一个奇数呢？

        转换次数：数组长度 ÷ 2

        原始数组： 1、2、3、4、5、6、7

        第一次转置： 7、2、3、4、5、6、1

        第二次转置： 7、6、3、4、5、2、1

        第三次转置： 7、6、5、4、3、2、1

对象数组：

数组是引用类型，而类也同样是引用类型，所以如果是对象数组的话表示如果是对象数组的话表示一个引用类型里面嵌套其他的引用类型

在之前使用的数组都属于基本数据类型的数组，但是所有的引用数据类型也同样可以定义数组，这样的数组称为对象数组。如果想定义对象数组（以类为名）

动态初始化：开辟后对象数组的内容都是空值

声明并开辟对象数组 : 类名称 对象数组名称 [] = new 类名称[长度];

分布完成:

声明对象数组 : 类名称 对象数组名称 [] = null;

开辟对象数组 : 对象数组名称 = new 类名称 [ 长度 ] ;

静态初始化: 类名称 对象数组名称 [] = new 类名称[ ] { 实例化对象 , 实例化对象...}

总结:

1、数组用的很少，但是一定会用，而且数组的相关的逻辑关系比较麻烦

把数组的排序与转置要弄明白；

2、一切以一位数组为主，要明白数组的定义与内存关系（对象一致）

3、对象数组的定义语法，对象数组 = 多个对象

4、数组有一个最大的天生短板：长度固定，所以这就限制了数组在开发中的出现

5、数组的排序：java.util.Arrays.sort（）

增强for循环 foreach：循环迭代

for（数组元素类型 变量 ：数组名）{

循环体

}

二分法查找：

数组的搜索算法：从指定数组中搜索某一元素的索引是什么

方法1：线性搜索（从头搜到尾/从尾搜到头）：indexOf/lastIndexOf

对于元素过多的数组，性能极低：有N个元素，循环次数 = （N + 1） / 2；

方法2 ： 二分搜索法/二分查找法

前提：数组元素必须有顺序

算法：当数据量很大适宜采用该方法。

采用二分法查找时，数据需是排好序的。