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 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 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 tailSet(E fromElement);//返回从fromElement开始的，包括fromElement
SortedSet headSet(E toElement);//返回toElement之前的，不包括toElement
SortedSet 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 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 {
    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 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 {

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


TreeSet 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 tailMap(E fromKey);//获取从fromKey开始的比其大的SortedMap，包括fromKey
SortedMap headMap(E toKey);//获取到toKey结束的比其小的SortedMap，不包括toKey
SortedMap subMap(E fromKey, E toKey);//获取从fromKey开始的比其大的toKey结束的比其小的SortedMap，包括fromKey，不包括toKey

NavigableMap

Map.Entry firstEntry();
Map.Entry lastEntry();

Map.Entry poolFirstEntry();//获取到第一个entry，并从map中去掉
Map.Entry poolLastEntry();//获取到最后一个entry，并从map中去掉

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

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

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

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

NavigableMap desendingMap();//获取反转的navigableMap
NavigableSet desendingKeySet();//获取反转的KeySet
NavigableSet navigableKeySet();//获取正常的keySet

NavigableMap tailMap(E fromKey, boolean incl);//获取从fromKey开始的比其大的SortedMap根据incl值，是否包括fromKey
NavigableMap headMap(E toKey, boolean incl);//获取到toKey结束的比其小的SortedMap根据inclu值，是否包括toKey
//获取从fromKey开始的比其大的toKey结束的比其小的SortedMap，根据两个incl值，是否包括fromKey，toKey
NavigableMap 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 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 map =new HashMap<>();
    map.put("key","value");
    map.put("key1","value1");
    Set> 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 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 hMap = map1.headMap("3333");
hMap.forEach((k,v)-> System.out.println(k+" | "+v));
1111 | def
2222 | ghi

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

SortedMap 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 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 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 singleton = Collections.singleton(1);
List one = Collections.singletonList("one");
Map one1 = Collections.singletonMap(1, "one");
//默认空的，以下均不可修改
List

JAVA基础知识之集合

你可能感兴趣的:(java集合)