博文主要是自己学习JAVA基础中的笔记，供自己以后复习使用，参考的主要教程是B站的
尚硅谷宋红康2023大数据教程
锲而舍之，朽木不折；锲而不舍，金石可镂。—荀子《荀子·劝学》

1. 数据结构剖析

数据结构，就是一种程序设计优化的方法论，研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，目的是加快程序的执行速度、减少内存占用的空间。

1.1 研究对象一：数据间逻辑关系

数据的逻辑结构指反映数据元素之间的逻辑关系，而与数据的存储无关，是独立于计算机的。

• 集合结构：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系。集合元素之间没有逻辑关系。
• 线性结构：数据结构中的元素存在一对一的相互关系。比如：排队。结构中必须存在唯一的首元素和唯一的尾元素。体现为：一维数组、链表、栈、队列
• 树形结构：数据结构中的元素存在一对多的相互关系。比如：家谱、文件系统、组织架构
• 图形结构：数据结构中的元素存在多对多的相互关系。比如：全国铁路网、地铁图

1.2 研究对象二：数据的存储结构（或物理结构）

数据的物理结构/存储结构：包括数据元素的表示和关系的表示。数据的存储结构是逻辑结构用计算机语言的实现，它依赖于计算机语言。
结构1：顺序结构

• 顺序结构就是使用一组连续的存储单元依次存储逻辑上相邻的各个元素。
• 优点： 只需要申请存放数据本身的内存空间即可，支持下标访问，也可以实现随机访问。
• 缺点： 必须静态分配连续空间，内存空间的利用率比较低。插入或删除可能需要移动大量元素，效率比较低
  
  结构2：链式结构
• 不使用连续的存储空间存放结构的元素，而是为每一个元素构造一个节点。节点中除了存放数据本身以外，还需要存放指向下一个节点的指针。
• 优点：不采用连续的存储空间导致内存空间利用率比较高，克服顺序存储结构中预知元素个数的缺点。插入或删除元素时，不需要移动大量的元素。
• 缺点：需要额外的空间来表达数据之间的逻辑关系，不支持下标访问和随机访问。
  
  结构3：索引结构
• 除建立存储节点信息外，还建立附加的索引表来记录每个元素节点的地址。索引表由若干索引项组成。索引项的一般形式是：（关键字，地址）。
• 优点：用节点的索引号来确定结点存储地址，检索速度快。
• 缺点： 增加了附加的索引表，会占用较多的存储空间。在增加和删除数据时要修改索引表，因而会花费较多的时间。
  结构4：散列结构
• 根据元素的关键字直接计算出该元素的存储地址，又称为Hash存储。
• 优点：检索、增加和删除结点的操作都很快。
• 缺点：不支持排序，一般比用线性表存储需要更多的空间，并且记录的关键字不能重复。

1.3 研究对象三：运算结构

施加在数据上的运算包括运算的定义和实现。运算的定义是针对逻辑结构的，指出运算的功能；运算的实现是针对存储结构的，指出运算的具体操作步骤。

• 分配资源，建立结构，释放资源
• 插入和删除
• 获取和遍历
• 修改和排序

1.4 小结

2. 一维数组

2.1 数组的特点

• 在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型。

//只声明了类型和长度
数据类型[]  数组名称 = new 数据类型[数组长度];
//声明了类型，初始化赋值，大小由元素个数决定
数据类型[] 数组名称 = {数组元素1，数组元素2，......}

• 物理结构特点：
  • 申请内存：一次申请一大段连续的空间，一旦申请到了，内存就固定了。
  • 不能动态扩展(初始化给大了，浪费；给小了，不够用)，插入快，删除和查找慢。
  • 存储特点：所有数据存储在这个连续的空间中，数组中的每一个元素都是一个具体的数据（或对象），所有数据都紧密排布，不能有间隔。
    

3. 链表

3.1 链表的特点

• 逻辑结构：线性结构
• 物理结构：不要求连续的存储空间
• 存储特点：链表由一系列结点node（链表中每一个元素称为结点）组成，结点可以在代码执行过程中动态创建。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
  
  常见的链表结构有如下的形式：
  
  

3.2 自定义链表

3.2.1 自定义单向链表

/*
单链表中的节点。
节点是单向链表中基本的单元。
每一个节点Node都有两个属性：一个属性：是存储的数据。另一个属性：是下一个节点的内存地址。*/
public class Node {// 存储的数据Object data;// 下一个节点的内存地址Node next;public Node(){}public Node(Object data, Node next){this.data = data;this.next = next;}
}

/*
链表类(单向链表)*/
public class Link<E> {// 头节点Node header;private int size = 0;public int size(){return size;}// 向链表中添加元素的方法（向末尾添加）public void add(E data){//public void add(Object data){// 创建一个新的节点对象// 让之前单链表的末尾节点next指向新节点对象。// 有可能这个元素是第一个，也可能是第二个，也可能是第三个。if(header == null){// 说明还没有节点。// new一个新的节点对象，作为头节点对象。// 这个时候的头节点既是一个头节点，又是一个末尾节点。header = new Node(data, null);}else {// 说明头不是空！// 头节点已经存在了！// 找出当前末尾节点，让当前末尾节点的next是新节点。Node currentLastNode = findLast(header);currentLastNode.next = new Node(data, null);}size++;}/*** 专门查找末尾节点的方法。*/private Node findLast(Node node) {if(node.next == null) {// 如果一个节点的next是null// 说明这个节点就是末尾节点。return node;}// 程序能够到这里说明：node不是末尾节点。return findLast(node.next); // 递归算法！}/*// 删除链表中某个数据的方法public void remove(Object obj){//略}// 修改链表中某个数据的方法public void modify(Object newObj){//略}// 查找链表中某个元素的方法。public int find(Object obj){//略}*/
}

3.2.2 自定义双向链表

/*
双向链表中的节点。*/
public class Node<E> {Node prev;E data;Node next;Node(Node prev, E data, Node next) {this.prev = prev;this.data = data;this.next = next;}
}

4. 栈

4.1 栈的特点

• 栈（Stack）又称为堆栈或堆叠，是限制仅在表的一端进行插入和删除运算的线性表。
• 栈按照先进后出(FILO,first in last out)的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶。每次删除（退栈）的总是删除当前栈中最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。
• 核心类库中的栈结构有Stack和LinkedList。
  • Stack就是顺序栈，它是Vector的子类。
  • LinkedList是链式栈。
• 体现栈结构的操作方法：
  • peek()方法：查看栈顶元素，不弹出
  • pop()方法：弹出栈
  • push(E e)方法：压入栈
• 时间复杂度:
  • 索引: O(n)
  • 搜索: O(n)
  • 插入: O(1)
  • 移除: O(1)

5. 队列

• 队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表。
• 队列是逻辑结构，其物理结构可以是数组，也可以是链表。
• 队列的修改原则：队列的修改是依先进先出（FIFO）的原则进行的。新来的成员总是加入队尾（即不允许"加塞"），每次离开的成员总是队列头上的（不允许中途离队），即当前"最老的"成员离队。
• 图示：
  
  

6. 树与二叉树

6.1 树的理解

专有名词解释：*

结点：树中的数据元素都称之为结点
根节点：最上面的结点称之为根，一颗树只有一个根且由根发展而来，从另外一个角度来说，每个结点都可以认为是其子树的根
父节点：结点的上层结点，如图中，结点K的父节点是E、结点L的父节点是G
子节点：节点的下层结点，如图中，节点E的子节点是K节点、节点G的子节点是L节点
兄弟节点：具有相同父节点的结点称为兄弟节点，图中F、G、H互为兄弟节点
结点的度数：每个结点所拥有的子树的个数称之为结点的度，如结点B的度为3
树叶：度数为0的结点，也叫作终端结点，图中D、K、F、L、H、I、J都是树叶
非终端节点（或分支节点）：树叶以外的节点，或度数不为0的节点。图中根、A、B、C、E、G都是
树的深度（或高度）：树中结点的最大层次数，图中树的深度为4
结点的层数：从根节点到树中某结点所经路径上的分支树称为该结点的层数，根节点的层数规定为1，其余结点的层数等于其父亲结点的层数+1
同代：在同一棵树中具有相同层数的节点

6.2 二叉树的基本概念

二叉树（Binary tree）是树形结构的一个重要类型。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。许多实际问题抽象出来的数据结构往往是二叉树形式，二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。

6.3 二叉树的遍历

• 前序遍历：中左右（根左右）

  即先访问根结点，再前序遍历左子树，最后再前序遍历右子 树。前序遍历运算访问二叉树各结点是以根、左、右的顺序进行访问的。

• 中序遍历：左中右（左根右）

  即先中前序遍历左子树，然后再访问根结点，最后再中序遍 历右子树。中序遍历运算访问二叉树各结点是以左、根、右的顺序进行访问的。

• 后序遍历：左右中（左右根）

  即先后序遍历左子树，然后再后序遍历右子树，最后访问根 结点。后序遍历运算访问二叉树各结点是以左、右、根的顺序进行访问的。
  

6.4 经典二叉树

1、满二叉树： 除最后一层无任何子节点外，每一层上的所有结点都有两个子结点的二叉树。 第n层的结点数是2的n-1次方，总的结点个数是2的n次方-1
2、完全二叉树： 叶结点只能出现在最底层的两层，且最底层叶结点均处于次底层叶结点的左侧。
3、二叉排序/查找/搜索树：即为BST (binary search/sort tree)。满足如下性质：
（1）若它的左子树不为空，则左子树上所有结点的值均小于它的根节点的值；
（2）若它的右子树上所有结点的值均大于它的根节点的值；
（3）它的左、右子树也分别为二叉排序/查找/搜索树。
对二叉查找树进行中序遍历，得到有序集合。便于检索。
4、平衡二叉树：（Self-balancing binary search tree，AVL）首先是二叉排序树，此外具有以下性质：
（1）它是一棵空树或它的左右两个子树的高度差的绝对值不超过1
（2）并且左右两个子树也都是一棵平衡二叉树
（3）不要求非叶节点都有两个子结点

平衡二叉树的目的是为了减少二叉查找树的层次，提高查找速度。平衡二叉树的常用实现有红黑树、AVL、替罪羊树、Treap、伸展树等。
6、红黑树：即Red-Black Tree。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。

红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，它是在 1972 年由 Rudolf Bayer 发明的。红黑树是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在 O(log n)时间内做查找，插入和删除， 这里的 n 是树中元素的数目。

红黑树的特性：

• 每个节点是红色或者黑色
• 根节点是黑色
• 每个叶子节点（NIL）是黑色。（注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点）
• 每个红色节点的两个子节点都是黑色的。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
• 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点（确保没有一条路径会比其他路径长出2倍）
  
  当我们插入或删除节点时，可能会破坏已有的红黑树，使得它不满足以上5个要求，那么此时就需要进行处理，使得它继续满足以上的5个要求：
  1、recolor ：将某个节点变红或变黑
  2、rotation ：将红黑树某些结点分支进行旋转（左旋或右旋）
  

红黑树可以通过红色节点和黑色节点尽可能的保证二叉树的平衡。主要是用它来存储有序的数据，它的时间复杂度是O(logN)，效率非常之高。

6.5 二叉树及其结点的表示

普通二叉树：

public class BinaryTree<E>{private TreeNode root; //二叉树的根结点private int total;//结点总个数private class TreeNode{//至少有以下几个部分TreeNode parent;TreeNode left;E data;TreeNode right;public TreeNode(TreeNode parent, TreeNode left, E data, TreeNode right) {this.parent = parent;this.left = left;this.data = data;this.right = right;}}
}

TreeMap红黑树：

public class TreeMap<K,V> {private transient Entry<K,V> root;private transient int size = 0;static final class Entry<K,V> implements Map.Entry<K,V> {K key;V value;Entry<K,V> left;Entry<K,V> right;Entry<K,V> parent;boolean color = BLACK;/*** Make a new cell with given key, value, and parent, and with* {@code null} child links, and BLACK color.*/Entry(K key, V value, Entry<K,V> parent) {this.key = key;this.value = value;this.parent = parent;}}
}

7. List接口分析

7.1 List接口特点

• List集合所有的元素是以一种线性方式进行存储的，例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
• 它是一个元素存取有序的集合。即元素的存入顺序和取出顺序有保证。
• 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
• 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

注意：
List集合关心元素是否有序，而不关心是否重复，请大家记住这个原则。例如“张三”可以领取两个号。

List接口的主要实现类

• ArrayList：动态数组
• Vector：动态数组
• LinkedList：双向链表
• Stack：栈
  JDK1.7.0_07中：

//属性
private transient Object[] elementData; //存储底层数组元素
private int size; //记录数组中存储的元素的个数//构造器
public ArrayList() {this(10); //指定初始容量为10
}public ArrayList(int initialCapacity) {super();//检查初始容量的合法性if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);//数组初始化为长度为initialCapacity的数组this.elementData = new Object[initialCapacity]; 
}//方法：add()相关方法
public boolean add(E e) {ensureCapacityInternal(size + 1);  //查看当前数组是否够多存一个元素elementData[size++] = e; //将元素e添加到elementData数组中return true;
}private void ensureCapacityInternal(int minCapacity) {modCount++;// 如果if条件满足，则进行数组的扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length; //当前数组容量int newCapacity = oldCapacity + (oldCapacity >> 1); //新数组容量是旧数组容量的1.5倍if (newCapacity - minCapacity < 0)  //判断旧数组的1.5倍是否够newCapacity = minCapacity;//判断旧数组的1.5倍是否超过最大数组限制if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//复制一个新数组elementData = Arrays.copyOf(elementData, newCapacity);
}//方法：remove()相关方法
public E remove(int index) {rangeCheck(index); //判断index是否在有效的范围内modCount++; //修改次数加1//取出[index]位置的元素，[index]位置的元素就是要被删除的元素，用于最后返回被删除的元素E oldValue = elementData(index); int numMoved = size - index - 1; //确定要移动的次数//如果需要移动元素，就用System.arraycopy移动元素if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index, numMoved);//将elementData[size-1]位置置空，让GC回收空间，元素个数减少elementData[--size] = null; return oldValue;
}private void rangeCheck(int index) {if (index >= size) //index不合法的情况throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}E elementData(int index) { //返回指定位置的元素return (E) elementData[index];
}//方法：set()方法相关
public E set(int index, E element) {rangeCheck(index); //检验index是否合法//取出[index]位置的元素，[index]位置的元素就是要被替换的元素，用于最后返回被替换的元素E oldValue = elementData(index);//用element替换[index]位置的元素elementData[index] = element;return oldValue;
}//方法：get()相关方法
public E get(int index) {rangeCheck(index); //检验index是否合法return elementData(index); //返回[index]位置的元素
}//方法：indexOf()
public int indexOf(Object o) {//分为o是否为空两种情况if (o == null) {//从前往后找for (int i = 0; i < size; i++)if (elementData[i]==null)return i;} else {for (int i = 0; i < size; i++)if (o.equals(elementData[i]))return i;}return -1;
}//方法：lastIndexOf()
public int lastIndexOf(Object o) {//分为o是否为空两种情况if (o == null) {//从后往前找for (int i = size-1; i >= 0; i--)if (elementData[i]==null)return i;} else {for (int i = size-1; i >= 0; i--)if (o.equals(elementData[i]))return i;}return -1;
}                                        

jdk1.8.0_271中：

//属性
transient Object[] elementData;
private int size;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//构造器
public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  //初始化为空数组
}//方法:add()相关方法
public boolean add(E e) {//查看当前数组是否够多存一个元素ensureCapacityInternal(size + 1);  // Increments modCount!!//存入新元素到[size]位置，然后size自增1elementData[size++] = e;return true;
}private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}private static int calculateCapacity(Object[] elementData, int minCapacity) {//如果当前数组还是空数组if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//那么minCapacity取DEFAULT_CAPACITY与minCapacity的最大值return Math.max(DEFAULT_CAPACITY, minCapacity);}return minCapacity;
}//查看是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {modCount++;  //修改次数加1//如果需要的最小容量比当前数组的长度大，即当前数组不够存，就扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length; //当前数组容量int newCapacity = oldCapacity + (oldCapacity >> 1); //新数组容量是旧数组容量的1.5倍//看旧数组的1.5倍是否够if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//看旧数组的1.5倍是否超过最大数组限制if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//复制一个新数组elementData = Arrays.copyOf(elementData, newCapacity);
}