网硕互联帮助中心
一、单列集合
1. Collection
相关方法
| boolean add(E e) | 把给定的对象添加到当前集合中 |
| void clear() | 清空集合中所有的元素 |
| boolean remove(E e) | 把给定的对象在当前集合中删除 |
| boolean contains(Object obj) | 判断当前集合中是否包含给定的对象 |
| boolean isEmpty() | 判断当前集合是否为空 |
| int size() | 返回集合中元素的个数 / 集合的长度 |
2. List
相关方法
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
3. ArrayList
相关方法
| boolean add(E e) | 添加元素，返回值表示是否添加成功 |
| boolean remove(E e) | 删除指定元素，返回值表示是否删除成功 |
| E remove(int index) | 删除指定索引的元素，返回被删除元素 |
| E set(int index,E e) | 修改指定索引下的元素，返回原来的元素 |
| E get(int index) | 获取指定索引的元素 |
| int size() | 集合中元素的数量 |
遍历方式
迭代器
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it = list.iterator();
while(it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
列表迭代器
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
}
增强for
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
for(String s : list) {
System.out.println(s);
}
}
lambda表达式遍历
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.forEach(s -> System.out.println(s));
}
普通for
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
4. LinkedList
相关方法
| void addFirst(E e) | 在该列表开头插入指定的元素 |
| void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| E getFirst() | 返回此列表中的第一个元素 |
| E getLast() | 返回此列表中的最后一个元素 |
| E removeFirst() | 从此列表中删除并返回第一个元素 |
| E removeLast() | 从此列表中删除并返回最后一个元素 |
5. Set
相关方法
继承于Collection
6. HashSet
相关方法
继承于Set
特点：无序、不重复、无索引
7. LinkedHashSet
相关方法
继承于Set
特点：有序、不重复、无索引
8. TreeSet
相关方法
| E first() | 获取最小元素 |
| E last() | 获取最大元素 |
| E lower(E e) | 获取 小于 e 的最大元素 |
| E higher(E e) | 获取 大于 e 的最小元素 |
| E floor(E e) | 获取 小于等于e 的最大元素 |
| E ceiling(E e) | 获取 大于等于e 的最小元素 |
| SortedSet<E> subSet(E from, E to) | 获取 [from, to) 区间元素 |
| SortedSet<E> headSet(E to) | 获取小于 to 的元素 |
| SortedSet<E> tailSet(E from) | 获取大于等于 from 的元素 |
特点：可排序、不重复、无索引
排序方式
方式一
在javaBean中实现Comparable接口指定排序规则
方式二
创建TreeSet对象时，传递比较器Comparable指定规则
单列集合使用场景
1. 如果想要集合中的元素可重复
用ArrayList集合，基于数组的。（用的最多）
2. 如果想要集合中的元素可重复，而且当前的增删操作明显多于查询
用LinkedList集合，基于链表的。
3. 如果想对集合中的元素去重
用HashSet集合，基于哈希表的。（用的最多）
4. 如果想对集合中的元素去重，而且保证存取顺序
用LinkedHashSet集合，基于哈希表和双链表，效率低于HashSet。
5. 如果想对集合中的元素进行排序
用TreeSet集合，基于红黑树。后续也可以用List集合实现排序
二、双列集合
1. Map
相关方法
| V put(K key,V value) | 添加元素 |
| V remove(Object key) | 根据键删除键值对元素 |
| void clear() | 移除所有的键值对元素 |
| boolean containsKey(Object key) | 判断集合是否包含指定的键 |
| boolean containsValue(Object value) | 判断集合是否包含指定的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中键值对的个数 |
| V getOrDefault(Object key, V defaultValue) | 从 Map 中取 key 对应的值，如果 key 不存在，返回默认值。 |
2. HashMap
相关方法
继承于Map
遍历方式
键找值
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
map.put("A","65");
map.put("B","66");
map.put("C","67");
Set<String> keys = map.keySet();
for (String key : keys) {
String value = map.get(key);
System.out.println(key + " = " + value);
}
}
键值对
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("A", "65");
map.put("B", "66");
map.put("C", "67");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
}
Lambda表达式
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
map.put("A","65");
map.put("B","66");
map.put("C","67");
// 完整版
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String value) {
System.out.println(key + "=" + value);
}
});
System.out.println("———————————-");
// 简写版
map.forEach((String key, String value)->{
System.out.println(key + "=" + value);
});
}
3. LinkedHashMap
相关方法
继承于HashMap
4. TreeMap
相关方法
| K firstKey() | 返回最小 key |
| K lastKey() | 返回最大 key |
| K lowerKey(K key) | 返回小于 key 的最大 key |
| K higherKey(K key) | 返回大于 key 的最小 key |
| K floorKey(K key) | 返回 ≤ key 的最大 key |
| K ceilingKey(K key) | 返回 ≥ key 的最小 key |
| SortedMap<K,V> subMap(K fromKey, K toKey) | 返回子 Map |
| SortedMap<K,V> headMap(K toKey) | 返回子 Map |
| SortedMap<K,V> tailMap(K fromKey) | 返回子 Map |
| Comparator<? super K> comparator() | 返回比较器（null = 自然排序） |
排序规则
方式一
在javaBean中实现Comparable接口指定排序规则
方式二
创建TreeSet对象时，传递比较器Comparable指定规则
三、Collections工具类
相关方法
| static <T> boolean addAll(Collection<T> c, T… elements) | 批量添加元素 |
| static void shuffle(List<?> list) | 打乱 List 集合元素的顺序 |
| static <T> void sort(List<T> list) | 排序 |
| static <T> void sort(List<T> list, Comparator<T> c) | 根据指定的规则进行排序 |
| static <T> int binarySearch (List<T> list, T key) | 以二分查找法查找元素 |
| static <T> void copy(List<T> dest, List<T> src) | 拷贝集合中的元素 |
| static <T> int fill (List<T> list, T obj) | 使用指定的元素填充集合 |
| static <T> void max/min(Collection<T> coll) | 根据默认的自然排序获取最大 或小值 |
| static <T> void swap(List<?> list, int i, int j) | 交换集合中指定位置的元素 |
四、不可变集合
相关方法
| static <E> List<E> of(E… elements) | 创建一个不可变的 List |
| static <E> Set<E> of(E… elements) | 创建一个不可变的 Set（无重复元素） |
| static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, …) | 创建一个不可变 Map |
| static <E> List<E> copyOf(Collection<? extends E> coll) | 根据已有集合创建不可变 List |
| static <E> Set<E> copyOf(Collection<? extends E> coll) | 根据已有集合创建不可变 Set |
| static <K,V> Map<K,V> copyOf(Map<? extends K, ? extends V> map) | 根据已有 Map 创建不可变 Map |
评论前必须登录！
注册