java集合

list:
removeIf()
replaceAll(String::toLowerCase)
批操作
coll1.removeAll(coll2) : 从coll1删除coll2中有的元素
coll1.retainAll(coll2) : 交集，共有的元素 intersection

集合转数组
list.toArray() 返回的是Object数组
list,toArray(new String[0]) : 传入指定类型的数组，返回指定类型的集合

Collection接口扩展了 Iterable 接口，所以集合可以forEach遍历

Iterator接口：

iterator.forEachRemaining(Consumer)
iterator.remove() // 移除next跨过去的元素
iterator.next() 返回跨过去的元素

	List list = Arrays.asList("a", "b", "c");
	Iterator iterator = list.iterator();
	// 遍历
	while (iterator.hasNext()){
	System.out.println(iterator.next()+"-");
	}
	// 遍历2
	iterator.forEachRemaining(System.out::println);

注意:

• 不能连续remove(),只能next()一次，remove()一次
• 并发修改异常： 如果一个迭代器发现他的集合被另一个迭代器修改了，或者是被该集合自身的某个方法修改了，就会抛出一个 ConcurrentModificationException
• iterator只会在原有的基础上遍历，如果在遍历过程中add()进去的对象，不会参加遍历

ListIterator接口

interface ListIterator extends Iterator
可以反向遍历链表 previous() hasPrevious()
查看有序集合索引 nextIndex() previousIndex()

LinkedList接口

addFirst()
addLast()
getFirst()
getLast()
removeFirst()
removeLast()

散列集

当集合中的元素很多，，要找某个指定的元素，就会需要很长时间，使用散列表
散列表(hash table)
散列码(hash code)
散列冲突(hash collision)
散列表： 由数组和链表实现，，每个列表称之为桶(bucket)…将桶数设置为预计元素个数的 75%~150%,标准类库使用的桶数是2的幂,默认为16,为表大小提供的任何值都将自动地转换成2的下一个幂值
装填因子(load factor)
再散列(rehashed) : 当表中填满了规定的装载因子那么多之后，会进行扩容，新表的桶数是原来的两倍，并且将原来的hash表，重新散列，放入新的表中

映射

映射(map): 我们知道某些关键信息，希望查找与之相关联的元素
散列映射
树映射
map遍历：

• keySet
• EntrySet
• forEach

getOrDefault(key,默认值)
putAll(Map)
containsKey()
containsValue()

SortedMap接口

comparator() 返回比较器，如果使用Comparable返回null
firstKey()
lastKey()

注意：

• 更新映射条目
  当map中没有这个key时，值为null，，恰好你需要这个值做计算，
  解决办法：

  1. getOrDefault() 获取的时候设置默认值
  2. putIfAbsent() 如果不存在设置一个值
  3. merge(key,value,BiFunction接口) : value和BiFunction不能为null，，将BiFunction函数应用到key对应的值和传入的value上，并且将，函数计算的结果，和key关联起来

• hashmap中的set，只能remove(),不能add()

• 当表中找不到元素项，并且表已经相当满了。。我们可能希望，访问频率高的元素放在内存中，访问频率低的元素让他从数据库中查找。。重写removeEldestEntry(),每当方法返回true时，他就会去删除eldest最近最少使用的元素，，LinkedHashMap中的方法

   LinkedHashMap map = new LinkedHashMap(){
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {
                return this.size()>3;
            }
        };
        map.put("a",1);
        map.put("b",2);
        map.put("c",3);

        System.out.println(map);
        map.put("d",5);
        System.out.println(map);

compute(key,BiFunction) : 将函数应用到key 和 get(key) 上，并将返回的值与key关联起来
computeIfPresent(key,BiFunction) : 如果这个get(key) 存在，不为null，将函数应用到key和get(key)上，并将返回值与key关联
computeIfAbsent(key,Function接口)： 如果这个key映射的值缺席(为null)，将这个key应用到这个函数上，并且将返回值和key关联
replaceAll(BiFunction): 将所有映射条目都应用到这个函数
putIfAbsent(key,value): 如果这个key对应的value不存在，则将传入的value和key关联

 public void test04(){
        HashMap map = new HashMap<>();
//        map.put("a",map.getOrDefault("a",0)+1);
//        System.out.println(map);

//        // absent缺席
//        map.putIfAbsent("a",0);
//        map.put("a",map.get("a")+1);
//        System.out.println(map);

//        map.put("a","silly b");
        map.put("b","11");
//        map.merge("a",1,Integer::sum);
//        map.compute("a",(key,value)->{return key+" is "+value;});
//        map.computeIfPresent("a",(key,value)->{return key+" is "+value;});

//        map.computeIfAbsent("a",(item)->{
//            System.out.println(item);
//            return null;
//        });

//        map.replaceAll((key,value)->{return null;});
//        System.out.println(map);

//        Integer a = map.get("a");
//        System.out.println(Integer.parseInt(null));

        Object a = map.putIfAbsent("a", "123");
        System.out.println("a = " + a);
        System.out.println(map);

    }

WeakHashMap

如果某个对象只能由WeakReference 引用，垃圾回收器也会将其回收，但会将引用这个对象的弱引用放入一个队列，WeakHashMap 将周期性的检查队列

树集

树集是一个有序集合(sorted collection)
TreeSet 底层是 红黑树，，要使用树集，必须能够比较元素，必须实现Comparable接口，或者提供一个Comparator实例

SortedSet接口：

• first()
• last()

NavigableSet接口：

• higher(E value)
• lower()
• ceiling()
• floor()
• pollFirst()
• pollLast
• descendingIterator()

        TreeSet users = new TreeSet<>(Comparator.comparing(User::getName));
//        TreeSet users = new TreeSet<>();
        users.add(new User("cc",12));
        users.add(new User("aa",22));
        users.add(new User("bb",1));
        System.out.println(users);
        System.out.println(users.first());
        System.out.println(users.last());
        User aa = users.higher(new User("aa", 1));
        System.out.println("aa = " + aa);

public class User implements Comparable{
    String name;
    Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public int compareTo(User other) {
        // Integer.compare()
        int diff = Integer.compare(age, other.age);
        // compareTo()  依次比较每个字母
        return diff==0?name.compareTo(other.name):diff ;
    }
}

队列
Queue接口

add()
offer() 第一个满了会报错，第二个返回false
remove()
poll()
element()
peek()

Deque接口

addFirst()
addLast()
offerFirst()
offerLast()
removeFirst()
removeLast()
pollFirst()
pollLast()
getFirst()
getLast()
peekFirst()
peekLast()

PriorityQueue

优先队列：无论何时，调用remove方法，总会移除优先队列中最小的元素(习惯将1设置为“最高”优先级)。。。必须要实现Comparable或者Comparator接口

    public void test01(){
        PriorityQueue pq = new PriorityQueue<>();
        pq.add(LocalDate.of(2010,11,2));
        pq.add(LocalDate.of(2022,12,12));
        pq.add(LocalDate.of(2020,11,20));
        pq.add(LocalDate.of(1995,11,2));

        System.out.println("iterator over elements ...");
        for (LocalDate localDate : pq) {
            System.out.println(localDate);
        }
        System.out.println("removing elements ...");
        while (!pq.isEmpty()){
            System.out.println(pq.remove());
        }
    }

RandomAccess接口

标记接口： 为了避免对链表完成随机访问操作，这个接口用来测试一个特定的集合是否支持高效的随机访问

使用Map.Entry
new AbstractMap.SimpleImmutableEntry<>(first,second)

子范围

• 根据位置截取
  subList(from, to) 第一个索引包含，第二个不包含
• 根据排序顺序截取
  subSet(from, to)
  headSet(to)
  tailSet(from)

---

subMap(from, to)
headMap()
tailMap()

---

NavigableSet接口： 可以设置是否等于边界值
subSet(from, fromInclusive, to , toInclusive)
headSet()
tailSet()

不可修改的视图
Collections中有几个方法，可以生成集合的不可修改视图(unmodifiable view),这些视图对现有集合增加了一个运行时检查，如果试图发现对集合进行修改就抛出一个异常
访问器
更改器

同步视图
Collections.synchronizedMap(new HashMap())

检查型视图： 检查这个视图类型是否是你想要的类型，如果不是，会报错到指定的位置
Collections.checkedList(list , String.class)

排序
Collections.sort(比较器)
获取比较器 ： Comparator.reverseOrder()
Comparator.comparingDouble(Employee::salary).reversed()

    Comparator