精华内容
下载资源
问答
  • 而原本java中是存在stack类的,但现在已经不推荐使用了,一般将Deque这个接口当作来使用,它实现的是一个双端队列。 Deque作为使用,常用以下方法:push(E),pop(),peek() ; Deque作为双端队列使用,常用...

    栈和队列是一种逻辑上的数据结构,栈,遵循先进后出的原则,在编译器中得到的应用较多,例如对于括号的匹配(这也是常见的算法题目),表达式的转换等,由于我们只关心栈顶元素,并不需要直接取到栈中间的元素,队列结构类似,只关心首尾元素,十分契合我们链表的特点。

    而原本java中是存在stack类的,但现在已经不推荐使用了,一般将Deque这个接口当作栈来使用,它实现的是一个双端队列。

    Deque作为栈使用,常用以下方法:push(E),pop(),peek() ;

    Deque作为双端队列使用,常用以下方法:addLast(E),removeLast();

    队列遵循先进先出的原则,一般用以作任务队列,Queue接口实现方法有:

     

    展开全文
  • Java栈和队列

    2019-06-30 14:25:47
    Java栈和队列1.Stack2.Queue3.PriorityQueue小结 栈和队列用来存储一组有序的值,二者很相似,栈是一种先进后出的结构,也就是最后保存的元素最先被访问;队列是一种先进先出的结构,也就是最先保存的元素最先被访问...


    队列用来存储一组有序的值,二者很相似,栈是一种先进后出的结构,也就是最后保存的元素最先被访问;队列是一种先进先出的结构,也就是最先保存的元素最先被访问。

    1.Stack

    栈通常是指先进后出的容器。有时候栈也被称为叠加栈,因为最后压入的元素,第一个弹出栈,有图有真相:
    在这里插入图片描述

    Stack 框架图:

    在这里插入图片描述

    可以看出 Stack 继承了 Vector,实现了 List 接口,也是 Collection 大家族中的一员。下面瞅瞅 Stack 的常规操作:

    public static void main(String[] args) {
            //创建 Stack 对象
            Stack<String> stack = new Stack<>();
            String str = "this is a stack";
            for (String s : str.split(" ")) {
                //将值放入栈中
                stack.push(s);
            }
            System.out.println(stack);
            System.out.println("栈的大小:" + stack.size());
            System.out.println("栈顶的值:" + stack.peek());
            System.out.println("删除并返回栈顶的值:" + stack.pop());
            System.out.println("删除栈顶后的栈:" + stack);
            //打印结果和上面相反
            while (!stack.empty()){
                System.out.print(stack.pop() + " ");
            }
     }
    

    打印结果:

    [this, is, a, stack]
    栈的大小:4
    栈顶的值:stack
    删除并返回栈顶的值:stack
    删除栈顶后的栈:[this, is, a]
    a is this

    从代码和打印结果可以看出,Stack 的操作和 LinkedLIst 的操作非常相似:

    • push(E item) 方法,将值压入栈的顶部;
    • size() 方法,得到栈的大小;
    • peek() 方法,返回栈顶元素,但是不删除该元素;
    • pop() 方法,删除并返回栈顶元素;
    • empty() 方法,判断栈是否为空,如果为空返回 true。

    2.Queue

    队列是一个典型的先进先出的容器,即从容器的一端放入事物然后从另一端取出,并且事物放入容器的顺序与取出的顺序是相同的。队列在并发编程中尤为重要,因为它可以安全地将对象从一个任务传输给另一个任务。

    Queue 框架图:

    在这里插入图片描述

    通过框架图可以看到 LinkedList 实现了 Queue 接口并且提供了方法以支持队列的行为。简单示例:

    public static void main(String[] args) {
            //通过 LinkedList 向上转型创建 Queue 对象
            Queue<Integer> queue = new LinkedList<>();
            Random random = new Random();
            for (int i = 0; i < 10; i++) {
                //向队列末尾添加元素
                queue.offer(random.nextInt(10));
                //queue.add(random.nextInt(10));
            }
            System.out.println("队列: " + queue);
            System.out.println("队列头:" + queue.peek());
            System.out.println("队列头:" + queue.element());
            System.out.println("删除并返回队列头:" + queue.poll());
            System.out.println("删除并返回队列头:" + queue.remove());
    }
    

    打印结果:

    队列: [2, 6, 4, 5, 3, 5, 9, 6, 2, 6]
    队列头:2
    队列头:2
    删除并返回队列头:2
    删除并返回队列头:6

    Queue 的使用似曾相识,这些方法在文章 List 简介 中已经介绍过,Queue 接口窄化了对 LinkedList 的方法的访问权限,只对外暴露了以下方法:

    • offer(E e) 方法和 add(E e) 方法一样,都是向队列的末尾添加一个元素;
    • peek() 方法 和 element() 方法都是在不删除的情况下返回队列的头元素,但是 peek() 方法在队列为空时返回 null,而 element() 方法则会抛出异常;
    • poll() 方法和 remove() 方法都是删除并返回队列头元素,但是 poll() 方法在队列为空的时候返回 null,而 remove() 方法则会抛出异常。

    3.PriorityQueue

    先进先出描述了最典型的队列规则,声明的是下一个弹出队列的元素应该是等待时间最长的元素。优先级队列声明下一个弹出元素是最需要的元素,也就是具有最高的优先级,当在 PriorityQueue 中添加一个对象时,这个对象会在队列中被排序,规则是对象在队列中的自然顺序,如果需要修改这个顺序,那么可以通过提供自己的 Comparator 来实现。

      /**
         * 打印 queue
         * @param queue
         */
        public static void printQueue(Queue queue){
            while(!queue.isEmpty()){
                System.out.print(queue.poll() + ",");
            }
        }
    
        public static void main(String[] args) {
            //创建一个整数集合
            List<Integer> list = Arrays.asList(3,6,1,8,5,1,7,9,0,4);
    
            //创建 PriorityQueue 对象
            PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
            priorityQueue.addAll(list);
            System.out.println("默认排序:");
            //打印
            printQueue(priorityQueue);
            System.out.println();
    
            //创建倒序的 PriorityQueue 对象
            priorityQueue = new PriorityQueue<>(list.size(), new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2.compareTo(o1);
                }
            });
            priorityQueue.addAll(list);
            System.out.println("倒序:");
            //打印
            printQueue(priorityQueue);
        }
    

    打印结果:

    默认排序:
    0,1,1,3,4,5,6,7,8,9,
    倒序:
    9,8,7,6,5,4,3,1,1,0,

    当使用 PriorityQueue 的无参构造器创建 PriorityQueue 优先级队列的时候,队列中元素的顺序默认是自然排序,如果需要制定排序规则,就需要调用 PriorityQueue 的有参构造器,然后自定义 Comparator 对象重写 compareTo() 方法。而且从打印结果来看,元素的重复是允许的。

    中间还有一个小插曲,当使用 PriorityQueue 的 toString() 方法去打印的时候,发现顺序居然不对,最后使用了上述代码中的遍历的方式才打印出理想中的结果。PriorityQueue 的逻辑结构是一棵完全二叉树,存储结构其实就是一个数组,逻辑层次遍历的结果刚好是一个数组。

    小结

    本章介绍了 Java 的栈和队列的概念和基本使用,补充了优先级队列的相关内容,打印优先级队列的时候需要使用遍历的方式。

    欢迎关注公众号:一盐难进

    在这里插入图片描述

    展开全文
  • ”通常指“后进先出”的(LIFO)容器。本文将分别介绍基于LinkedList和不依赖LinkedList的两种实现方法。  友情提示:这里,我假设读者... 在Java中,LinkedList具有能够实现的所有功能的方法,因此可以将L...

      “栈”通常指“后进先出”的(LIFO)容器。本文将分别介绍基于LinkedList和不依赖LinkedList的两种实现方法。

      友情提示:这里,我假设读者已经了解泛型,内部类,LinkedList容器以及递归的概念,如果没有,可能会对您的理解造成一点不便。

    一、基于LinkedList的实现

      在Java中,LinkedList具有能够实现栈的所有功能的方法,因此可以将LinkedList作为栈使用,实现类可以非常的优雅而简洁:

    package com.test.collection;
    
    import java.util.LinkedList;
    
    public class Stack<T> {
        private LinkedList<T> storage = new LinkedList<T>();
        public void push(T v) {
            storage.addFirst(v);
        }
        public T peek() {
            return storage.getFirst();
        }
        public T pop() {
            return storage.removeFirst();
        }
        public boolean empty() {
            return storage.isEmpty();
        }
        public String toString() {
            return storage.toString();
        }
    }
    View Code

      通过使用泛型,引入了栈在类定义中最简单的可行示例。push()接受T类型对象并压入栈中,而peek()和pop()将返回T类型的对象。区别是前者仅返回栈顶元素,后者返回并移除栈顶元素。

      如果你只需要栈的行为,这里使用继承就不合适了,因为这样会产生具有LinkedList其他所有方法的类(据说,Java1.0设计者在设计Java.util.Stack时,就犯了这个错误)。因此尽管已经有了java.util.Stack,但是LinkedList可以产生更好的Stack,下面的测试类中同时测试自己实现的Stack和Java.util.Stack里的Stack

    package com.test.collection;
    
    public class StackCollision {
    
        public static void main(String[] args) {
            com.test.collection.Stack<String> stack = new com.test.collection.Stack<String>();
            for(String s : "My dog has fleats".split(" "))
                stack.push(s);
            while(!stack.empty())
                System.out.print(stack.pop() + " ");
            System.out.println();
            java.util.Stack<String> stack2 = new java.util.Stack<String>();
            for(String s : "My dog has fleats".split(" "))
                stack2.push(s);
            while(!stack2.empty())
                System.out.print(stack2.pop() + " ");
        }
    
    }
    View Code

    测试结果:

    这里创建Stack实例时,需要完整地指定包名,否则有可能与java.util包中的Stack产生冲突。这两个Stack具有相同的接口,但是java.util中没有任何公共的Srack接口。

     

    二、不依赖于LinkedList的实现

      如上面的例子所示,LinkedList本身已经具备了创建堆栈所必须的方法。我们只需要将LinkedList已有的方法进行封装,就可以完成一个堆栈的实现了。但是如果我觉得这样不利于我深入理解堆栈的实现,不想调用LinkedList的方法,想自己从头实现,该怎么办呢?下面的例子或许可以给你提供一点思路:

     1 package com.test.generic;
     2 
     3 public class LinkedStack<T> {
     4     private class Node<U> {
     5         U item;
     6         Node<U> next;
     7         Node() {
     8             item = null;
     9             next = null;
    10         }
    11         Node(U item, Node<U> next) {
    12             this.item = item;
    13             this.next = next;
    14         }
    15         boolean end() {
    16             return item == null && next == null;
    17         }
    18     }
    19     private Node<T> top = new Node<T>();//End sentiel 末端哨兵
    20     public void push(T item) {
    21         top = new Node<T>(item, top);
    22     }
    23     public T pop() {
    24         T result = top.item;
    25         //item和next(节点参数)任意一个非null,则查找下一个节点,若item和next
    26         //的值均为null,则不再查找下一个节点,直接返回null的result = top.item
    27         if(!top.end())
    28             top = top.next;
    29         return result;
    30     }
    31     
    32     public static void main(String[] args) {
    33         LinkedStack<String> lss = new LinkedStack<String>();
    34         for(String s : "Phasers on stun!".split(" "))
    35             lss.push(s);
    36         String s;
    37         while((s = lss.pop()) != null)
    38             System.out.println(s);
    39     }
    40 }
    View Code

     

      上例使用了一个带泛型参数的内部类Node<U>作为堆栈节点,参数item为泛型,用于接收节点上各种类型的对象或者基本类型;类型为next作为节点参数,接收下一个节点的信息;top为末端哨兵(end sential)的一个例子,与前两个参数配合,实现判断堆栈何时为空。这个末端哨兵实在构造LinkedStack时创建的,然后,每调用一次push()方法,就会创建一个Node<T>对象。调用pop()方法时,总是返回top.item,然后舍弃当前top所指的Node<T>,并将top转移到下一个Node<T>,碰到末端哨兵,就不在移动top,因为如果到了末端,再继续调用pop方法,只能得到null,说明堆栈已经空了。

      输出结果中我们可以看到,被顺序装入的字符串"Phasers","on","stun!"被倒序的输出,符合堆栈“后进先出”(LIFO)的特性。

      最后,感谢Bruce Eckel提供的例子。

    转载于:https://www.cnblogs.com/junqiao/p/6490030.html

    展开全文
  • (stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线形表。是一种数据结构,它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶。需要读数据的时候从栈顶开始弹出数据(最后一...

    栈(stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线形表。栈是一种数据结构,它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶。需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。

    栈就是一种类似桶堆积物物品的数据结构,进行删除和插入的一端成为栈顶,另一端成为栈底,插入一般成为进栈(Push),删除则成为退栈(pop),栈也称后进后出表(LIFO表),学过数据结构的同学很熟悉栈这种数据结构的特点了,再次就不详细介绍了;

    下面的代码将利用LinkedList来实现一个栈的基本功能

    代码如下:

    package Stephen.Classchapter9;
    import java.util.LinkedList;
    public class MockStack {
        private LinkedList data = new LinkedList();
        public boolean idEmpty(){
            return data.isEmpty();
        }
        public Object top(){
            //取栈顶元素相当于取LinkedList容器的头位置的元素
            return data.getFirst();
        }
        public void push(Object element){
            //压入元素相当于在LinkedList容器的头位置插入元素
            data.addFirst(element);
        }
        public void pop(){
            //弹出元素相当于删除LinkedList容器的头位置的元素
            data.removeFirst();
        }
        public String toString(){
            return data.toString();
        }
        public static void main(String[] args){
            MockStack stack = new MockStack();
            //下面的语句使用LinkedList实现的堆栈的用法
            stack.push("Shandong");
            stack.push("University Of Technology");
            stack.push("StephenLi");
            while (!stack.idEmpty()){
                System.out.println("即将弹出的成员是:" + stack.top());
                stack.pop();
                System.out.println("当前栈中剩余的成员为:" + stack);
            }
        }
    }

    运行结果如下:

    MoStack 类用一个模拟栈的行为,其中push方法将数据插入到链表的头部,而top方法用于获取链表头部的数据,pop方法则是获取并删除链表头部的数据,通过这三个方法的组合模拟实现了栈的数据结构,程序的main方法中建立了一个MockStack类的实、实例,然后按先后顺序压入三个字符串,最后调用top和pop方法将数据弹出。从打印结果可以看出来,最新压入的元素StephenLi最先被弹出,最早压入栈的元素Shandong最后弹出,这个类符合栈数据结构的定义,程序中用到的方法如下

    public Object getFirst()

    参数 :无

    功能:返回此列表的第一个元素

    public void addFirst(Object o)

    参数: o 为要插入到此列表的开头的元素

    功能:将给定元素插入到此列表的开头

    转载于:https://www.cnblogs.com/lidaojian/archive/2012/06/27/2566371.html

    展开全文
  • Java 的实现

    2016-08-04 19:20:36
    // Java 不支持泛型数组,如需使用,请使用Java提供的容器 private Object[] stack; // 的默认初始大小 private static final int INIT_SIZE = 2; // 栈顶索引 private int index;
  • Java (stack)

    2019-06-24 19:01:19
    Java(stack)是容器(vector)的一个子类。 堆栈除了包括由Vector定义的所有方法,还定义了一些自己的方法: 方法 描述 boolean empty() 判断堆栈是否为空 Object peek() 查看但不移除堆栈顶部对象 ...
  • ---|LinkedList: 链表实现 , 增删快 , 查找慢 实现了 队列 ---|Vector: 和 ArrayList 原理相同 , 但线程安全 , 效率略低 ---| Stuck 类 ---|Set: 无存储顺序 , 不可重复 ---|HashSet 线程不安全,存取...
  • java 的实现

    2016-11-05 11:47:52
    接口定义interface Stack { public T pop(); public void push(T element); public boolean isEmpty(); public T peek(); } ...接口实现:链表方式class LinkedStack ... //不用容器或者数组等数据结构存储节点
  • java栈溢出与堆溢出

    2020-02-10 23:28:49
    基本类型跟就是不可实例化的,可以直接初始...存储运行时声明的变量——对象引用(或基础类型, primitive)内存空间,堆分配每一个对象内容(实例)内存空间。 一个变量可以先后指向多个对象实例;数组、链表等可...
  • JAVA容器

    2014-11-27 14:27:11
    容器位于java.util包内   Java容器类库的用途是保存对象,根据数据结构不同将其划分为两个不同的概念 (1) Collection,一个独立元素的序列,其中List按照元素的插入顺序保存元素,而set不能有重复元素,...
  • 结构即先进后出,可以将其看做一个有底的容器,放入元素从底部开始。后来的元素放入已有元素的上方,且完全遮住了已有的元素,只有取走后来的元素,才可以看到早入栈的元素,对早入栈的元素进行操作。 方法介绍:...
  • 是存放对象的一种特殊容器,在插入与删除对象时,这种结构遵循后进先出(last-in-first-out, LIFO)的原则 ADT作为一种抽象数据类型(ADT),必须支持下列的基本方法: push():将对象压至栈顶,并输出栈顶...
  • 文章目录java常用容器1. 容器的基本概念2. 利用Arrays和Collections添加一组元素3. 容器的打印4. List常用方法的使用5. 迭代器Iterator5.1. ListIterator6. LinkedList常用方法使用7. Stack常用方法使用8. Set常用...
  • java容器之队列、双端队列、

    千次阅读 2016-08-24 19:16:08
    java中queue的使用 Queue接口与List、Set同一级别,都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,就完全只能...
  • Java容器

    2019-02-02 21:29:00
    问题及答案来源自《Java程序员面试笔试宝典》第四章 Java基础知识 4.9容器 1、Java Collections框架是什么? Java Collections框架中包含了大量集合接口以及这些接口的实现类和操作它们的算法(比如排序、...
  • 队列,一种先进先出的数据结构 ,一种先进后出的数据结构 java中常见的能用作和队列的类有:LinkedList、ArrayDeque 虽然这两个类都实现了和队列的相关方法,但是更建议使用ArrayDeque 我们看看源码中对...
  • Java常用容器(数据结构)总结

    千次阅读 2016-12-16 09:20:11
    我们在学校时就知道常用的数据结构,顺序容器数组,链表,队列(先进先出),(先进后出),去重容器,关联容器,哈希表。所以就以这些作为切入java容器的入口,而且平常的代码编写中基本上也就用到这些容器而已 ...
  • Java 容器

    2021-02-01 15:53:47
    文章目录概念数组Collection 集合List 序列AbstractListArrayListVectorStack LIFOAbstractSequentialListLinkedListSet 不可重复集合AbstractSetTreeSetHashSetLinkedHashSetQueue FIFO队列Deque 双端队列...
  • Java实现-两共享空间

    千次阅读 2017-09-26 15:47:32
    大话数据结构中以合租房子为例,来比喻两共享空间这种结构,我想说得已经比较清楚了,在Java实现中,我们定义一个数组作为基准存储容器,两个1的底是在数组的始端,2的底在数组的顶端,两个在push...
  • java容器

    2017-02-27 17:30:00
    java容器java 默默的看雨下 1.概述 Java容器类的JDK提供的保存对象的类。其隐藏了具体的实现(数组、链表),包含常用的数据结构:集合、队列、、映射 Java容器主要包括3部分:Collection集合(List、...
  • Java容器

    2018-03-06 19:35:06
    原文:http://alexyyek.github.io/2015/04/06/Collection/Java容器类是java提供的工具包,包含了常用的数据结构:集合、链表、队列、、数组、映射等。从本文开始将开启一个系列详细分析Java容器中的每个成员,包括...
  • java技术面试

    2020-12-18 14:39:07
    序号 ...Java集合容器面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588551 3 Java异常面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/10439...
  • java容器

    2019-12-19 14:40:59
    List 1.ArrayList是动态数组,支持随机快速访问,由于其实现了RandomAccessable接口,其内部终究还是数组的实现。...还可以用作,队列,双向队列的实现方案。 3.vector:与ArrayList类似,不同的地...
  • java 技术

    2018-10-24 15:45:13
    一、框架  Spring:  Spring是一个解决了许多在J2EE开发中常见的的问题的强大框架。 Springle提供了管理业务对象的一致方法并且鼓励了注入...然而Spring在使用IoC容器作为构建玩关注所有架构层层的完整解决方案方...
  • Java链表LinkedStack

    2019-08-20 18:41:50
    链表实现的,在想象的时候,最好把他竖着想象成一个立着的容器。 * 然后往里面一个一个的加节点: * 1.先加入top节点 * 2.然后再在top节点上加入node1节点,node1节点指向top节点 * 3.再在node1节点上加入node2...
  • Java容器的总体框架

    2017-08-10 00:25:28
    Java集合是java提供的工具包,包含了常用的数据结构:集合、链表、队列、、数组、映射等。Java集合工具包位置是java.util.* Java集合主要可以划分为4个部分:List列表、Set集合、Map映射、工具类(Iterator迭代器...
  • Java技术总览

    2021-01-17 11:43:29
    java技术1 java基础:1.1 算法1.2 基本1.3 设计模式1.4 正则表达式1.5 java内存模型以及垃圾回收算法1.6 锁以及并发容器的源码1.7 线程池源码2 web方面:2.1 SpringMVC的架构设计2.2 SpringAOP源码2.3 Spring事务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,388
精华内容 555
关键字:

java栈容器

java 订阅