java最全最简洁的集合使用总结！五分钟熟练使用

集合

List Set Queue继承于Collection;Map不继承于Collection

ArrayList:一种可以动态增长和缩减的索引序列
LinkedList:一种可以在任何位置进行高效地插入和删除操作的有序序列

HashSet: 一种没有重复元素的无序集合
TreeSet:一种有序集，默认升序
EnumSet:一种包含枚举值的集
LinkedHashSet:一种可以记住元素插入顺序的集

HashMap:一种储存键值关联的数据结构
TreeMap:一种键有序排列的映射表，默认升序，非同步
LinkedHashMap:一种可以记住键值添加顺序的映射表

---

ArrayList

特点：可变集合,集合中允许null的存在，线程不安全，是顺序表（数组）的结构。
优点：基于数组的集合（解决了数组长度固定），有序，可重复，可存储null值，查询效率高
缺点：增删慢
使用场景：频繁访问列表中的某个元素，只需要在列表末尾进行添加和删除元素操作

ArratList方法

增：
1.add(元素) 在列表尾部插入
2.add(index,元素) 在index位置插入元素
3.addAll(另一个相同类型的集合) 将集合中的所有元素添加进来
4.复制一分元素 list.clone() 返回一个新的有一样元素的数组

删：
1.clear()删除集合中的所有元素
2.remove(index）删除index位置上的元素
3.remove(放一个指定集合) 删除包含指定集合中的所有元素
4.subList(index1,index2) 截取部分元素

改：
1.set(index,元素) 把index位置上的值修改成新值
2.sort() 对元素进行升序排序；sort(Comparator.reverseOrder()) 对元素进行降序排序
3.toArray() 将集合转换成数组
4.for循环迭代数组，fori, foreach(item-> ...)
5.toString() 将集合转换为字符串
6.trimToSize()
7.removeIf(e->e.contains("tao")) 如果满足某条件则移除

查：
1.get(index) 查询某个位置的元素
2.indexOf(元素) 返回某个元素的索引值
3.size（） 返回元素的数量
4.lastIndexOf(元素) 指定元素在最后一次出现的位置
5.contains(元素) 返回boolean判断元素是否存在

LinkedList

结构：双向链表
优点：增删效率高()，查询效率低，允许null的存在，不支持多线程的，线程不安全
缺点：不支持随机访问
使用场景：循环迭代来访问列表中的元素，频繁在任意位置删除添加操作

增：
1.add(元素) 在链表末尾添加元素，返回boolean
2.add（index,元素）向指定位置插入元素
3.addAll(集合) 将一个集合的所有元素添加到链表后，返回boolean
4.addAll(index,集合)将集合中的元素按照指定位置开始添加元素
5.addFirst(元素) 将元素添加到头部
6.addLast(元素) 将元素添加到尾部
7.offer(元素) 向链表尾部添加元素，返回boolean
8.offerFirst(元素) 向头部插入元素 返回boolean
9.offerLast(元素) 向尾部插入元素 返回boolean

删：
1.clear() 清空链表
2.removeFirst() 删除并返回第一个元素
3.removeLast() 删除并返回最后一个元素
4.remove(元素) 删除某一元素 返回boolean
5.remove（index） 删除某一位置的元素
6.poll()删除并返回第一个元素

改：
1.set(index,元素)
2.clone() 克隆列表
3.toArrat() 返回一个由链表元素组成的数组。
4.T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组

查：
1.contains(元素) 是否含有某一元素
2.get(index) 返回指定位置的元素
3.getLast() 返回最后一个元素
4.indexOf(元素) 寻找元素第一次出现的索引
5.lastIndexOf(元素) 查询指定元素最后一次出现的索引
6.peek() , element（） 找到并返回第一个元素
7.listIterator() 返回正向迭代器 listIterator(int index)返回从指定位置开始到末尾的迭代器。
8.descendingIterator() 返回倒叙迭代器
9.size() 返回链表元素个数

LinkedList和ArrayList的区别

数据结构：LinkedList基于链表实现，ArrayList基于数组实现。

插入和删除：LinkedList底层基于链表实现所以插入和删除比较高效,而ArrayList插入和删除需要移动其他元素的位置所以不高效

随机访问：ArrayList支持高效的随机访问，通过索引快速获取元素，LinkedList链表需要从头开始查询某个位置的元素

内存消耗：LinkedList的内存消耗要高因为有指针来维护节点的关系

迭代器性能：LinkedList性能好。

---

HashSet

结构：基于HashMap来实现的
优点:不允许有重复元素的集合，允许null值，元素是对象，基本类型要用包装类;可以进行快速删除和查询操作性能很高。
缺点：是无序的，不会记录插入的顺序，不是线程安全的
使用场景：高效存储唯一元素且不要求顺序
注意：不要再迭代过程中修改集合的结构，避免存null

增：
1.add(元素)
2.addAll(集合) 批量插入数据超方便

删：
1.remove(元素)
2.set1.removeAll(set2) 删除包含set2中的元素
3.clear() 清空所有元素

改：
1.clone() 克隆
2.new ArrayList(set) 转换成arraylist
3.new LinkedList(set) 转换成LinkedList

查：
1.contains(元素) 判断某元素是否存在
2.size() 集合大小
3.iterator 返回迭代器
4.set1.retainAll(set2) 交集
5.遍历forEach(x->)
6.set1.equals(set2) 比较两个set,返回boolean

TreeSet

底层：二叉树结构，基于HashMap
优点：不可重复，但可以按照元素大小自动排序，Integer默认自增
缺点：
使用场景：功能强大且灵活的数据结构，适用于需要排序、查找、范围查询等操作的场景
注意：对象需要实现Comparable或者创建TreeSet的时候定义comparator比较器来实现排序

增：
1.add(元素)

删：
1.pollFirst() 获取并移除TreeSet中的第一个元素。如果TreeSet为空，则返回null。
2.clear()
3.remove(元素)
4.pollLast() 获取并移除TreeSet中的最后一个元素。如果TreeSet为空，则返回null。

改：
直接改变某个已存在元素的值是不被支持的

查：
1.contains(元素)
2.size()
3.first() 返回第一个也就是最小的元素
4.last() 返回最后一个也就是最大的元素
5.isEmpty() 检查是否为空
6.iterator() 返回迭代器
7.subSet(元素1，元素2) 返回元素1到元素2之间的所有元素
8.descendingIterator()：返回TreeSet的逆序迭代器。
9.ceiling(元素)：返回大于或等于给定键值的最小键值。
10.floor(元素)：返回小于或等于给定键值的最大键值。

---

HashMap

底层：散列表，内容是键值对key-value（数组+链表）
优点：具有很快的访问速度，允许null,不支持线程同步
缺点：无序，不记录插入顺序
使用场景：可以用作缓存数据的存储结构，快速查询数据，数据分组等
注意：元素是对象，基本类型使用包装类

增：
1.put(key，value) 增加键值对
2.clone() 复制一份hashmap
3.putAll(map2) 将map2的所有键值对添加到原本的map中
4.putIfAbsent() 先判断指定的键（key）是否存在，不存在则将键/值对插入到 HashMap 中。存在则返回值。

删：
1.clear() 删除所有键值对
2.remove(key)

改：
1.replace(key,value)
2.replaceAll((key,value) -> value.toUpperCase)对每个键值对进行更改

查：
1.isEmpty 判断是否为空
2.size() 计算键值对的数量
3.contains(key)
4.contains(value)
5.get(key) 获取指定key对应的value
6.getOrDefault(key，defaultValue))获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
7.entrySet() 返回hashMap中所有的集合视图
8.keySet() 返回所有key组成的集合视图
9.values() 返回存在的所有value

TreeMap

底层：红黑树
优点：key值不可重复，默认key升序排序
缺点：维护红黑树结构，因此空间开销可能会更大一些
使用场景：时间复杂度均为O(log n)。对于大规模数据来说，尤其是当需要维持有序特性时，性能更可预测。

增删改查同hashMap

LinkedHashMap

底层：基于HashMap的双向链表来实现的（数组+链表（红黑树）+双向链表）

特点：HashMap无序，而LinkedHasMap有序，可分为插入顺序排序和访问顺序排序两种

缺点：线程不安全的

LRU算法（最近最少访问的）

默认访问其中的元素的时候，只要对其操作比如用了get访问这个元素，那么这个元素就会移动位置到置顶的位置（对这个元素进行操作就会移动位置到最前方），后面没有被访问的就会往后移动，清除元素就从后面开始清除，用作做缓存的情景。

构造方法

public LinkedHashMap(init initalCapacity,float loadFactor,boolean accessOrder){}

如果accessOrder设置成true就是按照访问顺序排序的，如果设置成fasle就是按照插入顺序排序的。

---

String

增
1.copyValueOf(char[] data) 使用整个输入字符数组来创建一个新的字符串对象。
2.getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。

删

改

1. byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
2. replace(char oldChar, char newChar)返回一个新的字符串
3. substring(int beginIndex) 从index截取字符
4. substring(int beginIndex, int endIndex) 截取index区间字符
5. toCharArray()将此字符串转换为一个新的字符数组。
6. toUpperCase()

查
1.charAt(index) 返回char,查询某个索引的字符
2.compareTo(比较的对象) 返回0则相同
3.compareToIgnoreCase(string s) 比较两个字符串不考虑大小写
4.contentEquals(Stringbuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真
5.endsWith(String suffix) boolean测试此字符串是否以指定的后缀结束
6.equlas(对象) equalsIgnoreCase(String s)
7.etBytes(String charsetName)使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
8.int hashcode() 返回此字符串的哈希码。
9.int indexOf(字符) 返回此字符串第一次出现的索引

1. indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。
2. indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
3. lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。
4. int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
5. length() 返回此字符串的长度。
6. matches(String regex)是否匹配给定的正则表达式。
7. startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
8. contains(String)
9. isEmpty()

数组

遍历数组：
fori可以获取下表和值，forEach对每个元素处理

通过Arrays类可以操作数组：

1. Arrays.binarySearch(数组，值) 二分查找
2. Arrays.equals(数组1，数组2) 判断是否一样
3. fill(数组1,值) 将数组中每个位置都赋予某个值
4. sort(数组) 自动升序