---

前言

本节会总结Java中各种数据结构里面的使用方法，包括之前的学过的数组、ArrayList、还包括链表、哈希表、树等数据结构一起其中的高级实用API。本博客会详细记录各种用法，作为个人的查询文档。

在学习这些数据结构前，前面有必要先来好好学习一下包装类，由于Java基本数据类型（可变）大部分集合都是不允许放进去的，我们必须要放其对应的包装类（不可变）才被允许放进去，所以学习这些集合第一关就是对应的包装类。

---

一、包装类

在前面我们其实简单讲过包装类，但讲的比较简单，这里做一个详细的笔记，方便后续查阅。

• 包装类：基本数据类型对应的引用数据累加
  将Java中的基本数据类型重新写成引用数据类型，并且是不可变的；这样就和python一样了，Python里面有一句名言，万物皆对象，有了包装类这句话是不是也可以移到Java中，Java中万物皆对象。
• 并且Java的集合的高级数据结构里面，基本数据类型由于其可变性，是不允许存进集合的；所以我们就需要将不可变的包装类存进集合实现相同的效果。

给出Java中基本数据类型和其对象的包装类内存图就清楚二者的关系了：

基本数据类型	对应的包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

可以看到只有char和int的包装类名有点变化要单独记一下，其余的都是首字母大写就可以了。
具体怎么用的建议先了解ArryList，下面给出示例：包装类就可以添加进集合了，表示方法和普通的写法一样，只是泛型要写包装类就是了。
下面以Integer演示包装类的用法，其他的都类似

1、Integer

（1）基本用法

// 创建 Integer
Integer a = 10;
Integer b = 11;

// 进行运算
Integer sum = a + b;
System.out.println(sum);    // 21

Double d = 5.0;
Double v = a * d;
double v1 = a * d;         // 这样也可以
System.out.println(v);     // 50.0  隐式类型转换这些都还有
System.out.println(v1);    // 50.0

可以看到和基本数据类型完全一样的用法，运算也一样，并且包装类和其对于的基本数据类型之间还存在自动隐式转换，使得二者是互通的。（这里设计到了我们等下要将的自动装箱、自动拆箱机制）

再看这个ArrayList list = new ArrayList<>();的例子ArrayList只能包装类进（可以跳到自动装箱哪里）

ArrayList<Integer> list = new ArrayList<>();
list.add(1);    // 自动装箱
list.add(2);
list.add(3);

for (Integer i : list) {
    System.out.print(i + " ");   // 1 2 3

这就是典型的自动装箱机制。

（2）JDK5前的包装类用法（了解即可，能更好帮助我们理解下面的自动装箱和自动拆箱机制）

在JDK5以前创建一个Integer对象，要用到一下这些复杂的方法（部分现在都已经废弃了）：

【注】：下面代码高版本jdk运行不了，方法已经废弃，这里只是做一个示例

Integer i1 = new Integer(1);
Integer i2 = new Integer(2);


// 如果要用上面JDK5前的这些方法创建Integer对象，进行计算需要手动拆箱，在装箱
// 因为对象之间不能直接进行运算
// 步骤：
// 1. 先将对象转换为基本数据类型（拆箱）
// 2. 进行运算
// 3. 将基本数据类型转换为对象（装箱）

int result = i1.intValue() + i2.intValue();  // 拆箱并运算
Integer i3 = new Integer(result);  // 装箱
System.out.println(i3);  

可以看到，包装类进行运算如果要手动拆箱后手动装箱，太麻烦了。没错，大佬们也觉得太麻烦了，于是JDK5以后就有了自动拆箱和自动装箱机制。

一个面试问题：

Integer i1 = Integer.valueOf(127);
Integer i2 = Integer.valueOf(127);
System.out.println(i1 == i2); // true

Integer i3 = Integer.valueOf(128);
Integer i4 = Integer.valueOf(128);
System.out.println(i3 == i4); // false

// 下面new出来的好理解，只要new出来的对象地址不同，肯定是false
Integer i5 = new Integer(127);
Integer i6 = new Integer(127);
System.out.println(i5 == i6); // false

Integer i7 = new Integer(128);
Integer i8 = new Integer(128);
System.out.println(i7 == i8); // false

关键在于前两段，为什么127的是true , 128的是false

查看源码会发现 -128到127间（闭区间）的因为在实际开发中应用的比较多，如果每次使用都new对象浪费内存，于是底层这样设计为：

• 提前把这个[-128,127]范围之内的每一个数据都创建好对象放进一个数组存起来
• 如果要用到了不会创建新的,而是返回已经创建好的对象，所以127地址一样的是，128地址不一样。

这是一个面试题，所以我也在这里写一下。

（3）自动装箱与自动拆箱机制 — 导致：int和Integer，包装类和对应的基本数据类型在不需要进集合的情况下是互通的（重要重要！！！！！）

Integer i1 = 100;           // 自动装箱
Integer i2 = 100;

Integer sum = i1 + i2;      // 内部会自动拆箱，然后再装箱
System.out.println(sum);

int i3 = 99;
int sum2 = i1 + i3;         // i1会自动拆箱
System.out.println(sum2);     // 199

// 注：除了部分集合只能包装类进，其他情况由于自动装箱拆箱，基本类型和包装类可以互相转换的，底层自动实现

再看这个ArrayList list = new ArrayList<>();的例子ArrayList只能包装类进

ArrayList<Integer> list = new ArrayList<>();
list.add(1);    // 自动装箱
list.add(2);
list.add(3);

for (Integer i : list) {
    System.out.print(i + " ");   // 1 2 3

这就是典型的自动装箱机制。

（4）Integer的常用方法

— 进制转换方法

方法名	说明
public static String toBinaryString(int i)	得到二进制
public static String toOctalString(int i)	得到八进制
public static String toHexString(int i)	得到十六进制

// 1 把整数转换成二进制
String str1 = Integer.toBinaryString(100);
System.out.println(str1);   // 1100100

// 2 把整数转换成八进制
String str2 = Integer.toOctalString(100);
System.out.println(str2);   // 144

// 3 把整数转换成十六进制
String str3 = Integer.toHexString(100);
System.out.println(str3);   // 64

2 包装类实现类型转换（重要！！！）

（1）Integer：public static int parseInt(String s)：将字符串类型的整数转换成int类型的整数

在python中这个功能 int()就能转，但在Java中必须这样才行

int i = Integer.parseInt("123");     // 字符串转整数  (自动拆箱)
System.out.println(i);      // 123
System.out.println(i + 1);  // 124
// 细节："123"里面必须是数字，里面有字母无法转，会报错

【注】：除了Character包装类，其他7中包装类都有其对应的paseXxx的方法进行类型转换
有了这个就可以将之前的键盘录入代码做一个规范了 包装类数据类型转换在键盘录入中的应用

（2）Boolean：public static boolean parseBoolean(String s)：将字符串类型的布尔转换成boolean

String str = "true";
boolean b = Boolean.parseBoolean(str);  // 字符串转布尔
System.out.println(b);  // true

二、数组 – int[]、String[]…

【注】：java的数组和Python的列表有很大的不同之处，下面的两个不同需要特别注意一下。

• （1）java的数组里面也可以是任意数据类型、如整数、浮点数、字符、字符串等或者对象（如类的实例），但需要注意的是，一个数组里面只能含有一种数据类型，也就是说java数组里面只能存在同一种数据类型，而Python的一个列表内却是可以同时含有多种不同数据类型，这是一个主要的小区别。
• （2）数组长度不可变：一旦数组创建并分配了空间，其长度不可改变。这点也是和Python不同，因此，如果需要动态增删元素，建议使用ArrayList等其他动态数组类。
• （3）java中数组这些没有切片操作这些。

1 数组的创建与初始化

（1）静态初始化

• 初始化就是在内存中为数组容器开辟空间，并将数据存入容器中的过程

• 注：数组一旦创建过后其长度就固定了，不可改变
  数组的长度直接访问数组的length属性即可：arr.length

其中语法有下面完整写法和简单写法两种

• 简单格式：数组类型[] 数组名 = {元素1，元素2，元素3…}
• 完整格式：数组类型[] 数组名 = new 数组类型[]{元素1，元素2，元素3…}

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

        int[] arr1 = new int[]{1,2,3};   // 这种是复杂的写法，一般使用下面的简单写法即可
        int[] arr2 = {1,2,3};

        String[] arr3 = new String[]{"a","b","c"};
        String[] arr4 = {"a","b","c"};
        System.out.println(arr2);  // [I@4eec7777
        System.out.println(arr4);  // [Ljava.lang.String;@3b07d329

    }
}

上面有个小细节，在java中直接打印数组打印的是数组的地址，下面对java中的地址格式做一个解释说明。
java地址格式说明：[I@4eec7777上面的这个地址，[ 表示是数组，I表示里面数据类型是整数 。@没有固定含义，就是一个固定格式，4eec7777这个才是真正的地址值。

（2）动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
语法： 数据类型[] 数组名 = new 数据类型[数组长度]

【注】：和静态相比，右边大括号没有了，中括号里面变数组长度了，要注意

int[] arr = new int[100]

数组默认的初始化规律：

• 整数类型：默认初始化为0
• 小数类型：默认初始化为0.0
• 字符类型：默认初始化为‘/u0000’ 其实就是空格
• 布尔类型：默认初始化为false
• 引用数据类型：默认初始化为 null

2 数组元素访问与修改

语法：

• 访问： 数组名[索引]
• 修改：数组名[索引] = 具体数据/变量

【注】：
1、java中的索引也是从0开始的
2、java中数组索引不能是负数，这和Python不一样

String[] arr4 = {"a","b","c"};
        String s = arr4[0];
        System.out.println(s);   // a

        arr4[1] = "哈哈";
        System.out.println(arr4[1]);     // 哈哈

3 数组的遍历

关于数组的变量java提供了一种增强的增强型 for 循环 (foreach)
基本语法：for (int i : arr)
以下面案例为例：定义一个数组[1,2,3,4,5],并用遍历数组求里面元素的和。

public class Business {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i:arr){
            sum += i;
        }
        System.out.println(sum);

    }
}

另外还有一种普通for循环结合数组长度来的就没有那么方便了

public class Business {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum);

    }
}

【注】：今后我们尽量使用增强型的和Python类似

4 数组的内存图（重要！！！！！！！）

由于数组前面已经有博客记录过了，这里直接给出衔接数组

5 二维数组

数组里面存数组就是二维数组了。

（1）静态初始化

• 语法格式： 数据类型[][] 数组名 = new 数据类型[][]{{元素1，元素2}，{元素1，元素2}}
• 简化格式：数据类型[][] 数组名 = {{元素1，元素2}，{元素1，元素2}}
• 范例：int[][] arr = new int[][]{{1,2},{3.4}} 或者 int[][] arr = {{1,2},{3.4}}
• 注意：二维数组数据类型指定了，所有数据类型都要是指定的数据类型，就算是内部的数组里面的元素也应该是最先规定的数据类型。

public class Business {
    public static void main(String[] args) {
        // int[][] arr = new int[][]{{1,2,3},{4,5,6,7,8}};
        int[][] arr = {{1,2,3},{4,5,6,7,8}};

        //数组访问
        System.out.println(arr[0][0]);  // 1

        // 二维数组的遍历，也可以使用增强for循环
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
        }

        System.out.println();
        // 二维数组的遍历，增强for循环
        for (int[] a : arr) {
            for (int i : a) {
                System.out.print(i+" ");
            }
        }
    }
}

（2）动态初始化

• 语法格式：数据类型[][] 数组名 = new 数据类型[m][n]
  其中，m,n理解成m行n列就可以了。所以没有静态初始化那么灵活可以内部数组长度不一样，不为二维数组不就是为了处理矩阵问题，够用就行。如果要动态初始化内部数组长度不同的怎么办，也有办法，由于并不常用，就放在下面的内存图中顺便作为介绍内存图的案例了。
• 范例： int[][] arr = new int[2][3];

public class Business {
    public static void main(String[] args) {
        // int[][] arr = new int[][]{{1,2,3},{4,5,6,7,8}};
        int[][] arr = new int[2][3];
        arr[0][0] = 100;

        // 遍历
        for (int[] row : arr){
            for (int data : row){
                System.out.print(data + " ");
            }
            System.out.println();
        }
    }
}
/* 输出：
100 0 0
0 0 0 
*/

（3）二维数组的内存图（重要重要重要！！！！！！！！！！！）

由于数组前面已经有博客记录过了，这里直接给出衔接数组

6 数组小练习

（1）求最值

public class Business {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int max = arr[0];     // 初始化最大值为数组第一个元素，一定要是数组中的元素，不能是0
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("Max: " + max);
    }
}

（2）按索引交换数组对应元素
在Python中交换两个变量的值直接 a,b = b,a即可，但是java不行，中间必须用一个中间变量过度。

int a = 10;
int b = 5;

int tem = a;
a = b;
b = tem;

System.out.println("a = " + a);  // 5
System.out.println("b = " + b);  // 10

知道上面那个，数组内部元素交换就按上面技巧来就是了。
其实还有一些其他花里胡哨的骚套路可以节省tem的内存消耗。

看下面这个题目：

思路：用双指针，while（i！= j）

public class Business {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};

        int i = 0;
        int j = arr.length - 1;
        while(i!=j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
        for(int k=0; k<arr.length; k++){
            System.out.println(arr[k]);
        }
    }
}

三、Arrays：操作数组的工具类（极其常用）

有没有发现数组里面没有什么方法吗？只有一个arr.length访问长度属性的属性访问手段。不要担心，这里就有这么一个操作数组的工具类，里面提供大量的静态方法操作数组，所以这个工具类用到的场景极其广泛。
下面同样给出常用的操作方法

1 public static String toString(数组)：把数组拼接成一个字符串

2 public static int binarySearch(数组)：

四、集合：ArryList — 数组列表

查阅帮助文档可以发现这个类在 java.util包下面

在之前创建数组我们采用的构造方式是 数组类型[] 数组名 = new 数组类型[]{元素1，元素2，元素3…}这种方式，这是独属于数组的构造方式。今后我们大多集合（还有些其他集合使用其他构造方式）都是使用 new + 泛型这种构造方式来创建集合对象。什么是泛型，打开ArryList的帮助文档：

上面这个<数据类型>括号就是泛型，用来指定集合里面的数据类型的。
了解了泛型就可以往下学习了

• ArryList基本数据类型不能进，必须是对应的包装类才行
• ArryList的长度是可以变的，理解成一个长度可变的动态数组
• ArryList提供了一个subList(int fromIndex, int toIndex)方法可以达到类似切片的效果 — 有兴趣可以查看API帮助文档（具体是浅复制还是深复制还得查阅资料），由于重点不在切片，所以这里就不详细说明，用到查资料即可。

1 ArryList对象的创建

• jdk7前的语法： Array<数据类型> 变量名 = new Array<数据类型> ()
• jdk7以后的语法： Array<数据类型> 变量名 = new Array<> ()

// ArrayList<String> ls = new ArrayList<String>();
ArrayList<String> ls = new ArrayList<>();
 ls.add("a");
 ls.add("b");
 System.out.println(ls);    // [a, b]

【注】：这个就和Python列表很像了

2 ArryList常见成员方法

【注】：其中E表示ArryList里面元素数据类型 ， e表示具体数据元素

（1）boolean add(E e) : 添加元素，返回值表示是否添加成功

（2）void add(int index, E e) ：在指定索引位置插入元素。

（3）boolean remove(E e) : 删除第一个指定元素 e，返回值表示是否删除成功

（4）E remove(int index) : 删除指定索引元素，返回被删除元素

（5）E set(int index, E e) : 修改指定索引下的元素，返回原来的元素

（6）E get(int index) : 获取指定索引处的元素

（7）int size() : 返回集合的长度

// ArrayList<String> ls = new ArrayList<String>();
ArrayList<String> ls = new ArrayList<>();
ls.add("aaa");
ls.add("bbb");
ls.add("ccc");
ls.add("aaa");
System.out.println(ls);    // [aaa, bbb, ccc, aaa]

ls.remove("aaa");    // 删除第一个aaa
System.out.println(ls);    // [bbb, ccc, aaa]

ls.remove(1);    // 删除索引为1的元素
System.out.println(ls);    // [bbb, aaa]

ls.set(1, "ddd");    // 修改索引为1的元素
System.out.println(ls);    // [bbb, ddd]

System.out.println(ls.get(1));    // ddd
System.out.println(ls.size());    // 2

（8）boolean isEmpty() ：判断数组列表是否为空。

这个判断为空有专门方法，没有Python那么方便。
【注】：java中的 逻辑运算符 ！ 和Python中的not有同样效果

ArrayList<String> list = new ArrayList<>();
list.add("Apple");  // 添加一个元素，使列表非空

// 判断是否非空
if (!list.isEmpty()) {
    System.out.println("List is not empty");
} else {
    System.out.println("List is empty");
}

3 ArryList的遍历

（1）使用get()方法遍历

（2）使用增强for循环遍历

ArrayList<String> list = new ArrayList<>();
list.add("Apple");  // 添加一个元素，使列表非空
list.add("Banana");
list.add("Orange");

// 使用get方法遍历列表
for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
}

System.out.println();

// 使用增强for循环遍历列表
for (String str : list) {
    System.out.print(str + " ");
}