关于java:JAVA基础知识之集合

最近找了之前本人写的 JAVA 基础知识的汇合局部，整顿了进去，分享给大家，货色很简略。
list 转换为数组

Object[] objArray = list.toArray();
// 转换为指定类型数组
MyClass[] a1 = list.toArray(new MyClass[0]);
MyClass[] a2 = new MyClass[3];
MyClass[] a3 = list.toArray(a2);

数组转换为 list

Collection<MyClass> listCol = Arrays.asList(a3);
list.forEach(e-> System.out.println("asList:"+e.label));

Collection 根本汇合
List 列表汇合，保护某些订单概念的汇合（ArrayList,LinkedList）
Queue 队列汇合，存在头元素，能够获取下一个。(ArrayDuque,PriorytyQueue)
Set 汇合，没有反复的汇合 (HashSet,TreeSet,EnumSet)
SortedSed 汇合，排好序的 Set 汇合
Iterator 写法

Iterator<Product> iterator = collection.iterator();
while(iterator.hasNext()){Product next = iterator.next();
    System.out.println(next);
}

ArrayList 汇合，能够随机取任何指定 index 的汇合，然而随机插入不好，例如在 200 和 201 个之间插入一个
LinkList 汇合，双向链表和队列组成，在两个成员之间插入十分不便，然而随机拜访很慢，所以跳到第 150 个元素，第 300 个元素效率很低。
HashSet，哈希表的汇合，应用每个对象实例的哈希值
TreeSet，树汇合，实现均衡二叉树的汇合，每一个元素都是惟一的，批改或者搜寻很慢，然而依照排序程序拜访成员很容易。

SortedSet 接口

E first();
E last();

SortedSet<E> tailSet(E fromElement);// 返回从 fromElement 开始的，包含 fromElement
SortedSet<E> headSet(E toElement);// 返回 toElement 之前的，不包含 toElement
SortedSet<E> subSet(E fromElement,E toElement);// 返回从 fromElement 开始的 toElement 之前的，包含 fromElement，不包含 toElement

NavigableSet 接口

E lower(E e);// 返回此 set 中小于给定元素的最大元素
E higher(E e);// 返回此 set 中大于给定元素的最小元素
E floor(E e);// 返回此汇合中小于或等于给定元素的最大元素
E ceiling(E e);// 返回此 set 中大于或等于给定元素的最小元素
E poolFirst();// 检索并删除第一个最小元素。E poolLast();// 检索并删除最初一个最高元素 

Queue 接口

boolean offer(E e);// 容量满了，返回异样，只有增加胜利才返回 true
boolean add(E e);// 容量满了增加失败时候返回 false，增加胜利返回 true

E remove();// 取出并删除队列的元素，如果队列为空返回异样，有值则返回值
E poll();// 如果队列为空返回 null，有值则返回值

E element();// 取出最初一个元素，但并不从队列里删除，没有值则返回异样
E peek();// 取出最初一个元素，但并不从队列里删除，没有值则返回 null

Deque

boolean offerFirst(E e);
boolean offerLast(E e);
boolean addFirst(E e);
boolean addLast(E e);
E removeFirst();
E removeLast();
E pollFirst();
E pollLast();

void push(E e);//LIFO 的退出办法
E pop();//LIFO 的取出办法 

PriorytiQueue

public class PriorityQueueTest {private static final Queue<User> queue = new PriorityQueue<>(Comparator.comparing(User::getId));
    public static void main(String[] args) {queue.add(new User(3L));
        queue.add(new User(1L));
        queue.add(new User(2L));
        User user;
        while((user = queue.poll())!=null){System.out.println(user);
        }
    }
}
// 输入
User{id=1}
User{id=2}
User{id=3}

Map 包含，HashMap，TreeMap，EnumMap

汇合排序的两种实现
1. 实体类通过实现 Comparable 接口排序

public class MyClass implements Comparable<MyClass> {
    String label,value;
    public MyClass(String label,String value){
        this.label = label;
        this.value = value;
    }

    @Override
    public boolean equals(Object o){MyClass other = (MyClass) o;
        return value.equalsIgnoreCase(other.value);
    }

    @Override
    public String toString() {return label + "|" + value;}

    @Override
    public int compareTo(MyClass other) {return value.compareToIgnoreCase(other.value);
    }
}


TreeSet<MyClass> tree = new TreeSet<>();
tree.add(new MyClass("2222","ghi"));
tree.add(new MyClass("3333","abc"));
tree.add(new MyClass("1111","def"));

tree.forEach(e-> System.out.println(e));

3333 | abc
1111 | def
2222 | ghi

2. 通过创立比拟器实现 Comparator 接口排序

public class MyComparator implements Comparator<MyClass> {

    @Override
    public int compare(MyClass x, MyClass y) {return x.label.compareToIgnoreCase(y.label);
    }
}


TreeSet<MyClass> tree2 = new TreeSet<>(new MyComparator());
tree2.add(new MyClass("2222","ghi"));
tree2.add(new MyClass("3333","abc"));
tree2.add(new MyClass("1111","def"));

tree2.forEach(e-> System.out.println(e));

1111 | def
2222 | ghi
3333 | abc

Map 根底 Map 汇合
SortedMap 接口 依照 key 排序的 Map 汇合
NavigableMap 接口
HashMap 通用 Map 汇合
TreeMap，自均衡的树汇合，依照 key 排序，能够依照实现 Comparable 接口排序或者创立比拟器实现 Comparator 接口。
LinkedHashMap

SortedMap

K firstKey();
K lastkey();
SortedMap<K,V> tailMap(E fromKey);// 获取从 fromKey 开始的比其大的 SortedMap，包含 fromKey
SortedMap<K,V> headMap(E toKey);// 获取到 toKey 完结的比其小的 SortedMap，不包含 toKey
SortedMap<K,V> subMap(E fromKey, E toKey);// 获取从 fromKey 开始的比其大的 toKey 完结的比其小的 SortedMap，包含 fromKey，不包含 toKey

NavigableMap

Map.Entry<K,V> firstEntry();
Map.Entry<K,V> lastEntry();

Map.Entry<K,V> poolFirstEntry();// 获取到第一个 entry，并从 map 中去掉
Map.Entry<K,V> poolLastEntry();// 获取到最初一个 entry，并从 map 中去掉

Map.Entry<K,V> lowerEntry(K key);// 获取严格小于 key 的最大的 Entry
Map.Entry<K,V> higherEntry(K key);// 获取严格大于 key 的最小的 Entry

K lowerKey(K key);// 获取严格小于 key 的最大的 key
K higherKey(K key);// 获取严格大于 key 的最小的 key

Map.Entry<K,V> floorEntry(K key);// 获取严格小于等于 key 的最大的 Entry
Map.Entry<K,V> ceilingEntry(K key);// 获取严格大于等于 key 的最小的 Entry

K floorKey(K key);// 获取严格小于等于 key 的最大的 key
K ceilingKey(K key);// 获取严格大于等于 key 的最小的 key

NavigableMap<K,V> desendingMap();// 获取反转的 navigableMap
NavigableSet<K> desendingKeySet();// 获取反转的 KeySet
NavigableSet<K> navigableKeySet();// 获取失常的 keySet

NavigableMap<K,V> tailMap(E fromKey, boolean incl);// 获取从 fromKey 开始的比其大的 SortedMap 依据 incl 值，是否包含 fromKey
NavigableMap<K,V> headMap(E toKey, boolean incl);// 获取到 toKey 完结的比其小的 SortedMap 依据 inclu 值，是否包含 toKey
// 获取从 fromKey 开始的比其大的 toKey 完结的比其小的 SortedMap，依据两个 incl 值，是否包含 fromKey，toKey
NavigableMap<K,V> subMap(E fromKey, boolean fromIncl,E toKey, boolean toIncl);

罕用办法
put，减少 key 和 value
putIfAbsent，如果没有该 key，则减少 key 和 value，如果有则不放
get 获取 key 的值，如果没有 key 则返回 null
getOrDefault 获取 key 的值，如果没有则返回咱们提供的默认的 value
values()，返回所有 value 的汇合，获取到的汇合删除掉其中的一个 value 值后，整个 map 中也会删掉该 key-value 值，但不能像 value 汇合中增加值，会报 exception
keySet()，返回所有 key 的汇合，获取到的汇合删除掉其中的一个 key 值后，整个 map 中也会删掉该 key-value 值，但不能像 key 汇合中增加值，会报 exception
entrySet()，返回 map 的 key-value 汇合，能够循环输入，也能够批改 value 值
forEach，lambda 表达式的循环每一个条目
replaceAll，通过 lambda 表达式并批改每个 key 关联的值

Map<String,String> map = new HashMap<>();
map.put("2222","ghi");
map.put("3333","abc");
map.put("1111","def");

String s1 = map.get("3333");
System.out.println("s1:"+s1);
s1:abc

String s2 =map .get("9999");
System.out.println("s2:"+s2);
s2:null

String s3= map.getOrDefault("9999","xyz");
System.out.println("s3:"+s3);
s3:xyz

map.forEach((k,v)-> System.out.println(k+"|"+v));

2222 | ghi
3333 | abc
1111 | def
map.replaceAll((k,v)->v.toUpperCase());
map.forEach((k,v)-> System.out.println(k+"|"+v));
2222 | GHI
3333 | ABC
1111 | DEF

public static void main(String[] args) {Map<String,Object> map =new HashMap<>();
    map.put("key","value");
    map.put("key1","value1");
    Set<Map.Entry<String, Object>> entries = map.entrySet();
    entries.forEach(entry-> System.out.println(entry.getKey()+"->"+entry.getValue()));
    entries.forEach(entry-> entry.setValue("tttt"));
    System.out.println(map.toString());
}
// 输入
key1->value1
key->value
{key1=tttt, key=tttt}

SortedMap 办法
firstKey 返回第一个 key
lastKey 返回最初一个 key
headMap 返回另一个 map，其中蕴含所有 key 小于我传入的指定 key，不蕴含我传入的 key
tailMap 返回另一个 map，其中蕴含所有 key 大于我传入的指定 key，蕴含我传入的 key
subMap，返回一个 map，蕴含所有大与等于开始 key，小于完结 key 的

SortedMap<String,String> map1 = new TreeMap<>();
map1.put("2222","ghi");
map1.put("3333","abc");
map1.put("1111","def");
map1.put("6666","xyz");
map1.put("4444","mno");
map1.put("5555","pqr");

map1.forEach((k,v)-> System.out.println(k+"|"+v));
1111 | def
2222 | ghi
3333 | abc
4444 | mno
5555 | pqr
6666 | xyz

SortedMap<String,String> hMap = map1.headMap("3333");
hMap.forEach((k,v)-> System.out.println(k+"|"+v));
1111 | def
2222 | ghi

SortedMap<String,String> tMap = map1.tailMap("3333");
tMap.forEach((k,v)-> System.out.println(k+"|"+v));
3333 | abc
4444 | mno
5555 | pqr
6666 | xyz

SortedMap<String,String> subMap = map1.subMap("2222","5555");
subMap.forEach((k,v)-> System.out.println(k+"|"+v));
2222 | ghi
3333 | abc
4444 | mno

Collection 办法，rotate(List<?> list, int distance) 列表中最初一个元素并将其挪动 distance 个地位，负数向后，正数向前挪动

List<User> list = new ArrayList<>();
User user1 = new User(1L);
User user2 = new User(2L);
User user3 = new User(3L);
list.add(user1);
list.add(user2);
list.add(user3);
Collections.rotate(list,1);
System.out.println(list);
// 输入
[User{id=3}, User{id=1}, User{id=2}]

shuffle 随机排列列表元素

Collections.shuffle(list)；System.out.println(list);
// 输入
[User{id=2}, User{id=1}, User{id=3}]

sort 排序

List<User> list = new ArrayList<>();
User user1 = new User(1L);
User user2 = new User(2L);
User user3 = new User(3L);
list.add(user1);
list.add(user3);
list.add(user2);
Collections.sort(list,Comparator.comparing(User::getId));
System.out.println(list);
// 输入
[User{id=1}, User{id=2}, User{id=3}]
//JDK1.8 也能够另外写法，list 自带比拟
list.sort(Comparator.comparing(User::getId));

单例模式

Set<Integer> singleton = Collections.singleton(1);
List<String> one = Collections.singletonList("one");
Map<Integer, String> one1 = Collections.singletonMap(1, "one");
// 默认空的，以下均不可批改
List<Object> objects = Collections.emptyList();
Map<Object, Object> objectObjectMap = Collections.emptyMap();
Set<Object> objects1 = Collections.emptySet();

//unmodifiableList 操作后的 one2 的 list 也不可批改
List<User> one2 = Collections.unmodifiableList(list);

User min = Collections.min(list,Comparator.comparing(User::getId));
System.out.println(min);
// 输入
1