java [数组]-[数组工具类]

 

一、数组

1. 概念:  数组装同一种数据类型元素的容器.数组中装的内容叫元素.

2. 数组结构和基本要素:

2.1. 标识符:数组的名称,用来区分不同数组

2.2. 数组元素:数组中存放的数据

2.3. 元素下标:数组对传入其中的元素的顺序编号

2.4. 元素类型:数组元素的数据类型

3. 特点:  

3.1. 可以存储指定类型的数据,如8大基本数据类型数据,也可以引用类型,包括对象和数组

3.2. 无论存储什么内容一个数组的定义的时候就明确类型,数组是只能存放一种类型元素,数组本身是引用类型

3.3. 数组长度是固定的,数组中的元素是有序排列的,数组的元素可以相同

3.4. 数组通过角标来进行操作数组中的元素 角标从0 到 数组长度 length-1
 

数组的内存结构

4. 数组的使用包括四步

4.1. 声明数组  int [] i;//在i变量存在于栈内存中,它用来存放数组的起始地址 

4.2. 分配空间  i = new [5]; //在堆内存中为数组开辟连续的空间,并且进行默认的初始化

4.3. 显式赋值  i[0] = 4; //将数据存放到数组中

4.4. 出来数据   i[0] = i[0]*2;//通过数组下标进行访问数组元素

5. 数组的定义格式:

  一维数组: 数组类型[] 数组名;

      二维数组: 数组类型[][] 数组名;

      多维数组: 数组类型[][]...[] 数组名;
      []号可以放在数组名之后,如int  i[] ; int i[][]  ;int [] i [];

6. 数组的空间分配

6.1. 对数组int [] i ;分配空间i = new int[5];

6.2. 声明数组并分配空间 : 数据类型[] 数组名 = new 数据类型[数组大小];

     数组大小就是数组能装的元素个数

7. 数组的初始化包括默认初始化和显式初始化

7.1. 默认初始化:在分配空间的时候会首先进行对数组默认初始化

7.1.1. 按默认初始值来初始化各元素
整型为0

   浮点型为0.0

   布尔类型为false,

   字符类型为 空字符

7.2. 显式初始化有动态初始化和静态初始化

7.2.1. 动态初始化：数组定义与为数组分配空间和赋值的操作分开进行,即先定义后赋值

7.2.1.1. Int[] i = {}; i[0] = 2;//这种方式赋值时下标可以int类型的0以上取值范围

7.2.1.2. Int[] i = new int[5]; i[0] = 2;//这种方式赋值时下标不能大于(指定大小-1)

7.2.1.3. Int[] i = new int[]{}; i[0] = 2;//这种方式赋值时下标可以int类型的0以上取值范围

7.2.2. 静态初始化:  数组的定义的同时给数组显式赋值

7.2.2.1. int[] i = {2,4,7};//直接赋值,数组的长度由系统自动计算,并分配所需内存空间

这种方式必须声明与初始化一条语句
   int[] m = {1,2,4,5,4,2};//正确
  int[] m;
   m = {1,2,4,5,4,2};//错误

7.2.2.2. Int[] i = new int[]{4,6,8};//这种方式赋值不能指定数组大小

Int[] i = new int[5]{3,5};//错误!

8. 怎么获取数组元素?

   通过 for (int i;i<arr.length ;i++ )遍历  得到每个元素arr[i]并可以对其进行操作
   或增强型 for(数组元素类型 元素 : arr)遍历

9 数组操作常见问题

• 数组脚标越界异常(ArrayIndexOutOfBoundsException)

     int[] arr = new int[2];
     System.out.println(arr[3]);
      访问到了数组中的不存在的脚标时发生。

• 空指针异常(NullPointerException)
  

     int[] arr = null;
     System.out.println(arr[0]);
     arr引用没有指向实体，却在操作实体中的元素时。

10 多维数组

   

   二维数组[][]
  格式1：int[][] arr = new int[3][2];

   定义了名称为arr的二维数组
   二维数组中有3个一维数组
   每一个一维数组中有2个元素
   一维数组的名称分别为arr[0], arr[1], arr[2]
   给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

   格式2：int[][] arr = new int[3][];

   二维数组中有3个一维数组

   每个一维数组都是默认初始化值null

   可以对这个三个一维数组分别进行初始化
   arr[0] = new int[3];
   arr[1] = new int[1];
   arr[2] = new int[2];

   格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

    定义一个名称为arr的二维数组

    二维数组中的有三个一维数组
    第一个一维数组中具体元素也都已初始化
    第一个一维数组arr[0] = {3,8,2};
    第二个一维数组arr[1] = {2,7};
    第三个一维数组arr[2] = {9,0,1,6};
    第三个一维数组的长度表示方式：arr[2].length;

二、Arrays 类 是操作数组的工具类

1.  Arrays 里的所有方法都是 static 故使用时不需要 new 对象 而直接通过类名调用

1.1. 基本方法:

1.1.1. <T> List<T> asList(T...a)将数组变集合

a. 将数组变集合好处是可以使用集合的思想和方法来操作数组元素
   如:get();indexOf();subList()等

b. 将数组变集合后不可以使用集合的增删方法,因为数组的长度固定

将集合变数组方法是 <T> T[] toArray( T [])
集合变数组的目的是限定对元素的增删操作。

c. 该方法参数为泛型可变参数，传入的为一维基本类型的数组时将被视为

一个参数且存入到集合中时也视为一个集合元素 ；如果传入的为多维

基本类型的数组或一维或多维的引用类型数组，则该数组将被拆开最外层

数组，并将数组元素作为可变参数依次存入到集合中，每个集合元素就是

一个数组元素

1.1.2. 查:

1.1.2.1. 二分法搜索数组元素位置

static int binarySearch（数组，元素）
      ---二分法搜索指定数组,获取指定数组的指定元素的下标

  该方法适用于基本类型数组（boolean[]除外）Object类型

  数组，使用之前必须先对数组进行排序（sort方法）

 static int binarySearch（数组，起始位置，终止位置，元素）
   ---二分法搜索指定数组中指定范围内的指定元素的角标

  该方法适用于基本类型数组（boolean[]除外）Object类型

  数组，使用之前必须先对数组进行排序（sort方法）

   static <T> int binarySearch
      ---二分法搜索指定泛型数组,获取指定对象

在进行此调用之前，必须根据指定的比较器（通过 sort(T[], Comparator)

方法）对数组进行升序排序。

1.1.3. 复制数组:

复制数组获取一个副本，被复制的数组可以是8种基本类型数组

 也可以是引用类型，可以从零角标开始截取指定长度，如果实际

 原数组长度小于截取长度，则用默认值填充超出的部分

1）按长度截取

static 数组 copyOf(数组,int newLength)
     ---复制指定数组,截取或用 0 （数值型）或null（字符型）或false（boolean型）

          填充（如果截取的指定长度大于原数组长度时），副本数组长度即为newLength
   static <T> T[] copyOf(T[] og,int newLength)
     ---复制指定的数组，截取或用 null 填充（如果截取的长度大于原数组长度），副 本具有指定的长度即为newLength。

   static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]>  newType)
     -----复制指定的数组，截取或用 null 填充（如果截取的长度大于原数组长度）， 副本具有指定的长度即为newLength。
  

2）按指定角标范围截取

   static 数组 copyOfRange(数组,int from,int to)
      ---将指定数组的指定范围复制到一个新数组。
   static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends  T[]> newType)
      --- 将指定数组的指定范围复制到一个新数组。

1.1.4. 判断:

1.1.4.1. 深度比较,用来比较Object类型数组,与equals(Object[] a,Object[] a2)

方法不同,此深度比较方法适用于任意深度的嵌套数组,即多维数组。

static boolean deepEquals(Object[] a1, Object[] a2)
      ---如果两个指定数组彼此是深层相等 的，则返回 true。

       对多维数组,会对每一内层元素进行比较,都相等时才会true

1.1.4.2. 一般比较,可以比较基本类型或Object类型数组是否相等

    判断依据是两相同类型的数组的长度相等且数组对应位置

     的元素分别相等,那么这两个数组是相等的

   static boolean equals(基本数据类型[] a, 基本数据类型[] a2)
     ---如果两个指定的 (相同)基本数据类 型数组彼此相等，则返回 true。
   static boolean equals(Object[] a, Object[] a2)
     ---如果两个指定的 Objects 数组彼此相等，则返回 true。

只比较当前数组存放的元素是否分别相等,多维数组不比较内层元素 

1.1.5. 填充

填充可以对8种基本类型数组或Object类数组进行填充

可以按指定范围填充也可以全部填充

1.1.5.1. 全部填充

static void fill(数组, 同数组元素类型的值)
     ---将指定值分配给指定数组的每个元素

1.1.5.2. 填充指定范围

static void fill(数组,同数组元素类型的值,int from,int to)
     ---将指定值分配给指定数组指定范围的每个元素
   

1.1.6. 排序

可以对boolean类型以为的基本类型数组或Object数组或给定了比较器的泛型类

数组进行排序

可以对整个数组进行排序也可以对数组的某个访问内进行排序

进行二分法搜索的时候必须配合该排序法使用

1.1.6.1. 全范围排序

static void sort(数组)
       ---对指定数组按数字升序进行排序。

1.1.6.2. 指定范围排序
           static void sort(数组, int fromIndex, int toIndex)
                   ---对指定 数组的指定范围按数字升序进行排序。

1.1.7. 获取数组的hashCode 值

1.1.7.1. 根据数组的元素获取 hashCode值 ,适用于基本类型数组,Object类型数组

static int hashCode(数组) 

----基于指定数组的内容返回哈希码。

1.1.7.2. 深层数组元素获取 hashCode值 ,使用于多维数组

static int deepHashCode(Object[] a)

----基于指定数组的“深层内容”返回哈希码。

1.1.8. 获取数组的字符串形式,可以将基本类型数组或Object类型数组内容

以字符串形式返回

toString(数组) 返回数组内容的字符串形式