java数据结构（集合）

最新推荐文章于 2024-09-08 14:39:05 发布
最新推荐文章于 2024-09-08 14:39:05 发布
阅读量673 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： java 算法 数据结构 链表 排序算法
原文链接：https://blog.csdn.net/fox_bert/article/details/90272656
版权

一、集合介绍

Collection(单列集合)

List(有序,可重复)

ArrayList
底层数据结构是数组,查询快,增删慢（因为：增删后涉及到其他数据的位移）
线程不安全,效率高
Vector
底层数据结构是数组,查询快,增删慢（因为：增删后涉及到其他数据的位移）
线程安全,效率低
LinkedList
底层数据结构是双向链表,查询慢,增删快
线程不安全,效率高


Set(无序,唯一)

HashSet
底层数据结构是哈希表。
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可

LinkedHashSet
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
TreeSet
底层数据结构是红黑树。(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象


Map(双列集合)

A:Map集合的数据结构仅仅针对键有效，与值无关。
B:存储的是键值对形式的元素，键唯一，值可重复。

HashMap

底层数据结构是:

jdk1.8以下：（数组+单向链表）哈希表

  jdk1.8+：（数组+[单向链表 / 红黑树]）哈希表，根据情况会选择链表和红黑树之间进行转换

线程不安全，效率高
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。

Hashtable

底层数据结构是哈希表。线程安全，效率低
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可

TreeMap

底层数据结构是红黑树。(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象

二、常见数据结构

1、数组结构

数组结构我想不必多说了

数组是最最基本的数据结构，很多语言都内置支持数组。数组是使用一块连续的内存空间保存数据，保存的数据的个数在分配内存的时候就是确定的

深入了解Java数据结构（集合及底层实现）1

2、链表结构

单向链表 

深入了解Java数据结构（集合及底层实现）2

双向链表

 

深入了解Java数据结构（集合及底层实现）3

3、二叉树结构

深入了解Java数据结构（集合及底层实现）4

4、散列表结构（哈希表）

 

深入了解Java数据结构（集合及底层实现）5

三、关于集合选取原则

    是否是键值对象形式:
是：Map
键是否需要排序:
是：TreeMap
否：HashMap
不知道，就使用HashMap。

否：Collection
元素是否唯一:
是：Set
元素是否需要排序:
是：TreeSet
否：HashSet
不知道，就使用HashSet

否：List
要安全吗:
是：Vector
否：ArrayList或者LinkedList
增删多：LinkedList
查询多：ArrayList
不知道，就使用ArrayList
不知道，就使用ArrayList


四、集合的常见方法及遍历方式

Collection:
add()
remove()
contains()
iterator()
size()

遍历：
增强for
迭代器

|--List
get()

遍历：
普通for
|--Set

Map:
put()
remove()
containskey(),containsValue()
keySet()
get()
value()
entrySet()
size()

遍历：
根据键找值
根据键值对对象分别找键和值

五、HashMap底层实现原理（jdk1.7\jdk1.8+）

面试常问特点：

1、底层结构

  • jdk1.8以下：HashMap的底层是：数组+链表(单向链表)
  • jdk1.8+：HashMap的底层是：数组+[链表(单向链表) / 红黑树 ]

2、线程不安全（put方法没有加锁） 

3、初始化默认大小：16 【1 << 4】

4、扩容 

扩容触发机制：

  • 当前存储过的键值对的数量【即HashMap中的一个size属性】必须大于等于阈值（threshold）【注意：阈值=数组length*加载因子】；
  • 当前加入的数据是否发生hash冲突

加载因子：0.75 当元素存储（使用）到达现有数组的75%的时候进行扩容（例如：下标100的数组，任意75个下标存储后就会扩容）

扩大容量：每次在原基础乘以2，扩容后为原来的2倍

 /** * The default initial capacity - MUST be a power of two. */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 /** * The load factor used when none specified in constructor. */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * The next size value at which to resize (capacity * load factor). * @serial */ // If table == EMPTY_TABLE then this is the initial capacity at which the // table will be created when inflated. int threshold; /** * Constructs an empty HashMap with the default initial capacity * (16) and the default load factor (0.75). */ public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); }

准确点来说是 Entry[]数组 （根据Entry的内部结构不同，来断定具体是什么数据结构）

  • 数组的特点是：寻址容易，插入和删除困难（因为添加删除会涉及到其他元素的位移）；
  • 链表的特点是：寻址困难，插入和删除容易（因为寻址需要一个一个的遍历过去，无法直接定位）；

那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”
 

问：数组我们都知道，但什么是Entry数组呢？

答：就是一个数组里放的都是Entry

问：那这里的Entry又是什么呢？

答：

注意：每个集合类里面的存放实现都有可能是不一样的（比如 TreeSet 里面也有 Entry，但是和 HashMap 的 Entry 内部结构实现是不同的）

HashMap 的 Entry 就是我们说的链表结构 (单向链表)

下图中我们可以看到，在HashMap里面有个静态类 Entry 也是 key value 形式的；

里面有 next 属性，类型也是Entry

这就是一个 Entry 里面嵌套了另一个 Entry（典型的链表结构）

注意：我们可以看到这个 Entry类里面只有一个 Entry next 属性，只有下一个，所以这是一个 单向链表

HashMap 结构 ，里面有个Entry（这是用来存放数据的）

深入了解Java数据结构（集合及底层实现）6

内部类 Entry 结构 

深入了解Java数据结构（集合及底层实现）7

下面是HashMap的结构图，结合上面的代码就很好理解了吧

深入了解Java数据结构（集合及底层实现）8

深入了解Java数据结构（集合及底层实现）9

1、HashMap中有一个table的全局属性属性，该属性是Enrty数组

数据都在这里面存放

深入了解Java数据结构（集合及底层实现）10

深入了解Java数据结构（集合及底层实现）11

首先执行初始化 ：初始化会加载一些配置信息

初始化完成，如果在调用put方法时，发现table里面没有任何数据，那么会调用 inflateTable(int toSize)

深入了解Java数据结构（集合及底层实现）12

深入了解Java数据结构（集合及底层实现）13

2、【重点】HashMap 是如何添加数据的（我们主要看红色标注区域）

深入了解Java数据结构（集合及底层实现）14

（1）首先拿到我们的 key 算出对应的 HashCode【line：492】

（2）根据 key 和 table.length 调用 indexFor() 来计算出一个数值 i，这个数值是 table 数组的下标【line：493】

（3）重点来了，我们需要比较这个 key 是否已经存在，如果存在则给对应的 value 重新赋值【line：494~502】

  1. 根据计算出来的下标 i 拿到该 table数组 在该下标内的 Entry
  2. 判断 entry 是不是 null ，如果不是则表示该值已存在，拿到值（for遍历过程）
  3. 判断数组中存在的 entry 的 hash 和我们计算出的 hash 是否一致、 key 是否一致
  4. 如果一致，则说明 HashMap 中该 key 已经存在，我们进入 if() 内进行赋值操作，并返回旧的值

（4）如果该数组下标内没有找到对应的 key，我们则调用 addEntry() 方法进行添加【line：505】

addEntry()方法如下：

  1. 先进行扩容机制的判断【line：878~882】
  2. 调用createEntry()方法进行添加键值对
  3. 进行链表的添加（将旧节点加入新节点的 next 中）
  4. 添加完成后为全局变量size++（扩容时会用size进行判断）

大概看一下我们就可以理解，有兴趣的同学可以看一下 （红色区域为添加，蓝色区域后面会讲到）

链表的添加方式：每次都是在最外层创建一个新的链表点，然后把旧的链表插入新的点，所以最外层的（顶层的）永远是最新的

深入了解Java数据结构（集合及底层实现）15

（5）get(key)方法如何实现的呢？

如果你认真的跟着我上面的步骤理解了 put(key,value)方法，我想不用看源码也能大概说出来是如何实现的

  1. 我们根据 key 算出 hashCode
  2. 用这个 HashCode 再算出，数组中的一个下标
  3. 如果这个下标是null 那么我们返回null
  4. 如果不是，那我们就遍历对比链表里面的每一个Entry，找到就返回，找不到就返回null

亮点，我们也附带学习了遍历链表的方法 

3、【重点】扩容机制源码 

扩容必须同时满足两个条件：

  1.  存放新值的时候，发现当前已有键值对（key-value）元素的个数（size）必须大于等于阈值（阈值=加载因子*当前数组长度）
  2.  存放新值的时候，当前新值数据key发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值）

在put()方法中有调用addEntry()方法，这个方法里面是具体的存值，在存值之前还有判断是否需要扩容

判断扩容条件：(size >= threshold) && (null != table[bucketIndex])【line：878】

如果下面两个条件都发生，那么就扩容

  1. 判断当前个数是否大于等于阈值(size >= threshold)
  2. 当前存放是否发生哈希碰撞(null != table[bucketIndex])

扩容调用方法：resize(int) 【line：879】

扩容大小为原先数组大小的两倍 

深入了解Java数据结构（集合及底层实现）16

阈值：threshold  

threshold 就是所说的阈值，它是一个全局变量，决定了数组是否进行扩容的判断条件之一【上图中 line：878】 

阈值根据加载因子和数组大小决定的 

默认情况下： 阈值=加载因子 * 当前数组大小

深入了解Java数据结构（集合及底层实现）17

深入了解Java数据结构（集合及底层实现）18

HashMap的构造函数有4个：

下图中的3个构造函数可以看到都是调用了同一个构造函数 public HashMap (int initialCapacity, float loadFactor)

代码中选中的是加载因子 

深入了解Java数据结构（集合及底层实现）19

public HashMap (int initialCapacity, float loadFactor)

深入了解Java数据结构（集合及底层实现）20

如果需要扩容，调用扩容的方法：resize(int)

深入了解Java数据结构（集合及底层实现）21

总结：

HashMap的扩容需要同时满足两个条件：

  1.  存放新值的时候，发现当前已有键值对（key-value）元素的个数（size）必须大于等于阈值（阈值=加载因子*当前数组长度）
  2.  存放新值的时候，当前新值数据key发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值）

因为上面这两个条件，所以存在下面这些情况

  1. 就是hashmap在存值的时候（默认大小为16，负载因子0.75，阈值12），可能达到最后存满16个值的时候，再存入第17个值才会发生扩容现象，因为前16个值，每个值在底层数组中分别占据一个位置，并没有发生hash碰撞。【key不触发hash碰撞】
  2. 当然也有可能存储更多值（超多16个值，最多可以存26个值）都还没有扩容。原理：前11个值全部hash碰撞，存到数组的同一个位置（这时元素个数小于阈值12，不会扩容），后面所有存入的15个值全部分散到数组剩下的15个位置（这时元素个数大于等于阈值，但是每次存入的元素并没有发生hash碰撞，所以不会扩容），前面11+15=26，所以在存入第27个值的时候才同时满足上面两个条件，这时候才会发生扩容现象。

HashMap（jdk1.8+）的变化

变化如下：

  1. 数据存储结构进行改变
  2. 对数组下标的定位生成，做了改动，使之更具有分散性（减少经常向同一个下标存储的情况）
  3. 加入了链表和红黑树相互转变的机制（减少链的深度）

深入了解Java数据结构（集合及底层实现）22

1、存储key value的内部存储类 Entry 变为 Node 或 TreeNode

transient Node[] table;
static class Node implements Map.Entry { final int hash; final K key; V value; Node next; Node(int hash, K key, V value, Node next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry e = (Map.Entry)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }

 TreeNode

 /** * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn * extends Node) so can be used as extension of either regular or * linked node. */ static final class TreeNode extends LinkedHashMap.Entry { TreeNode parent;  // red-black tree links TreeNode left; TreeNode right; TreeNode prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node next) { super(hash, key, val, next); } ...... }

2、put方法的改变（加入了红黑树的转变机制）

使用树型结构，而不去使用单向链表

当节点超过8时，从链表转变为红黑树结构，从而减小链的深度 

当节点小于6时，从红黑树转变为链表结构

 /** * The bin count threshold for using a tree rather than list for a * bin.  Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal about conversion back to plain bins upon * shrinkage. */ static final int TREEIFY_THRESHOLD = 8; /** * The bin count threshold for untreeifying a (split) bin during a * resize operation. Should be less than TREEIFY_THRESHOLD, and at * most 6 to mesh with shrinkage detection under removal. */ static final int UNTREEIFY_THRESHOLD = 6;

put方法的改变

深入了解Java数据结构（集合及底层实现）23

（1）根据情况判断是否进行初始化【line：628~629】

（2）计算出数组的下标，取出数据存入变量p，判断是否为null，如果为null则直接生成新节点存入，跳至661【line：630~631】

（3）如果该下标中存在数据则进入else【line：632~660】

（1、下标中先取链表的 顶层 Node节点，判断key是否相同。相同则直接进入line：653进行数据替换【line：634~636】

（2、判断该下标Node节点类型是否为TreeNode（树结构），如果是则使用内部类TreeNode的putTreeVal进行存储【line：637~638】

（3、如果传入的key不是 顶层 Node节点，数组下标节点也不是TreeNode（树结构），那么就对该下标下的Node节点进行循环遍历【line：639~652】

（4、对value值进行替换处理

LinkedHashMap 底层实现原理

 LinkedHashMap 继承了 HashMap 所以很多方法都是继承来的，但是 LinkedHashMap 又是有序的，我们可以看到构造器中有个 accessOrder 参数，这个就是来控制有序的。

深入了解Java数据结构（集合及底层实现）24

六、HashTable底层实现原理

面试常问特点：

1、底层结构

jdk1.8以下：HashMap的底层是：数组+链表(单向链表)

jdk1.8+：HashMap的底层是：数组+[链表(单向链表) / 红黑树 ]

2、线程安全（put方法加了synchronized修饰） 

3、初始化默认大小：11 

4、扩容 

扩容触发机制：数据大小【size()】大于等于阈值【count >= threshold】

加载因子：0.75

扩大容量：每次原大小乘以2再加1【(old.length << 1)+1】

 /** * Constructs a new, empty hashtable with a default initial capacity (11) * and load factor (0.75). */ public Hashtable() { this(11, 0.75f); }

关于2n+1的扩展，在hashtable选择用取模的方式来进行，那么尽量使用素数、奇数会让结果更加均匀一些，具体证明，可以看看已经证明这点的技术文章
关于hash，hashmap用2的幂，主要是其还有一个hash过程即二次hash，不是直接用key的hashcode，这个过程打散了数据
总体就是一个减少hash冲突，并且找索引效率还要高，实现都是要考量这两因素的 

1、添加方法和HashMap几乎是一样的 

深入了解Java数据结构（集合及底层实现）25

（1）用 key 算出对应的 HashCode【line：465】

（2）根据 HashCode和 table.length 计算出 table 数组的下标【line：466】

（3）循环遍历table下标中的entry链表，比较这个 key 是否已经存在，如果存在则给对应的 value 重新赋值【line：468~475】

（4）如果该数组下标内没有对应的key，我们则调用 addEntry() 方法进行添加【line：477】

深入了解Java数据结构（集合及底层实现）26

2、扩容方法 rehash()

深入了解Java数据结构（集合及底层实现）27

七、TreeMap 底层实现原理

1、了解结构 

TreeMap 有一个 Entry root 属性 （用来存放数据的）

Entry 类型又有三个 Entry 类型的 left、right、parent 属性,和自己的 key、value属性；（用来存放 树结构 左、右、父的对象数据，还有自己的值；color 属性是当前树节点的颜色）

由此可见 Entry 类型是个 红黑树 的结构，而 TreeMap 里面存储的是 Entry 结果自然就是红黑树

 

深入了解Java数据结构（集合及底层实现）28

深入了解Java数据结构（集合及底层实现）29

2、内部类 Entry 结构

深入了解Java数据结构（集合及底层实现）30

八、ArrayList 底层实现原理

面试常问特点：

1、底层结构：数组 

2、线程不安全（add方法没有加锁）  

3、初始化默认大小：10 

4、扩容

扩容触发机制：当存储第11个数据时，11超过了默认的10，就会触发扩容

扩大容量：每次在原基础上增加0.5倍，扩容后为原来的1.5倍

 /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { super(); this.elementData = EMPTY_ELEMENTDATA; }

扩容机制源码

ensureCapacityInternal() 方法

（1）在调用Add方法时，会先通过 ensureCapacityInternal() 方法确保当前ArrayList维护的数组具有存储新元素的能力【Line:440】

（2）ensureCapacityInternal() 判断ArrayList默认的元素存储数据是否为空，为空则设置最小要求的存储能力为必要存储的元素和默认存储元素个数的两个数据之间的最大值，然后调用ensureExplicitCapacity方法实现这种最低要求的存储能力【Line:208】

（3）如果最低要求的存储能力 > ArrayList 已有的存储能力，这就表示ArrayList的存储能力不足，因此需要调用 grow();方法进行扩容 【Line:215】

深入了解Java数据结构（集合及底层实现）31

 

深入了解Java数据结构（集合及底层实现）32

扩容方法源码（扩容后为原来的1.5倍）

grow()方法 

（1）数字转换为二进制，使用向右位移符 >> 移动所有二进制数，实现除法（源码中 oldCapacity >> 1表示所有二进制向右移动1位，表示除以2，移出去的数直接忽略）

（2）新size = 旧的size + 扩大的size（Line：236）

（3）创建一个新的数组

（4）通过Arrays.copyOf方法，将原数组的数据复制到新数组

深入了解Java数据结构（集合及底层实现）33

总结：

举例说明：添加20个元素到ArrayList中 

当第一次插入元素时才分配10（默认）个对象空间。之后扩容会按照1.5倍增长。

也就是当添加第11个数据的时候，Arraylist继续扩容变为10*1.5=15；

当添加第16个数据时，继续扩容变为15 * 1.5 =22个；

九、Vector 底层实现原理

面试常问特点：

1、底层结构：数组 

2、线程安全（add方法添加synchronized锁） 

3、初始化默认大小：10 

扩容触发机制：当存储第N+1个数据时，N+1超过了先前的数组最大个数N，就会触发扩容

扩大容量：每次在原基础上增加1倍，也就是总大小为原来的2倍

 /** * Constructs an empty vector so that its internal data array * has size {@code 10} and its standard capacity increment is * zero. */ public Vector() { this(10); }

扩容机制源码

ensureCapacityHelper() 方法 

基本上ArrayList一样

深入了解Java数据结构（集合及底层实现）34

深入了解Java数据结构（集合及底层实现）35

扩容方法源码（扩容后为原来的2倍）

grow()方法 

（1）(capacityIncrement > 0) ? capacityIncrement : oldCapacity（大多情况会返回 oldCapacity）

（2）新size = 旧的size + 旧的size（Line：256）

（3）创建一个新的数组

（4）通过Arrays.copyOf方法，将原数组的数据复制到新数组

深入了解Java数据结构（集合及底层实现）36

总结：

举例说明：添加40个元素到 Vector 中 

当第一次插入元素时才分配10（默认）个对象空间。之后扩容会按照2倍增长。

也就是当添加第11个数据的时候，Vector 继续扩容变为10*2=20；

当添加第21个数据时，继续扩容变为20 * 2 =40个；

十、LinkedList 底层实现原理

1、了解结构。我们进入类中，看到它的变量

LinkedList 有两个 Node 类型的 first、last属性，和自己的size；（用来存放第一个和最后一个，还有总大小的值）

Node 类型又有两个 Node 类型的 next、prev属性,和自己的 item 属性；（用来存放 前一个和后一个对象数据，还有自己的值）

由此可见 Node 类型是个 双向链表 的结构，而 LinkedList 里面存储的是 Node 结果自然就是 双向链表

深入了解Java数据结构（集合及底层实现）37

深入了解Java数据结构（集合及底层实现）38

2、内部类 Node 结构

深入了解Java数据结构（集合及底层实现）39

nothing in the world
关注
专栏目录
数据结构与JAVA集合
ll_0104的博客
04-08 921
在这里插入图片描述 数据结构 1.数据结构有什么用？ 当你用java里面的容器类很爽的时候，你有没有想过是如何实现的呢？ 现实世界的存储我们使用的是工具和建模。每种数据结构都有自己的优点和缺点想想如果google的数据用的是数组进行存储，我们还能方便的查询所有的数据吗？而算法，在这么多的数据中如何做到快速的插入、查找、删除也是在追求更快。 我们的java语言是面向对象的语言，就像是自动挡轿车，C语言面向过程的编程语言类似于手动挡。数据结构就是变速箱 2.常见数据结构 栈、队列、
Java集合与数据结构
carolineme的博客
03-14 276
1、数组 说明：数组一旦初始化，其长度就是确定的。arr.length；数组长度一旦确定，就不可修改。 默认初始化值： 弊端： 一旦初始化以后，其长度就不可修改； 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高； 获取数组中实际元素的需求，数组没有现成的属性或方法可用； 数组存储数据的特点有序、可重复，对于无序、不可重复的需求不能满足。 2 、集合 集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 集合优点：解决数组存储方面的弊端.
JAVA (集合和数据结构)
weixin_33757609的博客
09-08 170
Collection和Collections的区别: 1、java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。声明了适用于JAVA集合（只包括Set和List）的通用方法。Set 和List 都继承了Conll...
Java中有哪些用于数据存储的常用数据结构?他们分别都有哪些特点？
最新发布
2301_80140904的博客
09-08 983
在java中，有多种常用的数据结构用于储存，比较常用的有: 数组（Array)、列表(List)、集合(Set)、映射（Map）、队列(Queue)、栈（Stack)、链表（Linked List）、图（Graph）、树（Tree）等。
Java 集合与数据结构
编程开发相关技术学习
11-24 1209
Java集合与数据结构
10.JAVA中的集合（数据结构）
改变从现在开始
08-01 330
数据结构之Java中的集合，包括各个容器的特性与对比，集合工具类；（内含代码练习）
数据结构和算法：用Java实现的抽象数据结构的集合
02-05
这是用Java实现的抽象数据结构和算法的集合。 该代码经过了很好的注释，可以轻松理解。 每个数据结构都经过良好测试。 您可以通过与我联系。 数据结构 ： 此仓库包含以下数据结构： 排序算法 图上的算法 图表示 ...
Java 数据结构
01-03
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 枚举（Enumeration） 位集合（BitSet） 向量（Vector） 栈（Stack） 字典（Dictionary） 哈希表（Hashtable） 属性...
java数据结构知识点集合.doc
06-28
本文将详细介绍 Java 中的传统数据结构接口和类，包括枚举（Enumeration）、位集合（BitSet）、向量（Vector）、栈（Stack）、字典（Dictionary）、哈希表（Hashtable）以及属性（Properties）。此外，还将简要介绍 ...
Java 集合与数据结构详解1
08-03
本文将深入探讨Java集合框架的核心概念、数据结构以及相关的算法。 首先，集合框架主要由两个核心部分组成：集合（Collection）和图（Map）。集合是用来存储单一元素的容器，而图则用于存储键值对映射关系。在...
java 集合泛型+数据结构
08-07
java 集合泛型+数据结构
java 集合数据结构_java集合：常用集合的数据结构
weixin_29458017的博客
02-13 210
List有序可重复ArrayListArrayList数据结构是数组。查询快，增删慢。ArrayList是线程不安全的，允许元素为null 。Vector线程安全的数组，效率较差，已经过时不用。LinkedListLinkedList 数据结构是双向链表，插入删除比较方便。LinkedList 是线程不安全的，允许元素为null 。MapHashMap :jdk1.8中HashMap底层是哈希表数...
Java集合中的基本数据结构
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
06-02 392
1、集合中三大数据结构 1.1 数组 内存地址连续 可以通过下标的成员访问，下标访问的性能高 增删操作有较大的性能消耗（需要动态扩容） 1.2 链表（双向链表） 灵活的空间要求，存储空间不要求连续 不支持下标访问，支持顺序遍历搜索 针对增删操作找到对应的节点改变链表的头尾指针指向即可，无需移动元数据存储位置 1.3 树（Java中二叉树特性） 某节点的左子树节点仅包含小于该节点的值 某节点的右子树节点仅包含大于该节点的值 节点必须是二叉树 顺序排列 存在问题：树可以认为是介于数组和链表
java集合的数据结构_java集合数据结构汇总
weixin_42365065的博客
02-21 150
一、SetHashSet其实是用了HashMap的数据结构。HashMap的数据结构是一个数组+链表的形式。关于HashMap数据结构的具体实现、以及扩容，参考博客：https://www.jianshu.com/p/8b372f3a195d/TreeSet用了TreeMap的数据结构，TreeMap的本质是一个红黑树，TreeMap类里存着根节点：private transient Entryr...
java数据结构与集合
gjm15535760262的博客
08-07 155
集合 1.数组和集合的区别 相同点 都是容器，可以存储多个数据 不同点 数组的长度是不可变的，集合的长度是可变的 数组可以存储基本数据类型和引用数据类型，几个只能存储引用数据类型，如果要存储基本数据类型，需要存对应的包装类 2.遍历集合 迭代器 Iterator it = c.iterator(); hasNext() 判读当前位置还有没有元素 next() 获取当前位置的元素，并将迭代器对象移向下一个索引位置 remove() 删除迭代器对象当前指向的元素 增强for
JAVA集合数据结构
JAVA架构师成长之路
12-28 912
线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。 Collection接口 　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一
JAVA数据结构和算法
静心编程-java-php-jsp-数据库-网站-我们一起成长
05-06 763
JAVA数据结构 线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。  Collection├List│├LinkedList│├ArrayList│└Vector│　└Stack└Set
Java集合数据结构
鱼获飞的博客
05-26 334
1、HashMap的实现原理、HashMap的数据结构、HashMap的源码理解、从HashMap源码角度说说怎么put数据、HashMap怎么解决hash冲突的。 extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable // 初始容量 16 // 最大容量 2^30 // 加载因子 0.75 // 扩容倍数 2 // 临界值 = 容量 * 加载因子 默认临界值为12 // 最大临界值
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值