Java常用

package kemuyi;

import com.sun.jmx.remote.internal.ArrayQueue;
import org.junit.Test;
import org.junit.experimental.theories.suppliers.TestedOn;

import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.stream.Collectors;

public class KS20220107_1 {

@Test
public void testStack() {
// Stack
Deque stack = new LinkedList<>(); // ArrayDeque
stack.push(1);
stack.push(2);
stack.peek();
stack.pop();
stack.isEmpty();
}

@Test
public void testQueue() {
// Queue
Queue queue = new LinkedList<>(); // ArrayDeque
queue.offer(1);
queue.add(2);

queue.poll();
queue.remove();
queue.isEmpty();

//Deque
Deque deque = new LinkedList<>(); // ArrayDeque
deque.offerFirst(1);
deque.offerFirst(2);
System.out.println("Deque:" + deque.poll()); // 2
}

@Test
public void testList() {
List students = Arrays.asList(
new Student(1, 24, 180),
new Student(2, 21, 170),
new Student(3, 24, 165));
Collections.sort(students, (o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
});
System.out.println(students);
}

@Test
public void testSet() {
Set hashSet = new HashSet<>();
hashSet.add(new Student(1, 24, 180));
hashSet.add(new Student(2, 21, 170));
hashSet.add(new Student(3, 24, 165));
// 对HashSet排序的话，必须返回LinkedHashSet
Set collect = hashSet.stream().sorted((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
}).collect(Collectors.toCollection(LinkedHashSet::new));
System.out.println("HashSet排序:" + collect);

// LinkedHashSet容器中元素的顺序和插入顺序保持一致
Set linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(new Student(1, 24, 180));
linkedHashSet.add(new Student(2, 21, 170));
linkedHashSet.add(new Student(3, 24, 165));

linkedHashSet = linkedHashSet.stream().sorted((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
}).collect(Collectors.toCollection(LinkedHashSet::new));
System.out.println("LinkedHashSet排序:" + linkedHashSet);

// TreeSet可以在构造的时候传入比较器，也可以和上面方式一样stream遍历sorted()
Set treeSet = new TreeSet<>((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
});
treeSet.add(new Student(1, 24, 180));
treeSet.add(new Student(2, 21, 170));
treeSet.add(new Student(3, 24, 165));
System.out.println("TreeSet排序:" + treeSet);

treeSet.removeIf(student -> student.equals(new Student(1, 24, 180)));
System.out.println("TreeSet遍历删除:" + treeSet);
}

@Test
public void testMap() {
Map<String, Integer> strMap = new HashMap<>();
strMap.put("A", 3);
strMap.put("B", 5);
strMap.put("C", 1);
strMap.put("E", 9);
strMap.put("D", 1);
System.out.println("HashMap key默认升序排列：" + strMap);

strMap = strMap.entrySet().stream()
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.collect(Collectors.toMap(entry -> entry.getKey(), entry -> entry.getValue(), (k1, k2) -> k2, LinkedHashMap::new));
System.out.println("HashMap 按Value降序排列:" + strMap);

strMap = strMap.entrySet().stream()
.sorted(Map.Entry.comparingByValue())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (k1, k2) -> k2, LinkedHashMap::new));
System.out.println("HashMap 按Value升序排列:" + strMap);
System.out.println();
Map<Integer, Student> map = new HashMap<>();
map.put(1, new Student(1, 24, 180));
map.put(3, new Student(3, 24, 165));
map.put(2, new Student(2, 21, 170));
System.out.println("原始HashMap数据：" + map);

map = map.entrySet().stream()
.sorted(Map.Entry.comparingByValue((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
}))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> x, LinkedHashMap::new));
System.out.println("HashMap 按value排序：" + map);

// key:student value:count
Map<Student, Integer> map2 = new HashMap<>();
map2.put(new Student(1, 24, 180), 12);
map2.put(new Student(3, 24, 165), 8);
map2.put(new Student(2, 21, 170), 9);
map2 = map2.entrySet().stream()
.sorted(Map.Entry.comparingByKey((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
}))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> x, LinkedHashMap::new));
System.out.println("HashMap 按key排序：" + map2);

map2.entrySet().removeIf(entry -> entry.getKey().equals(new Student(3, 24, 165)));
System.out.println("HashMap 遍历删除：" + map2);
}

@Test
public void testTreeMap() {
TreeMap<Integer, List> treeMap = new TreeMap<>();
treeMap.computeIfAbsent(4, k -> new LinkedList<>()).add(new Student(1, 24, 180));
treeMap.computeIfAbsent(8, k -> new LinkedList<>()).add(new Student(3, 24, 165));
treeMap.computeIfAbsent(12, k -> new LinkedList<>()).add(new Student(2, 21, 170));

System.out.println(treeMap.ceilingKey(5));
System.out.println(treeMap.floorKey(5));
System.out.println(treeMap.firstKey());

treeMap.ceilingEntry(5);
treeMap.floorEntry(5);

treeMap.computeIfPresent(8, (key, students) -> {
students.add(new Student(1, 1, 1));
return students;
});

// 常用法
if (treeMap.containsKey(8)) {
treeMap.get(8).add(new Student(1, 1, 1));
} else {
treeMap.computeIfAbsent(8, k -> new LinkedList<>()).add(new Student(3, 3, 3));
}

// 遍历
treeMap.forEach((k, v) -> System.out.println(k + "：" + v));

Collection<List> values = treeMap.values();
}

@Test
public void testPQ() {
Map<Integer, Student> map = new HashMap<>();
map.put(1, new Student(1, 24, 180));
map.put(3, new Student(3, 24, 165));
map.put(2, new Student(2, 21, 170));

PriorityQueue priorityQueue = new PriorityQueue<>((o1, o2) -> {
if (o1.age == o2.age) {
return o1.height - o2.height;
}
return o1.age - o2.age;
});
priorityQueue.addAll(map.values());

}

public static void main(String[] args) {
}
}

class Student {
public int id;
public int age;
public int height;

public Student(int id, int age, int height) {
this.id = id;
this.age = age;
this.height = height;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id && age == student.age && height == student.height;
}

@Override
public int hashCode() {
return Objects.hash(id, age, height);
}

@Override
public String toString() {
return "Student{" +
"id=" + id +
", age=" + age +
", height=" + height +
'}';
}
}