Home > Article > Java > Java stack and queue instance analysis

Java stack and queue instance analysis

王林forward: 2023-05-10 16:40:151328browse

Stack

package com.yuzhenc.collection;

import java.util.Stack;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 15:41:36
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test26 {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.add("A");
        stack.add("B");
        stack.add("C");
        stack.add("D");
        System.out.println(stack);//[A, B, C, D]
        //判断栈是否为空
        System.out.println(stack.empty());//false
        //查看栈顶元素，不会移除
        System.out.println(stack.peek());//D
        System.out.println(stack);//[A, B, C, D]
        //查看栈顶元素，并且移除，即出栈（先进后出）
        System.out.println(stack.pop());//D
        System.out.println(stack);//[A, B, C]
        //入栈，和add方法执行的功能一样，就是返回值不同
        System.out.println(stack.push("E"));//返回入栈的元素 E
        System.out.println(stack);//[A, B, C, E]
    }
}

Queue

Blocking Queue

ArrayBlockingQueue : Does not support simultaneous reading and writing operations, the bottom layer is based on arrays;
LinkedBlockingQueue: Supports simultaneous reading and writing operations, high efficiency under concurrent conditions, the bottom layer is based on linked lists ;

package com.yuzhenc.collection;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 16:00:22
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test27 {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //添加元素
        //不可以添加null，报空指针异常
        //arrayBlockingQueue.add(null);
        //arrayBlockingQueue.offer(null);
        //arrayBlockingQueue.put(null);

        //正常添加元素
        System.out.println(arrayBlockingQueue.add("Lili"));//true
        System.out.println(arrayBlockingQueue.offer("Amy"));//true
        arrayBlockingQueue.put("Nana");//无返回值

        //队列满的情况下添加元素
        //arrayBlockingQueue.add("Sam");//报非法的状态异常
        //设置最大注阻塞时间，如果时间到了队列还是满的，就不再阻塞了
        arrayBlockingQueue.offer("Daming", 3,TimeUnit.SECONDS);
        System.out.println(arrayBlockingQueue);//[Lili, Amy, Nana]
        //真正阻塞的方法，如果队列一直是满的，就一直阻塞
        //arrayBlockingQueue.put("Lingling");//运行到这永远走不下去了，阻塞了

        //获取元素
        //获取队首元素不移除
        System.out.println(arrayBlockingQueue.peek());//Lili
        //出队，获取队首元素并且移除
        System.out.println(arrayBlockingQueue.poll());//Lili
        System.out.println(arrayBlockingQueue);//[Amy, Nana]
        //获取队首元素，并且移除
        System.out.println(arrayBlockingQueue.take());//Amy
        System.out.println(arrayBlockingQueue);//[Nana]

        //清空元素
        arrayBlockingQueue.clear();
        System.out.println(arrayBlockingQueue);//[]

        System.out.println(arrayBlockingQueue.peek());
        System.out.println(arrayBlockingQueue.poll());
        //设置阻塞事件，如果队列为空，返回null，时间到了以后就不阻塞了
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
        //真正的阻塞，队列为空
        //System.out.println(arrayBlockingQueue.take());//执行到这里走不下去了
    }
}

SynchronousQueue: Conveniently and efficiently transfer data between threads without causing data contention in the queue;

package com.yuzhenc.collection;

import java.util.concurrent.SynchronousQueue;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:06:47
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test28 {
    public static void main(String[] args) {
        SynchronousQueue sq = new SynchronousQueue();
        //创建一个线程，取数据：
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        System.out.println(sq.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        //搞一个线程，往里面放数据：
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    sq.put("aaa");
                    sq.put("bbb");
                    sq.put("ccc");
                    sq.put("ddd");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

PriorityBlockingQueue: Priority blocking queue;
Unbounded queue, no length limit, but when you do not specify the length, the default The initial length is 11, which can also be specified manually. Of course, as data continues to be added, the bottom layer (the bottom layer is the array Object[]) will automatically expand. The program will not end until all the memory is consumed, resulting in an OutOfMemoryError memory overflow;
Null elements cannot be placed, and incomparable objects are not allowed (resulting in throwing ClassCastException). The object must implement an internal comparator or an external comparator;

package com.yuzhenc.collection;

import java.util.concurrent.PriorityBlockingQueue;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:16:56
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test29 {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Human> priorityBlockingQueue = new PriorityBlockingQueue<>();
        priorityBlockingQueue.put(new Human("Lili",25));
        priorityBlockingQueue.put(new Human("Nana",18));
        priorityBlockingQueue.put(new Human("Amy",38));
        priorityBlockingQueue.put(new Human("Sum",9));
        //没有按优先级排列
        System.out.println(priorityBlockingQueue);//[Human{name=&#39;Sum&#39;, age=9}, Human{name=&#39;Nana&#39;, age=18}, Human{name=&#39;Amy&#39;, age=38}, Human{name=&#39;Lili&#39;, age=25}]
        //出列的时候按优先级出列
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Sum&#39;, age=9}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Nana&#39;, age=18}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Lili&#39;, age=25}
        System.out.println(priorityBlockingQueue.take());//Human{name=&#39;Amy&#39;, age=38}
    }
}

class Human implements Comparable <Human> {
    String name;
    int age;

    public Human() {}

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Human{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", age=" + age +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Human o) {
        return this.age-o.age;
    }

DelayQueue: DelayQueue is an unbounded BlockingQueue, used to place objects that implement the Delayed interface, where The object can only be taken from the queue when it expires;
When the producer thread calls a method such as put to add an element, the compareTo method in the Delayed interface will be triggered. Sorting is performed, which means that the order of the elements in the queue is sorted by expiration time, not the order in which they were entered into the queue. The element at the head of the queue is the earliest to expire, and the later it expires, the later it expires;
The consumer thread checks the element at the head of the queue. Note that it is checking, not taking out. Then call the element's getDelay method. If the value returned by this method is less than 0 or equal to 0, the consumer thread will take out the element from the queue and process it. If the value returned by the getDelay method is greater than 0, the consumer thread will take out the element from the head of the queue after the time value returned by wait. At this time, the element should have expired;
cannot be The null element is placed in this queue;
What can DelayQueue do

Taobao order business: If thirty after placing the order The order will be automatically canceled if there is no payment within minutes;
Are you hungry? Order notification: A text message notification will be sent to the user 60 seconds after the order is placed successfully;
Close idle connections. In the server, there are many client connections, which need to be closed after being idle for a period of time;
caching. Objects in the cache need to be removed from the cache after their idle time has expired;
Task timeout processing. When the network protocol sliding window requests reactive interaction, handle timeout unresponsive requests, etc.;

package com.yuzhenc.collection;

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 21:43:32
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test30 {
    //创建一个队列：
    DelayQueue<User> dq = new DelayQueue<>();
    //登录游戏：
    public void login(User user){
        dq.add(user);
        System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]已经登录，预计下机时间为：" + user.getEndTime() );
    }
    //时间到，退出游戏，队列中移除：
    public void logout(){
        //打印队列中剩余的人：
        System.out.println(dq);
        try {
            User user = dq.take();
            System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]上机时间到，自动退出游戏");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //获取在线人数：
    public int onlineSize(){
        return dq.size();
    }
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建测试类对象：
        Test30 test = new Test30();
        //添加登录的用户：
        test.login(new User(1,"张三",System.currentTimeMillis()+5000));
        test.login(new User(2,"李四",System.currentTimeMillis()+2000));
        test.login(new User(3,"王五",System.currentTimeMillis()+10000));
        //一直监控
        while(true){
            //到期的话，就自动下线：
            test.logout();
            //队列中元素都被移除了的话，那么停止监控，停止程序即可
            if(test.onlineSize() == 0){
                break;
            }
        }
    }
}
class User implements Delayed {
    private int id;//用户id
    private String name;//用户名字
    private long endTime;//结束时间
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getEndTime() {
        return endTime;
    }
    public void setEndTime(long endTime) {
        this.endTime = endTime;
    }
    public User(int id, String name, long endTime) {
        this.id = id;
        this.name = name;
        this.endTime = endTime;
    }
    //只包装用户名字就可以
    @Override
    public String toString() {
        return "User{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                &#39;}&#39;;
    }
    @Override
    public long getDelay(TimeUnit unit) {
        //计算剩余时间 剩余时间小于0 <=0  证明已经到期
        return this.getEndTime() - System.currentTimeMillis();
    }
    @Override
    public int compareTo(Delayed o) {
        //队列中数据 到期时间的比较
        User other = (User)o;
        return ((Long)(this.getEndTime())).compareTo((Long)(other.getEndTime()));
    }
}

Java stack and queue instance analysis

Double-ended queue

package com.yuzhenc.collection;

import java.util.Deque;
import java.util.LinkedList;

/**
 * @author: yuzhenc
 * @date: 2022-03-20 22:03:36
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test31 {
    public static void main(String[] args) {
        /*
        双端队列：
        Deque<E> extends Queue
        Queue一端放 一端取的基本方法  Deque是具备的
        在此基础上 又扩展了 一些 头尾操作（添加，删除，获取）的方法
         */
        Deque<String> d = new LinkedList<>() ;
        d.offer("A");
        d.offer("B");
        d.offer("C");
        System.out.println(d);//[A, B, C]
        d.offerFirst("D");
        d.offerLast("E");
        System.out.println(d);//[D, A, B, C, E]
        System.out.println(d.poll());//D
        System.out.println(d);//[A, B, C, E]
        System.out.println(d.pollFirst());//A
        System.out.println(d.pollLast());//E
        System.out.println(d);//[B, C]
    }
}

The above is the detailed content of Java stack and queue instance analysis. For more information, please follow other related articles on the PHP Chinese website!

Java Object NULL 接口栈线程并发对象

Statement：

This article is reproduced at:yisu.com. If there is any infringement, please contact admin@php.cn delete

Previous article：How does springboot integrate shiro to implement multi-verification login function?Next article：How does springboot integrate shiro to implement multi-verification login function?

See more

Java stack and queue instance analysis

Stack

Queue

Blocking Queue

Double-ended queue

Related articles