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
阅读 181

程序员一枚,也爱读书,也爱理财,还喜欢把学到的读到的总结出来写点东西,写的不难,希望大家喜欢。

3 声望
0 粉丝
0 条评论

程序员一枚,也爱读书,也爱理财,还喜欢把学到的读到的总结出来写点东西,写的不难,希望大家喜欢。

3 声望
0 粉丝
文章目录
宣传栏