set的简单使用

  1. // 如果我们只需要存储不重复的key，并不需要存储映射的value，那么就可以使用Set。主要应用在查重方面
  3. public class Collection2{
  4.     public static void main(String[] args) {
  5.         Set<String> set = new HashSet<>();
  6.         System.out.println(set.add("abc"));  // true
  7.         System.out.println(set.add("xyz"));  // true
  8.         System.out.println(set.add("xyz"));  // false 不能添加相同的字符串
  9.         System.out.println(set.contains("xyz")); // true
  10.         System.out.println(set.contains("XYZ")); // false 区分大小写
  11.         System.out.println(set.remove("hello")); // false 不能移除不存在的数据
  13.         System.out.println(set.size()); // 2 计算长度
  14.     }
  15. }
  17. // 最常用的set实现类是HashSet,实际上，HashSet仅仅是对HashMap的一个简单封装，
  19. // HashSet是无序的，因为它实现了Set接口，并没有实现SortedSet接口；
  20. // TreeSet是有序的，因为它实现了SortedSet接口

Queue的使用

  1. // 队列是常用的数据结构之一，遵循的规则是：“先进先出”
  3. public class Collection2{
  4.     public static void main(String[] args) {
  5.         Queue<String> q = new LinkedList<>();
  6.         // 添加3个元素到队列
  7.         q.offer("apple");
  8.         q.offer("shuai");
  9.         q.offer("xiaoshuai");
  10.         // 从队列取出元素
  11.         /* 
  12.         *  .offer()  向队列中添加数据，不要添加null进入数据
  13.         *  .poll()  取出元素并且从队列中删除，如果取不到数据则返回null
  14.         *  .peek()  取出元素但不从队列中删除,如果连续使用则获取的是同一个数据
  15.         *  .size()  查看当前队列的长度
  16.         *  */
  17.         System.out.println(q.poll());   // apple
  18.         System.out.println(q.poll());  // shuai
  19.         System.out.println(q.peek());  // xiaoshuai
  20.         System.out.println(q.size());  // 返回当前队列的长度
  21.         System.out.println(q.poll());  // 队列中取不到数据返回null
  22.     }
  23. }

PriorityQueue的使用

  1. Queue<String> q = new PriorityQueue<>();
  2. // 默认是按照字符串进行比较，小的先出队列
  4. // 模拟VIP用户可以优先办理业务
  5. // 需要我们自定义Comparable接口
  7. import java.util.Comparator;
  8. import java.util.PriorityQueue;
  9. import java.util.Queue;
  11. public class Collection2{
  12.     public static void main(String[] args) {
  13.         Queue<User> q = new PriorityQueue<>(new UserComparator());
  14.         q.offer(new User("Bob","A",1));
  15.         q.offer(new User("Alice","A",2));
  16.         q.offer(new User("xiaoshuai","A",10));
  17.         q.offer(new User("shuai","V",1));
  18.         System.out.println(q.poll());  // shuai/V1
  19.         System.out.println(q.poll());  // Bob/A1
  20.         System.out.println(q.poll());  // Alice/A2
  21.         System.out.println(q.poll());  // null
  22.         System.out.println(q.poll());  // null
  23.     }
  24. }
  26. class UserComparator implements Comparator<User>{
  27.     public int compare(User u1, User u2){
  28.         if (u1.number.charAt(0) == u2.number.charAt(0)){
  29.             // 如果两人的号都是A开头或者都是V开头，比较号的大小
  30.             return u1.number1.compareTo(u2.number1);
  31.         }
  32.         if (u1.number.charAt(0) == 'V'){
  33.             // u1的号码是V开头，优先级高
  34.             return -1;
  35.         }else {
  36.             return 1;
  37.         }
  38.     }
  39. }
  42. class User{
  43.     public final String name;
  44.     public final String number;
  45.     public final Integer number1;
  47.     public User(String name , String number , Integer number1){
  48.         this.name = name;
  49.         this.number = number;
  50.         this.number1 = number1;
  51.     }
  53.     public String toString(){
  54.         return name + "/" + number + number1;
  55.     }
  56. }

Deque(双端队列的使用)

  1. // 两端都能进或者出数据，我们称之为双端队列（Deque）
  2. // Deque接口实际上扩展自Queue;
  4. // 声明一个双端队列
  5. Deque<String> deque = new LinkedList<>();
  6. deque.offerLast("A");  // 从队尾插入数据
  7. deque.offerFirst("A"); // 从队首插入数据
  8. System.out.println(deque.pollLast()); // 从队尾删除数据
  9. System.out.println(deque.pollFirst()); // 从队首删除数据
  10. // 如果队列中没有数据，返回null

使用Stack（栈）

  1. // 栈是常用的数据结构之一，遵循的规则是：“先进后出”
  3. /*
  4. Stack只有入栈和出栈的操作：
  5.     把元素压栈：push(E)；
  6.     把栈顶的元素“弹出”：pop()；
  7.     取栈顶元素但不弹出：peek()。
  9. 注意：我们用Deque可以实现Stack的功能；当Deque作为Stack使用时，我们调用上面方法去实现
  11. 为什么Java的集合类没有单独的Stack接口呢？因为有个遗留类名字就叫Stack，出于兼容性考虑，所以没办法创建Stack接口，只能用Deque接口来“模拟”一个Stack了。
  12. */
  14. // Stack的在计算机中的作用非常广泛