十、集合
| ArrayList | 一种可以动态增长和缩减的索引序列 |
| LinkedList | 一种可以在任何位置进行高效地插人和删除操作的有序序列 |
| ArrayDeque | 一种用循环数组实现的双端队列 |
| HashSet | 一种没有重复元素的无序集合 |
| TreeSet | —种有序集 |
| EnumSet | 一种包含枚举类型值的集 |
| LinkedHashSet | 一种可以记住元素插人次序的集 |
| PriorityQueue | 一种允许高效删除最小元素的集合 |
| HashMap | 一种存储键 / 值关联的数据结构 |
| TreeMap | —种键值有序排列的映射表 |
| EnumMap | 一种键值属于枚举类型的映射表 |
| LinkedHashMap | 一种可以记住键 / 值项添加次序的映射表 |
| WeakHashMap | 一种其值无用武之地后可以被垃圾回收器回收的映射表 |
| IdentityHashMap | 一种用 = 而不是用 equals 比较键值的映射表 |
Collection
import org.example.Size;
import org.junit.Before;
import org.junit.Test;
import java.util.*;
public class CollectionTest {
Collection collection;
Collection A;
Collection B;
@Before
public void b(){
collection=new ArrayList();
for (int i = 0; i < 5; i++) {
collection.add(i);
}
A=new ArrayList();
for (int i = 0; i < 5; i++) {
A.add(i);
}
B=new ArrayList();
for (int i = 4; i < 7; i++) {
B.add(i);
}
}
/**
* collection 的基本遍历
*/
@Test
public void t1(){
collection.iterator().forEachRemaining( o -> System.out.print(o));
System.out.println();
collection.iterator().forEachRemaining( System.out::print);
System.out.println();
Iterator<Integer> iterator=collection.iterator();
while (iterator.hasNext()){
Integer i=iterator.next();
if (i==2)iterator.remove();
System.out.print(i);
}
System.out.println();
for (Object o :collection){
System.out.print(o);
}
System.out.println();
collection.forEach(o -> {
System.out.print(o);
});
}
/**
* collection 常用方法
*/
@Test
public void t2(){
// 集合大小
System.out.println(collection.size());
// 集合是否为空
System.out.println(collection.isEmpty());
// 集合是否包含对象
System.out.println(collection.contains(3));
// 集合是否包含集合
System.out.println(collection.containsAll(new ArrayList<>()));
//可以看到这个方法改变了集合A中的元素，将存在于集合A中但不存在于集合B中的元素移除。
//如果集合A的大小发生了改变，返回true，即使两个集合完全没有交集，也会返回true。
//如果集合A的大小没有发生改变，返回false，即使两个集合完全相同，也会返回false。
A.retainAll(B);
// 注意这里是 Collection collection,A,B 名字没起好
collection.remove(1);
collection.removeAll(A);
collection.addAll(A);
System.out.println(collection); // [0, 2, 3, 4]
Integer[] integers=new Integer[6];
// 集合转数组
Object[] integers2=collection.toArray(integers);
// Arrays.toString ，按一定格式将数组转化成字符串的
System.out.println(Arrays.toString(integers)); // [0, 2, 3, 4, null, null]
System.out.println(Arrays.toString(integers2));// [0, 2, 3, 4, null, null]
Object[] integers3= collection.toArray();
System.out.println(Arrays.toString(integers3));// [0, 2, 3, 4]
// 清空
collection.clear();
}
}
集合转数组部分订正
// 列表转换数组，
// 数组类型不能强制转换，Object数组 类 和 Integer数组 类 是无法互相转换的
// 这样用的时候不方便操作， (Integer)obejects[0]
Object[] objects=list.toArray();
Integer[] nums2;
// 可以传入一个指定类型的数组 将返回同类型数组
// 如果传入数组长度不够，会新建一个同类型数组并返回
nums2=list.toArray(new Integer[0]);
// 如果传入数组长度够用，则直接填入到这个数组中并返回
nums2=list.toArray(new Integer[10]);
LinkList
import org.junit.Test;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class ListTest {
@Test
public void t1(){
List<Integer> list=new LinkedList<>();
for (int i = 0; i < 5; i++) {
list.add(i);
}
ListIterator<Integer> iterator=list.listIterator();
/// 以下都是 函数生效前 游标位置
// next 返回游标 后面的元素，同时游标右移 之后如果使用 remove/set 操作的是 游标左侧元素
// previous 返回游标 前面的元素，同时游标左移 之后如果使用 remove/set 操作的是 游标右侧元素
// nextIndex返回游标 后面的元素位置
// public int previousIndex() { return nextIndex - 1;}
// previousIndex返回游标 前面的元素位置 = 后面的元素位置-1
System.out.println(iterator.previousIndex());// -1
System.out.println(iterator.nextIndex()); //0
System.out.println(iterator.next()); // 0
iterator.add(7); //
System.out.println(iterator.next());// 1 在添加元素后 iterator previous() 是刚添加的元素，next() 是 刚添加的元素后面的元素
System.out.println(iterator.previous());// 1
iterator.remove();
System.out.println(iterator.next()); // 2
System.out.println(iterator.nextIndex());// 3 0 7 2 | 3 游标在这个位置
iterator.set(6);
iterator.hasNext();
iterator.hasPrevious();
System.out.println("*************");
iterator=list.listIterator();
for (int i = 0; i < 20; i++) {
if (iterator.hasNext()){
System.out.println(iterator.next());
}
}
System.out.println(list.get(1));
// 元素第一次出现的位置 没有找到返回 -1
System.out.println(list.indexOf(4));
// 元素最后一次出现的位置 没有找到返回 -1
System.out.println(list.lastIndexOf(4));
LinkedList<Integer> list2=new LinkedList<>();
list2.addFirst(1);
list2.addLast(3);
list2.getFirst();
list2.getLast();
list2.removeFirst();
list2.removeLast();
}
}
ArrayList
Vector 也可以实现动态数组
Vector 所有方法都是同步的，耗时
ArrayList 所有方法都是不同步的
HashSet
-
桶：收集具有相同散列值的数据结构，具有相同散列值得放在一个桶里
-
桶数：桶的数目，通常将桶的数目设置为预计元素个数的 75%~150%
-
填装因子：（默认为 0.75） 当表中超过 75% 的位置已经被填充，就会用双倍的桶数进行再散列
-
再散列：重新创建一个桶数更多的表，将原表元素插入新表，并舍弃旧的表
Map 的 key 是唯一的，从 HashSet 的源码中可以看到，HashSet 实际上是使用了 HashMap 的 key 作为元素
注释中说明了默认的 桶数为 16 ，填装因子为 0.75
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* default initial capacity (16) and load factor (0.75).
*/
public HashSet() {
map = new HashMap<>();
}
常用方法
HashSet<String> hashSet=new HashSet<>();
// public HashSet(Collection<? extends E> c) {
// 将集合全部元素添加到散列集
new HashSet<String>(new ArrayList<String>());
// 设置桶数
new HashSet<String>(16);
// 设置桶数和填装因子
new HashSet<String>(16,0.75f);
// 添加元素
hashSet.add("zs");
hashSet.add("ls");
hashSet.add("zs");
// 是否包含元素
hashSet.contains("zs");
hashSet.remove("zs");
//
// 对于要存于 散列集的对象要重写 hashCode() 方法 和 equals() 方法，
// 并且要保证 若果 x.equals(y) 为 true 那么 x.hashCode()==y.hashCode 为true
//
"zs".hashCode();
hashSet.iterator().forEachRemaining(System.out::println);
特点：
- 集合元素可以是null,但只能放入一个null
- 不是同步的
TreeSet
// TreeSet 中的元素 在遍历时，是按顺序排列的，当前是使用 红黑树 实现的
// TreeSet 实现了 SortedSet 接口
// 使用树集 元素必须实现 Comparable 接口，（元素不能比较的话，没办法排序的），或者 new 的时候传入比较器
TreeSet<String> set=new TreeSet<>();
set.add("john");
set.add("bob");
set.add("carlos");
set.add("bob");
set.add("a");
set.add("z");
// 遍历
for (String s : set) {
System.out.println(s);
}
set.iterator().forEachRemaining(System.out::println);
// 常用方法
set.first();
set.last();
// NavigableSet 接口的方法
// 返回 比 bz 大的元素中 最小的
System.out.println(set.higher("bz")); // carlos
// 返回 比 bz 小的元素中 最大的
System.out.println(set.lower("bz")); // bob
// 返回 比 bob 大或等于的元素中 最小的
System.out.println(set.ceiling("bob"));
// 返回 比 bob 小或等于的元素中 最大的
System.out.println(set.floor("bob"));
// 删出最小元素并返回
set.pollFirst();
// 删出最大元素并返回
set.pollLast();
System.out.println("*********");
// descendingIterator() 返回一个反向迭代器，用于逆序遍历
set.descendingIterator().forEachRemaining(System.out::println);
Queue
-
双端队列 Deque
左往右的队列操作，右往左也支持
-
优先级队列 PriorityQueue
可以以任意顺序插入，但是始终是按顺序检索
使用数据结构 堆（heap）：一个可以自我调整的二叉树
常用方法
Queue<Integer> queue=new ArrayDeque<>();
queue.add(999);
// 以下方法，每组 前面的 出错抛出异常，后面的 返回 false 或者 null
// 添加元素 ，队列满了则无法添加
queue.add(1); //抛出异常
queue.offer(2); // 返回 false
// 移除并返回头部元素
queue.remove();
queue.poll();
// 返回头部元素，但不删除
queue.element();
queue.peek();
// 双端队列
// public interface Deque<E> extends Queue<E> {
// ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>
Deque<Integer> deque=new ArrayDeque<>();
deque.add(999);
// 头插 和 尾插
deque.addFirst(1); // 出错抛出异常
deque.addLast(2);
deque.offerFirst(3); // 出错返回 false
deque.offerLast(4);
// 移除并返回头/尾部元素
deque.removeFirst();
deque.removeLast();
deque.pollFirst();
deque.pollLast();
// 返回头/尾部元素，但不删除
deque.getFirst();
deque.getLast();
deque.peekFirst();
deque.peekLast();
// 设置初始容量，无参构造器 默认为 16
// ArrayQueue 在满了的时候能自动扩充容量
Queue<Integer> queue2=new ArrayDeque(8);
// 优先级队列
// 元素可以按任意顺序插入，但是总是按照排序的顺序进行检索
// 使用了 数据结构 堆 （heap 一个可以自我调整的二叉树）
// PriorityQueue<E> extends AbstractQueue<E>
// AbstractQueue<E> extends AbstractCollection<E> implements Queue<E>
Queue<Integer> queue3=new PriorityQueue<>();
queue3.add(9);
queue3.add(8);
queue3.add(2);
queue3.add(7);
System.out.println(queue3); // [2, 7, 8, 9]
HashMap
Map<Integer,String> map=new HashMap<>();
map.put(1,"1zs");
map.put(2,"2ls");
String name;
name=map.get(1);
// 获取失败时，用 无名氏 当作默认值返回
name=map.getOrDefault(99,"无名氏");
map.put(2,"2ls cover");
// void putAll(Map<? extends K, ? extends V> m);
map.putAll(new HashMap<>());
boolean b;
// 查看 是否包含 键
b=map.containsKey(1);
// 查看 是否包含 值
b=map.containsValue("2ls");
// 对map中每组 键值对 都执行 某操作
map.forEach((k,v)->{
System.out.println("key "+ k+" : "+v);
});
new HashMap<>();
// 初始化时设置桶数，和 Set 相同
new HashMap<>(16);
// 初始化时设置桶数和填装因子
new HashMap<>(16,0.75f);
TreeMap
能自动按键排序的 Map
TreeMap<Integer,String> treeMap=new TreeMap<>();
// public TreeMap(Comparator<? super K> comparator) {
// 注意 是 Comparator 不是 Comparable
// 是 tor ！ 不是 able！
// 可以传入一个比较器，作为 key 的比较方法，可以用 lambda 表达式写法，也可以 匿名类 或者写一个实现接口的类
new TreeMap<Integer,String>((a,b)->{return 1;});
treeMap.put(3,"3ww");
treeMap.put(1,"1zs");
treeMap.put(2,"2ls");
treeMap.put(2,"2ls cover");
// SortedMap 接口的方法
// 返回最小 key 和 最大 key
treeMap.firstKey();
treeMap.lastKey();
// 当原先 key 对应 value 不存在时 才放入新 value
treeMap.putIfAbsent(1,"1 putIfAbsent");
// 参数 1 key
// 参数 2 新值
// 参数 3 处理旧值和新值 的过程
// get(key) 为 null 时，直接将参数 2 作为新value
// 不为空的时候 用参数 3 处理 原value 和 参数 2 ,结果作为新value
// 如果参数 3 处理结果为 null 则移除value 即 remove(key)
// 不为空则 put(key ,newValue)
// 详情见源码
treeMap.merge(1,"merger",String::concat); // 1:1zsmerger
treeMap.merge(4,"--merger",(a,b)->{return a+b+"lambda";});// 4:--merger
// 将 key 和 value 做一定处理 作为新的 value
// 及时 get(key) 为空也会处理
// 处理结果为 null 则会移除 remove(key)
// 不为空则 put(key ,newValue)
treeMap.compute(3,(k,v)->{return k+v+"lambda";}); // 3:33wwlambda
treeMap.compute(9,(k,v)->{ return k+v+"lambda";});// 9:9nulllambda
// 当 key 对应值 不为 null 时才做处理,否则直接返回
treeMap.computeIfPresent(10,(k,v)->{ return k+v+"computeIfPresent";});
// 当 key 对应值 为 null 时才做处理
treeMap.computeIfAbsent(11,(k)->{ return k+"computeIfPresent";});
// 将所有映射 都用函数处理
treeMap.replaceAll((k,v)->{ return v;});
treeMap.forEach((k,v)-> System.out.println(k+":"+v));
System.out.println(null+"-hello"); // 输出 null-hello
Map映射视图
map.keySet();
map.values();
map.entrySet();
对 Map 做映射方便做一些操作，有点像 SQL 的视图
对三种映射视图通过 iterator 做 remove() 操作，都会同时影响到原 map
若能修改视图，则也会使 原来的 map 做出相应的修改
但是都不能使用 add() 方法，会抛异常
Map<Integer,String> map=new HashMap<>();
map.put(2,"2ls");
map.put(3,"3ww");
map.put(1,"1zs");
map.put(4,"4zl");
// 返回 键 集
Set<Integer> integers = map.keySet();
// 返回 值 的集合
Collection<String> values = map.values();
// 返回 键值组合的结构 Entry 的集
Set<Map.Entry<Integer, String>> entries = map.entrySet();
// 1=1zs
// 2=2ls
// ··········
// 输出结果如上， toString() 方法会将 key 和 value 中间以等号拼接
// static class Node<K,V> implements Map.Entry<K,V> {
// public final String toString() { return key + "=" + value; }
entries.forEach(System.out::println);
// 在键集视图上，用迭代器 remove() 方法删除键，会删除原来 map 中对应的 键和值
Iterator iterator=integers.iterator();
while (iterator.hasNext()){
Integer i= (Integer) iterator.next();
if (i==2){
iterator.remove();
}
}
// 在值集合视图上，用迭代器 remove() 方法删除键，会删除原来 map 中对应的 键和值
Iterator<String> iterator2 = values.iterator();
while (iterator2.hasNext()){
String next = iterator2.next();
if ("1zs".equals(next)){
iterator2.remove();
}
}
// 在键值集视图上，用迭代器 remove() 方法删除键，会删除原来 map 中对应的 键和值
// 修改键对应的值，会使原来的 map 被相应的修改
Iterator<Map.Entry<Integer, String>> iterator3 = entries.iterator();
while (iterator3.hasNext()){
Map.Entry<Integer, String> next = iterator3.next();
if (3==next.getKey()){
next.setValue("通过 Entry 被修改了");
}
if (4==next.getKey()){
iterator3.remove();
}
}
// map 中的 1 2 4 都被 被删除了
// 键 3对应的值被修改为 ： 3通过 Entry 被修改了
map.forEach((k,v)-> System.out.println(k+v));
// 三种映射视图都不能使用 add() 方法，会抛异常
//integers.add(5);
//values.add("5");
//entries.add(null);
weakHashMap弱散列映射
能与垃圾回收器协同工作的 Map
// WeakHashMap 使用弱引用保存键
// 当对键的唯一引用，来自散列条目时，这一数据结构将与垃圾回收器协同工作，一起删除键值对
WeakHashMap<Integer, String> weakHashMap = new WeakHashMap<>();
// WeakHashMap 不是线程安全的 ，在并发场景下使用，可以使用 Collections.synchronizedMap(weakHashMap);
// Map<Integer, String> map = Collections.synchronizedMap(weakHashMap);
weakHashMap.put(1,"1zs");
weakHashMap.put(2,"2zs");
LinkedHashSet LinkedHashMap
能按顺序（插入顺序或受影响顺序）遍历的 HashSet 和 HashMap
// LinkedHashMap 会记住数据插入的顺序，可以按插入顺序迭代
LinkedHashMap<Integer,String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put(1,"1zs");
linkedHashMap.put(3,"3zs");
linkedHashMap.put(2,"2zs");
linkedHashMap.put(4,"4zs");
// 1 3 2 4
linkedHashMap.forEach((k,v)->{System.out.println(k+" : "+v);});
// 第三个参数 accessOder 默认为false，若设置为true ，
// 则每当 调用get 或 put ，会将受影响的条目从当前位置移除，放置到条目链表的尾部
// 这种特性可以应用于高速缓存的最近最少用原则，最前面的元素说明最近没有访问，有新数据要加入缓存可以移除靠前面的元素
linkedHashMap = new LinkedHashMap<Integer,String>(16,0.75f,true);
linkedHashMap.put(1,"1zs");
linkedHashMap.put(3,"3zs");
linkedHashMap.put(2,"2zs");
linkedHashMap.put(4,"4zs");
linkedHashMap.get(1);
linkedHashMap.get(2);
linkedHashMap.get(3);
linkedHashMap.get(4);
// 1 2 3 4
linkedHashMap.forEach((k,v)->{System.out.println(k+" : "+v);});
// 会记住插入顺序的 集，会以插入顺序进行遍历
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("1zs");
linkedHashSet.add("3zs");
linkedHashSet.add("2zs");
linkedHashSet.add("4zs");
linkedHashSet.contains("3zs");
// 1 3 2 4
linkedHashSet.forEach(System.out::println);
EnumSet EnumMap
针对枚举类型作为 集的元素 或者 Map 的 key 时
一种高效的 Set 和 Map
// EnumSet 是 枚举类型 的集的高效实现
// 没有 public 构造方法，需要使用静态工厂方法构造集
EnumSet<Size> sizes ;
// 返回一个包含所有枚举值的集
sizes= EnumSet.allOf(Size.class);
// 返回一个空集
sizes= EnumSet.noneOf(Size.class);
// 返回一个从 x 到 x 的枚举值的集
sizes=EnumSet.range(Size.SMALL,Size.LARGE);
// 返回一个包含 参数 1 ，参数 2，参数 3 ··· 的枚举值得值
sizes=EnumSet.of(Size.SMALL,Size.LARGE);
sizes.forEach(System.out::println);
// EnumMap 是一个键类型是枚举类型的 map，它直接高效的用数组实现
// 构造时需要指定键的枚举类型
EnumMap<Size, Object> enumMap = new EnumMap<>(Size.class);
IdentityHashMap
根据对象的内存来判断 key 是否一致的 Map
// IdentityHashMap
// 这个类中键的散列值是使用 System.identityHashCode(Object o) 计算，(一种根据对象的内存地址来计算散列码的方式)
// 而不是 hashCode()
// 对象比较的时候，使用的是 == 而不是 equals
String a="abcd";
String b= "ab";
// 避免 编译器优化，使 a,b 有不同的内存地址
if (a.equals("abcd")){
b+="cd";
}
System.out.println(a==b); //false
System.out.println(a.equals(b));// true
System.out.println(System.identityHashCode(a)==System.identityHashCode(b));//false
IdentityHashMap<String,Integer> identityHashMap=new IdentityHashMap<>();
identityHashMap.put(a,1);
identityHashMap.put(b,2);
identityHashMap.forEach((k,v)->{
System.out.println(k+":"+v);
});
/*
输出结果
false
true
false
abcd:1
abcd:2
*/
视图与包装器
类似 HashMap 的 keySet() values() 还有一些其他视图
轻量级集合包装器
- 数组包装成 List ： Arrays.asList()
// List = Arrays.asList() 可以修改数据，不能改变数组大小（不能对list添加删除）
String[] strings={"1zs","2ls","3ww"};
List<String> list = Arrays.asList(strings);
list.set(0,"1-set");
list.get(0);
// 输出 1-set 2ls 3ww
list.forEach(s -> {System.out.println(s);});
// [1-set, 2ls, 3ww]
System.out.println(Arrays.toString(strings));
// 任何改变 数组大小的操作如 add remove 都会抛出异常
//list.add("ss");
- 单一元素
// List = Collections.nCopies(重复次数，要重复的Object)
// 不允许修改数据
List<String> list2 = Collections.nCopies(15, "你好");
// 输出 15 组你好
list2.forEach(System.out::print);
System.out.println();
// 不允许修改数据
//list2.set(2,"不好");
// 不允许改变
//list2.add("xx");
// 获得一个单一的元素集、列表、映射
Set<String> singleton = Collections.singleton("1");
List<String> singletonList = Collections.singletonList("1");
Map<Integer, String> singletonMap = Collections.singletonMap(1, "1");
子范围
-
List 子范围
获得一个范围内的子列表
// List 子范围 List.subList(int fromIndex, int toIndex);
// 可以将任何操作应用到子范围(包括 remove add)
List<Integer> list3=new LinkedList<>();
list3.add(1);
list3.add(2);
list3.add(3);
list3.add(4);
// 返回一个索引从 参数 1 (包括此索引) ，到 参数 2 (不包括此索引) 的 List
// 用函数定义域理解就是 [ 1 ,3 )
List<Integer> list4 = list3.subList(1, 3);
list4.clear(); // list3:[1, 4]
list4.add(6); // list3:[1, 6, 4]
System.out.println(list3);
-
SortedSet 子范围
获得一个范围内的子元素集
// SortedSet 子范围
// 可以在 子范围内进行操作
SortedSet<String> sortedSet = new TreeSet<>();
sortedSet.add("az");
sortedSet.add("za");
sortedSet.add("gg");
// 返回 大于等与参数1 小于 参数2 的元素子集
// ["bb" ,"qq")
SortedSet<String> sortedSet2 = sortedSet.subSet("bb", "qq");
System.out.println(sortedSet2);// [gg]
sortedSet2.remove("gg"); // sortedSet:[az, za]
// 可以在子范围内操作 添加
sortedSet2.add("qa"); // sortedSet: [az, qa, za]
// "zz">"qq" 添加了超出子范围的 数据 会抛出异常
//sortedSet2.add("zz");
System.out.println(sortedSet);
// 返回 小于 "qa" 的元素子集
sortedSet.headSet("qa"); // [az]
// 返回 大于等于 "az" 的元素子集
sortedSet.tailSet("az"); // [az, qa, za]
不可修改的视图、同步视图、受查视图
- 同步视图
转换获得一个具有同步访问方法的 集合 - 受查视图
插入时检查 插入对象是否为给定类
// 不可修改的视图
// Collections.unmodifiableCollection
// Collections.unmodifiableList
// Collections.unmodifiableSet
// Collections.unmodifiableSortedSet
// Collections.unmodifiableNavigableSet
// Collections.unmodifiableMap
// Collections.unmodifiableSortedMap
// Collections.unmodifiableNavigableMap
Collection<String> strings1 = Collections.unmodifiableCollection(list);
System.out.println(strings1);
// 同步视图
// 转换获得一个具有同步访问方法的 集合
Collections.synchronizedCollection(list);
// Collections.synchronizedList()
// 其他方法同上省略 ········
// 受查视图
// 插入时检查 插入对象是否为给定类
// 如下代码
ArrayList<String> list8=new ArrayList<>();
ArrayList list9= list8;
list9.add(new Date());
// 在这里会报错 ，但是实际上出错的位置是在 add 处，无法正确检测到出错位置
// String s= (String) list9.get(0);
// 获得一个安全的列表视图，在 add 时候就会检查插入对象是否为给定类
List<String> safeList=Collections.checkedList(list8,String.class);
// Collections.checkedCollection()
// 其他方法同上省略 ········
常用算法
- 排序和混排
List<Integer> list=new ArrayList<>();
list.add(7);
list.add(9);
list.add(2);
list.add(3);
System.out.println(list);
// 排序 默认升序
Collections.sort(list);
System.out.println(list); // [2, 3, 7, 9]
// 自定义比较器
list.sort((a,b)->{ return b.compareTo(a);}); // [9, 7, 3, 2]
list.sort(Integer::compareTo); // [2, 3, 7, 9]
// public int compare(Comparable<Object> c1, Comparable<Object> c2) {return c2.compareTo(c1);}
// 传入了一个 用 c2.compareTo(c1) 实现 compare 方法的比较器,因此排出来就是降序的了
// 降序排列
list.sort(Comparator.reverseOrder());
System.out.println(list); // [9, 7, 3, 2]
// 将原数据转化成 double 在做逆序排列
// Integer::doubleValue 是传入的 转化成 double 数据的方法
list.sort(Comparator.comparingDouble(Integer::doubleValue).reversed());
System.out.println(list);
// 根据员工的工资 逆序排列员工
//staff.sort(Comparator.compari ngDoubl e(Empl oyee::getSalary) . reversedO)
// 打乱数组顺序
Collections.shuffle(list);
// 集合类库中使用的是归并排序，可以保证 通过比较器认为相同的两个元素，会按原有顺序排列
// 比如 已经按照总分排好的 学生成绩表，在按照数学成绩排序时，数学成绩相同的学生，总分高的仍会排在前面
-
二分查找
使用二分查找必须先排序，否则会得出错误的结果
二分查找 对支持随机访问的数据结构才有意义，如果提供的是 LinkedList 将自动变为线性查找
List<Integer> list=new ArrayList<>();
Integer[] nums={9,7,6,2,6,4,7,8,6,3,4};
//for (Integer num : nums) { list.add(num);}
list=Arrays.asList(nums);
// 使用二分查找必须先排序，否则会得出错误的结果
Collections.sort(list);
System.out.println(list); // [2, 3, 4, 4, 6, 6, 6, 7, 7, 8, 9]
// 返回找到元素的下标，如果元素重复，返回的是根据二分查找算法首次找到元素的下标，而不是重复元素的首个下标
// 查找失败时返回负数 i ，-i-1 为查找元素应插入位置
int index = Collections.binarySearch(list, 6);
System.out.println(index); // 5
// 二分查找 对支持随机访问的数据结构才有意义，如果提供的是 LinkedList 将自动变为线性查找
- Collections 提供的一些简单算法
List<Integer> list=new ArrayList<>();
Integer[] nums={9,7,6,2,6,4,7,8,6,3,4};
//list=Arrays.asList(nums);
for (Integer num : nums) { list.add(num);}
int i;
i=Collections.max(list);
i=Collections.min(list);
// Collection.copy 是浅拷贝
// Collection.copy 方法要求目标列表的 size 必须大于 源列表的 size ,否则直接抛出IndexOutOfBoundsException
// list 的size() 只有在 add 和 remove 的时候才会发生改变，所以先用空对象填充
List<Integer> newList=new ArrayList(Arrays.asList(new Object[list.size()]));
Collections.copy(newList,list);
System.out.println(newList);
// boolean List.addAll(Collection<? extends E> c);
// 把一个集合的所有元素添加到 list 中 ，浅拷贝 添加的是引用
List list3=new ArrayList();
list3.addAll(list);
// 将列表中所有位置，都用相同的元素填充
Collections.fill(newList,2); // [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
Collections.replaceAll(list,2,-2); // [9, 7, 6, -2, 6, 4, 7, 8, 6, 3, 4]
Integer[] sub={2,2};
List subList=Arrays.asList(sub);
// 查找 子列表 首次出现时的索引
i=Collections.indexOfSubList(newList,subList); // 0
// 查找 子列表 最后一次出现时的索引
i=Collections.lastIndexOfSubList(newList,subList);// 9
// 交换 给定两个索引的元素 位置
Collections.swap(list,0,1); // [7, 9, 6, -2, 6, 4, 7, 8, 6, 3, 4]
// 逆置 列表中的元素
Collections.reverse(list); // [4, 3, 6, 8, 7, 4, 6, -2, 6, 9, 7]
// 旋转列表中的元素，将所有元素向右循环移动 d(2) 个位置， 即 i 移动到 (i+d)%list.size() 位置
Collections.rotate(list,2); // [9, 7, 4, 3, 6, 8, 7, 4, 6, -2, 6]
// 元素出现的次数
i=Collections.frequency(list,6); // 3
// 两个集合是否有没有交集 ，两个集合没有共同元素 返回 true
boolean b=Collections.disjoint(list,newList);
Collection<Integer> collection=list;
// 条件删除
collection.removeIf(t -> { return t<0?true:false;}); // [9, 7, 4, 3, 6, 8, 7, 4, 6, 6]
// 自定义对列表所有元素进行操作
list.replaceAll( t->{ return -t;}); // [-9, -7, -4, -3, -6, -8, -7, -4, -6, -6]
System.out.println(list);
- 按批量作
List<Integer> list=new ArrayList<>();
Integer[] nums={9,7,6,2,6,4,7,8,6,3,4};
//list=Arrays.asList(nums); // 涉及到 add remove 不能使用！
for (Integer num : nums) { list.add(num);}
Collection collection=list;
Collection collection2=new ArrayList();
collection2.add(6);
// 移除所有 出现在 collection2 的元素
collection.removeAll(collection2); // [9, 7, 2, 4, 7, 8, 3, 4]
// 移除所有 没有出现在 collection2 的元素
collection.retainAll(collection2); // []
// 添加所有 collection2 的元素，浅拷贝
collection.addAll(collection2); // [6]
System.out.println(collection);
- 集合和数组转换
Integer[] nums={1,3,5,4,8};
// 数组转换列表，详情参考视图和包装
List<Integer> list=Arrays.asList(nums);
// 列表转换数组，
// 数组类型不能强制转换，Object数组 类 和 Integer数组 类 是无法互相转换的
// 这样不方便操作， (Integer)obejects[0]
Object[] objects=list.toArray();
Integer[] nums2;
// 可以传入一个指定类型的数组 将返回同类型数组
// 如果传入数组长度不够，会新建一个同类型数组并返回
nums2=list.toArray(new Integer[0]);
// 如果传入数组长度够用，则直接填入到这个数组中并返回
nums2=list.toArray(new Integer[10]);
nums2=list.toArray(new Integer[list.size()]);
网友评论