精华内容
下载资源
问答
  • Java合集框架支持一下两种类型的容器:一种是为了存储一个元素合集,简称为合集(collection)另一种是为了存储键/值对,称为映射表(map)集合:Set用于存储一组不重复的元素List用于存储一个有序元素合集Stack用于存储...

    Java合集框架支持一下两种类型的容器:

    一种是为了存储一个元素合集,简称为合集(collection)

    另一种是为了存储键/值对,称为映射表(map)

    集合:

    Set用于存储一组不重复的元素

    List用于存储一个有序元素合集

    Stack用于存储采用后进先出方式处理的对象

    Queue用于存储采用先进先出方式处理的对象

    PriorityQueue用于存储按照优先级顺序处理的对象

    collection

    add(o: E): boolean //添加一个元素

    addAll(c: Collection extends E>): boolean

    clear(): void //删除所有元素

    contains(o: Object): boolean //判断合集是否包含元素o

    remove(o: Object): boolean //从该合集中移除元素o

    retainAll(c: Collection extends E>): boolean //保留同时位于c和该合集中的元素

    size(): int //返回该合集中的元素数目

    ......

    迭代器

    每个合集都是可迭代的(Iterable)。可以获得集合的Iterator对象来遍历集合中的所有元素。Iterator是一种经典的设计模式,用于在不需要暴露数据结构具体细节的情况下,来遍历一个数据结构。

    Collection接口继承自Iterable接口,Iterable接口中定义了iterator方法返回Iterator接口(迭代器),Iterator接口为遍历各种类型的合集中的元素提供了一种统一的方法。

    迭代器中remove()方法和next()一起配合使用,迭代器的初始指针指向第一个元素之前,需要先用next(),再用remove()。

    使用foreach方法其实就是对iterator方法的封装,通过反编译可以看到。

    import java.util.ArrayList;

    import java.util.Collection;

    import java.util.Iterator;

    public class TestIterator {

    public static void main(String[] args) {

    Collection collection = new ArrayList<>();

    collection.add("a");

    collection.add("b");

    collection.add("c");

    //iterator头指针指向集合头元素前面,hasNext判断有没有下一个元素,但是指针不会变

    //next方法移向下一个元素,并且返回指针移动后返回的值

    Iterator iterator = collection.iterator();

    //注意collection接口中提供的remove方法和iterator中的remove方法不能同时出现,会产生并发修改错误

    System.out.println(collection);

    //foreach反编译后其实是对iterator方法的包装

    for(String content : collection) {

    System.out.println(content);

    }

    }

    }

    线性表

    List接口继承自Collection接口,定义了一个用于顺序存储元素的合集。可以使用他的两个具体类ArrayList或者LinkedList来创建一个线性表。

    List接口定义了一个允许重复的有序合集。List接口增加了面向位置的操作,并且增加了一个能够双向遍历线性表的新线性表迭代器

    add(index: int, element: Object): boolean //在指定的索引处增加一个新的元素

    //备注:若果原来的位置有元素,那么将其及后面的所有元素索引加1

    get(intdex: int): E //返回指定索引位置的元素

    indexOf(element: Object): int //返回第一个匹配元素的索引

    listIterator(): ListIterator //返回针对该线性表元素的迭代器

    listIterator(startIndex: int): ListIterator //返回从指定为止开始的迭代器

    //此方法可以用来逆序迭代

    remove(index: int): E //移除指定索引位置处的元素

    set(intdex: int, element: Object): Object //设置指定索引处的元素

    ListIterator接口继承了Iterator接口,以增加对线性表的双向遍历能力。

    add(element: E): void //添加一个指定元素到线性表中

    hasPrevious(): boolean //逆向遍历时如果当前元素之前还有元素返回true

    next(): E //返回下一个元素

    nextIndex(): int //返回下一个元素的索引

    previous(): E //返回前一个元素

    previousIndex(): int //返回前一个元素的索引

    set(element: E): void //使用指定的元素替换previous或next方法返回的最后一个元素ArrayList用数组存储元素,这个数组是动态创建的,如果元素个数超过了数组的容量,就创建一个更大的数组,并将当前数组中所有的元素都复制到新的数组当中。LinkedList在一个链表中存储元素。

    要选用两种类中的哪一个依赖于特定的需求。如果需要下标随机访问而不会在线性表的起始位置插入或删除元素,那么ArrayList效率高,反之就用LinkedList。向ArrayList中添加元素时,其容量会自动增大。ArrayList不能自动减小,可以使用方法trimToSize()将数组容量减小到线性表的大小。

    ArrayList() //使用默认的出事容量构建一个空线性表

    ArrayList(c: Collection extends E>) //从已存在的合集中创建一个线性表

    ArrayList(initialCapacity: int) //创建一个指定初始容量的空数组线性表

    trimToSize(): void //将ArrayList实例容量裁剪到当前大小

    LinkedList()

    LinkedList(c: Collection extends E>)

    addFist(element: E):void //添加元素到线性表头部

    addLast(element: E): void //添加元素到线性表尾部

    getFirst(): E //返回该线性表第一个元素

    getLast(): E //返回该线性表最后一个元素

    removeFirst(): E //从线性表中返回并删除第一个元素

    RemoveLast(): E //从线性表中返回并删除最后一个元素

    Comparator接口

    Comparable接口定义了compareTo方法,用于比较实现了Comparable接口的同一个类的两个元素,比如String、Date、Calendar、BigInteger、BigDecimal以及所有基本类型的数字包装类。

    public intcompara(T element1,T element2)//如果element1小于element2,就返回一个负值//如果element1大于element2,就返回一个正值//若两者相等,则返回0

    向量类和栈类

    在Java API中,Vector是AbstractList的子类,Stack是Vector的子类。除了访问和修改向量的同步方法之外,Vector类与ArrayList是一样的,Vector类被广泛用在Java的遗留代码中。

    栈类Stack是作为Vector类的扩展来实现的

    java.util.Vectorjava.util.Stack

    Stack() //创建一个空的栈

    empty(): boolean //若为空则返回true

    peek(): E //返回栈顶元素

    pop(): E //返回并移除栈顶元素

    push(o: E): E //压入一个元素

    search(o: Object): int //返回指定元素的索引

    队列和优先队列

    队列(queue)是一种先进先出的数据结构。优先队列(priority queue)中,元素被赋予优先级,最高优先级的元素先被删除。

    java.util.Collection

    java.util.Queue

    add(element: E): boolean //插入一个元素到队列中

    offer(element: E): boolean //插入一个元素到队列中,在大部分情况下两者是相同的,但是在有容量限制的queue中,当队列已满时,add方法抛出错误,而offer方法返回false

    poll(): E //获取并移除队列头元素,如果空返回null

    remove(): E //获取并移除队列头元素,如果空抛出异常

    peek(): E //获取但不移除队列的头元素,如果队列为空则返回null

    element(): E //获取但不移除队列的头元素,如果为空则抛出异常

    双端队列Deque和链表LinkedList

    Deque支持在两端插入和删除元素,LinkedList类实现了Deque接口。

    PriorityQueue类实现了一个优先队列。

    总结

    Java合集框架支持集合、线性表、队列和映射表,他们分别定义在接口Set、List、Queue、Map中

    除去PriorityQueue,Java合集框架中的所有实例类都实现了Cloneable和Serializable接口。所以他们的实例都是可克隆和可实例化的。

    Comparator可以用于比较没有实现Comparable接口的类的对象。

    Vector向量类和ArrayList基本一样,不同的是Vector访问和修改向量的方法是同步的。

    展开全文
  • 一、写在前面数据结构中的队列应该是比较熟悉的了,就是先进先出,因为有序故得名队列,就如同排队嘛,在对尾插入新的节点,在对首删除节点.jdk集合框架也是提供也一个Queue的接口.这个接口代表一个队列.顺序队列:...

    一、写在前面

    数据结构中的队列应该是比较熟悉的了,就是先进先出,因为有序故得名队列,就如同排队嘛,在对尾插入新的节点,在对首删除节点.jdk集合框架也是提供也一个Queue的接口.这个接口代表一个队列.顺序队列:ArrayBlockingQueue,LinkedBlockingQueue.(上面两种是足色队列)还有一种是ConcurentLinkedQueue。

    底层的实现由数组合链表两种的,数组的实现会有个弊端的,会造成假满的现象,开始的时候,队列为空的时候,对首引用变量个对尾的引用变量都为null,随着删除队列的元素,就会发生front+1,rear等于底层数组的容量了.在顺序的存储结构中,front总是保存这着队列中即将出队列的元素的索引,rear总是保存着即将进入队列的元素的索引.队列中的元素的个数就是rear-front的.在顺序的队列中,底层是数组,所以保存 的数据元素是不会改变的,改变的只有rear和front这两个引用变量.

    这里采用链式存储可以有效的利用空间的,就是引用变量要占用额外的空间的.

    队列的常用的操作:

    1:初始化

    2:返回队列的长度

    3:添加元素

    4:删除元素

    5:访问对首的元素

    6:访问队列的对尾的元素

    7:判断队列是否为空

    8:清空队列

    二、自定义的实现

    源码展示的比较清楚,就不用再多做介绍

    public class LinkedQueue{

    //自定义链队列--采用非静态内部类来表示链队列的数据节点

    private class Node{

    //表示链队列的数据节点

    private T data;

    //指向下一个节点的引用

    private Node next;

    @SuppressWarnings("unused")

    public Node(){

    }

    public Node(T data,Node next){

    this.data=data;

    this.next=next;

    }

    }

    //定义链队列的对首和对尾的引用

    private Node front;

    private Node rear;

    //定义链栈的大小

    private int size;

    //创建一个空的链对列

    public LinkedQueue(){

    front=null;

    rear=null;

    }

    //以确定的元素来创建一个链对列,只有一个节点的

    public LinkedQueue(T element){

    front=new Node(element,null);

    //指向同一个元素

    rear=front;

    size++;

    }

    //返回链队列的大小

    public int length(){

    return size;

    }

    //返回链队列得对首的元素,不删除对首的元素

    public T elementFront(){

    if(!empty()){

    return front.data;

    }else{

    return null;

    }

    }

    //访问队列的最后一个元素

    public T elementRear(){

    if(!empty()){

    return rear.data;

    }else{

    return null;

    }

    }

    //返回当前的链对队列是否为空

    public boolean empty(){

    return size==0;

    }

    //清空一个链队列

    public void clear(){

    front=null;

    rear=null;

    size=0;

    }

    //插入链队列一个节点--对尾

    public void add(T element){

    //如果链对列为空,就新建一个节点

    if(front==null){

    rear=new Node(element,null);

    front=rear;

    }else{

    //动态创建新节点

    Node newRear=new Node(element,null);

    rear.next=newRear;

    rear=newRear;

    }

    size++;

    }

    //删除链队列一个节点,返回删除后的节点

    public T remove(){

    Node oldFront=front;

    front=front.next;

    oldFront.next=null;

    size--;

    return oldFront.data;

    }

    //返回队列

    public String toString(){

    //如果链队列为空链队列是

    if(empty()){

    return "[]";

    }else{

    StringBuilder sBuilder=new StringBuilder("[");

    for(Node current=front;current!=null;current=current.next){

    sBuilder.append(current.data.toString()+",");

    }

    int len=sBuilder.length();

    return sBuilder.delete(len-1, len).append("]").toString();

    }

    }

    public static void main(String[] args) {

    LinkedQueue lQueue=new LinkedQueue();

    lQueue.add("aaa");

    lQueue.add("bbb");

    lQueue.add("ccc");

    lQueue.add("ddd");

    System.out.println("返回队列的头结点的数值:"+lQueue.elementFront());

    System.out.println("返回队列的尾节点的数值:"+lQueue.elementRear());

    System.out.println(lQueue.length());

    System.out.println(lQueue);

    }

    }

    运行结果:

    ec926e9c8e892773709e47fd97d7d08e.png

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • Java集合是java提供的工具包,包含了常用的数据结构:集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.*Java集合主要可以划分为4个部分:List列表、Set集合、Map映射、工具类(Iterator迭代器、...

    Java集合是java提供的工具包,包含了常用的数据结构:集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.*
    Java集合主要可以划分为4个部分:List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)。

    Java集合工具包框架如下图。

    e5cd850ba5f87c0e28f9888915a7a460.png

    说明:看上面的框架图,先抓住它的主干,即Collection和Map。

    • Collection是一个接口,是高度抽象出来的集合,它包含了集合的基本操作和属性。

    Collection包含了List和Set两大分支。

    (01) List是一个有序的队列,每一个元素都有它的索引。第一个元素的索引值是0。
    List的实现类有LinkedList, ArrayList, Vector, Stack。

    (02) Set是一个不允许有重复元素的集合。
    Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap,它实际上是通过HashMap实现的;TreeSet依赖于TreeMap,它实际上是通过TreeMap实现的。

    • Map是一个映射接口,即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。

    AbstractMap是个抽象类,它实现了Map接口中的大部分API。而HashMap,TreeMap,WeakHashMap都是继承于AbstractMap。
    Hashtable虽然继承于Dictionary,但它实现了Map接口。

    接下来,再看Iterator。它是遍历集合的工具,即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator,是因为Collection的实现类都要实现iterator()函数,返回一个Iterator对象。
    ListIterator是专门为遍历List而存在的。

    再看Enumeration,它是JDK 1.0引入的抽象类。作用和Iterator一样,也是遍历集合;但是Enumeration的功能要比Iterator少。在上面的框图中,Enumeration只能在Hashtable, Vector, Stack中使用。

    最后,看Arrays和Collections。它们是操作数组、集合的两个工具类。

    有了上面的整体框架之后,我们接下来对每个类分别进行分析。


    Collection架构


    我们将对Collection进行概括。下面先看看Collection的一些框架类的关系图:

    f4d9506968e2069f646848af56cfca85.png

    Collection是一个接口,它主要的两个分支是:List 和 Set

    List和Set都是接口,它们继承于Collection。List是有序的队列,List中可以有重复的元素;而Set是数学概念中的集合,Set中没有重复元素!
    List和Set都有它们各自的实现类。

    为了方便实现,集合中定义了AbstractCollection抽象类,它实现了Collection中的绝大部分函数;这样,在Collection的实现类中,我们就可以通过继承AbstractCollection省去重复编码。AbstractList和AbstractSet都继承于AbstractCollection,具体的List实现类继承于AbstractList,而Set的实现类则继承于AbstractSet。

    另外,Collection中有一个iterator()函数,它的作用是返回一个Iterator接口。通常,我们通过Iterator迭代器来遍历集合。ListIterator是List接口所特有的,在List接口中,通过ListIterator()返回一个ListIterator对象。

    接下来,我们看看各个接口和抽象类的介绍;然后,再对实现类进行详细的了解。

    目录1. Collection简介2. List简介3. Set简介4. AbstractCollection5. AbstractList6. AbstractSet7. Iterator8. ListIterator

    1. Collection简介

    Collection的定义如下:

    public interface Collection<E> extends Iterable<E> {}
    它是一个接口,是高度抽象出来的集合,它包含了集合的基本操作:添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等。

    Collection接口的所有子类(直接子类和间接子类)都必须实现2种构造函数:不带参数的构造函数 和 参数为Collection的构造函数。带参数的构造函数,可以用来转换Collection的类型。

    // Collection的APIabstract boolean         add(E object)abstract boolean         addAll(Collection extends E> collection)abstract void            clear()abstract boolean         contains(Object object)abstract boolean         containsAll(Collection> collection)abstract boolean         equals(Object object)abstract int             hashCode()abstract boolean         isEmpty()abstract Iterator     iterator()abstract boolean         remove(Object object)abstract boolean         removeAll(Collection> collection)abstract boolean         retainAll(Collection> collection)abstract int             size()abstract  T[]         toArray(T[] array)abstract Object[]        toArray()

    2. List简介

    List的定义如下:

    public interface List<E> extends Collection<E> {}
    List是一个继承于Collection的接口,即List是集合中的一种。List是有序的队列,List中的每一个元素都有一个索引;第一个元素的索引值是0,往后的元素的索引值依次+1。和Set不同,List中允许有重复的元素。List的官方介绍如下:

    A List is a collection which maintains an ordering for its elements. Every element in the List has an index. Each element can thus be accessed by its index, with the first index being zero. Normally, Lists allow duplicate elements, as compared to Sets, where elements have to be unique.

    关于API方面。既然List是继承于Collection接口,它自然就包含了Collection中的全部函数接口;由于List是有序队列,它也额外的有自己的API接口。主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

    // Collection的APIabstract boolean         add(E object)abstract boolean         addAll(Collection extends E> collection)abstract void            clear()abstract boolean         contains(Object object)abstract boolean         containsAll(Collection> collection)abstract boolean         equals(Object object)abstract int             hashCode()abstract boolean         isEmpty()abstract Iteratoriterator()abstract boolean         remove(Object object)abstract boolean         removeAll(Collection> collection)abstract boolean         retainAll(Collection> collection)abstract int             size()abstract  T[]         toArray(T[] array)abstract Object[]        toArray()// 相比与Collection,List新增的API:abstract void                add(int location, E object)abstract boolean             addAll(int location, Collection extends E> collection)abstract E                   get(int location)abstract int                 indexOf(Object object)abstract int                 lastIndexOf(Object object)abstract ListIteratorlistIterator(int location)abstract ListIteratorlistIterator()abstract E                   remove(int location)abstract E                   set(int location, E object)abstract ListsubList(int start, int end)

    3. Set简介

    Set的定义如下:

    public interface Set<E> extends Collection<E> {}
    Set是一个继承于Collection的接口,即Set也是集合中的一种。Set是没有重复元素的集合。

    关于API方面。Set的API和Collection完全一样。

    // Set的APIabstract boolean         add(E object)abstract boolean         addAll(Collection extends E> collection)abstract void             clear()abstract boolean         contains(Object object)abstract boolean         containsAll(Collection> collection)abstract boolean         equals(Object object)abstract int             hashCode()abstract boolean         isEmpty()abstract Iterator     iterator()abstract boolean         remove(Object object)abstract boolean         removeAll(Collection> collection)abstract boolean         retainAll(Collection> collection)abstract int             size()abstract  T[]         toArray(T[] array)abstract Object[]         toArray()

    4. AbstractCollection

    AbstractCollection的定义如下:

    public abstract class AbstractCollection<E> implements Collection<E> {}
    AbstractCollection是一个抽象类,它实现了Collection中除iterator()和size()之外的函数。
    AbstractCollection的主要作用:它实现了Collection接口中的大部分函数。从而方便其它类实现Collection,比如ArrayList、LinkedList等,它们这些类想要实现Collection接口,通过继承AbstractCollection就已经实现了大部分的接口了。

    5. AbstractList

    AbstractList的定义如下:

    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {}
    AbstractList是一个继承于AbstractCollection,并且实现List接口的抽象类。它实现了List中除size()、get(int location)之外的函数。
    AbstractList的主要作用:它实现了List接口中的大部分函数。从而方便其它类继承List。
    另外,和AbstractCollection相比,AbstractList抽象类中,实现了iterator()接口。

    6. AbstractSet

    AbstractSet的定义如下:

    public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {}
    AbstractSet是一个继承于AbstractCollection,并且实现Set接口的抽象类。由于Set接口和Collection接口中的API完全一样,Set也就没有自己单独的API。和AbstractCollection一样,它实现了List中除iterator()和size()之外的函数。
    AbstractSet的主要作用:它实现了Set接口中的大部分函数。从而方便其它类实现Set接口。

    7. Iterator

    Iterator的定义如下:

    public interface Iterator {}
    Iterator是一个接口,它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。Iterator提供的API接口,包括:是否存在下一个元素、获取下一个元素、删除当前元素。注意:Iterator遍历Collection时,是fail-fast机制的。即,当某一个线程A通过iterator去遍历某集合的过程中,若该集合的内容被其他线程所改变了;那么线程A访问集合时,就会抛出ConcurrentModificationException异常,产生fail-fast事件。关于fail-fast的详细内容,我们会在fail-fast总结后面专门进行说明。
    // Iterator的APIabstract boolean hasNext()abstract E next()abstract void remove()

    8. ListIterator

    ListIterator的定义如下:

    public interface ListIterator<E> extends Iterator<E> {}
    ListIterator是一个继承于Iterator的接口,它是队列迭代器。专门用于便利List,能提供向前/向后遍历。相比于Iterator,它新增了添加、是否存在上一个元素、获取上一个元素等等API接口。
    // ListIterator的API// 继承于Iterator的接口abstract boolean hasNext()abstract E next()abstract void remove()// 新增API接口abstract void add(E object)abstract boolean hasPrevious()abstract int nextIndex()abstract E previous()abstract int previousIndex()abstract void set(E object)
    展开全文
  • 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 的栈和队列的概念和基本使用,补充了优先级队列的相关内容,打印优先级队列的时候需要使用遍历的方式。

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

    在这里插入图片描述

    展开全文
  • Java集合框架

    2020-12-03 00:05:27
    Java集合框架 Java集合大致可以分为Set、List、Queue和Map四种。 Set是无序、不可重复的集合;List是有序、重复的集合;Map是具有映射关系的集合;Queue是队列集合。 1、Java集合和数组的区别 (1)数组长度在初始化...
  • 概念Java中的集合类:是一种工具类,就像是容器,储存任意数量的具有共同属性的对象集合的作用集合框架的类型:collection和map 都是接口,不能实例化List和Queue有序、可重复,Set无序、不可重复list添加元素两种...
  • java集合框架

    2017-12-22 10:06:34
    java集合框架支持两种类型: 一是存储一类元素, 即为集合; 二是存储键值对,即为map. 集合支持三种类型的集合: 规则集: Set 存储一组不重复的元素, 且无序. 线性表: List 存储一组可重复的元素, 且有序. 队列 : ...
  • Java自定义实现链队列

    2017-11-10 21:33:37
     数据结构中的队列应该是比较熟悉的了,就是先进先出,因为有序故得名队列,就如同排队嘛,在对尾插入新的节点,在对首删除节点.jdk集合框架也是提供也一个Queue的接口.这个接口代表一个队列.顺序队列:...
  • Java集合框架详解

    2014-02-12 11:54:45
    一、集合的总体系 java集合类定义主要在...java.util.List接口及其子类,List提供的是一个有序的集合;   java.util.Map接口及其子类,Map提供了一个映射(对应)关系的集合数据结构 在JDK5中新增了Queue(队列)
  • Java集合大致可分为Set、List和Map三种体系,其中Set代表无序、不可...Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。 Collection接口 它主要有三个子接口,List,Set,Queue List子...
  • Java Collection框架中包含了大量集合接口以及这些接口的实现类和操作他们的方法。 包括: 集合(Collection) 列表(List) ArrayList 有序 可排序 可重复 ,可以for循环遍历 线程不安全 底层是数组 查询快增删...
  • Java中实现数据集合功能的一个框架:链表(list)数学集合(set)映射(map) 常用的集合类型: 线性表(list):一组有序元素的集合,可以使用整数索引来访问其中的元素 栈(stack):具备后进先出特性...
  • Java 集合框架

    2019-03-09 10:33:15
    List 是一个有序集合,允许元素重复。它的某些实现可以提供基于下标值的常量访问时间,但是这不是 List 接口保证的。Set 是一个无序集合。 49)poll() 方法和 remove() 方法的区别? poll() 和 remove() 都是从...
  • java集合框架详解

    2019-03-07 17:49:01
    java集合框架详解 tree排序hash不排序 set不可重复 list有序 如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应 该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。 ...
  • Java集合框架总结

    2017-02-17 14:49:10
    Java集合框架总结两个根接口 Collection Map Set和List是Collection接口派生的两个子接口,Queue是Java提供的队列实现,类似于List。Map实现类用于保存具有映射关系(key-value)的数据。 Set、List和Map可以看作...
  • java集合框架体系介绍

    2020-01-27 10:49:50
    Java中集合的分类,主要有两个接口派生出来的:Collection 和 Map 是java集合框架的根接口,这两个接口包含一些接口或者实现类。 java集合大致可分为:Set、List、Queue、Map Set代表无序、不可重复的集合 List代表...
  • Java 集合框架的接口

    2019-12-06 22:44:08
    Java 集合框架的接口接口基本关系说明Collection 常用方法说明Map常用方法说明 接口基本关系说明 Collection :用来存储管理一组对象 objects ,这些对象一般被成为元素 elements Set : 元素不能重复,背后隐含着...
  • java 集合框架

    2016-07-17 16:21:50
    List的特点有序,重复,那么ArrayList和LinkedList的区别: ArrayList插入和删除数据慢,取值速度快,实际上ArrayList是数组的扩充; LinkedList插入和删除数据快,取值速度慢,原因是LinkedList是双向队列 2.Set...
  • Java集合-1】整体框架

    万次阅读 2019-07-02 15:38:46
    Java集合是Java提供的工具包,位于java.util.*中,包含了集合、链表、队列、栈、数组、映射等常见的数据结构。 基本框架 集合的框架图如下: 观察上面的框架结构图可知: Collection是一个接口,包含了集合的基本...
  • Java集合类框架总结

    2019-08-30 22:46:20
    Collection接口属于java.lang包,是集合类框架的主要接口,List接口、set接口、Queue接口继承了Collection接口,分别是列表、集合和队列。 1、List接口 java.lang.List接口主要定义了一些添加、获取、删除的元素...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 318
精华内容 127
关键字:

有序队列框架java

java 订阅