Java API（十五）：Queue队列、Deque栈、Map集合

小鹿快跑～

已于 2023-06-13 19:56:40 修改

阅读量2.7k

点赞数 5

分类专栏： Java知识点文章标签： java

于 2022-05-15 11:42:59 首次发布

本文链接：https://blog.csdn.net/qq_45138120/article/details/124761126

版权

Java知识点专栏收录该内容

20 篇文章 6 订阅

订阅专栏

文章目录

Java API
一、Queue队列
- 1、Queue接口及LinkedList实现
- 2、Queue常用方法
二、Deque栈
- 1、Deque接口及LinkedList实现
- 2、Deque常用方法
三、Map集合

Java API

包括Queue接口及LinkedList实现、Queue常用方法、Deque接口及LinkedList实现、Deque常用方法、Map集合常用方法、HashMap基本原理、重写equals和hashCode方法、HashMap应用、HashMap性能调优、Map遍历（迭代）。

一、Queue队列

1、Queue接口及LinkedList实现

1）队列Queue是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另外一端取出（poll）元素

2）队列也可以放一组元素，但是存取元素必须遵循：先进先出原则

3）JDK提供了Queue接口，同时使得LinkedList实现了该接口（选择LinkedList实现Queue经常要进行插入和删除的操作，而LinkedList在这方面效率最高）

Queue queue = new LinkedList();

在这里插入图片描述

2、Queue常用方法

Queue常用方法

方法	功能
boolean offer(E e)	入队操作，向队尾追加一个新元素，如果添加成功则返回true
E poll()	出队操作，从队首获取元素，获取后该元素就从队列中被删除了
E peek()	引用队首元素，但是不做出队操作

import java.util.LinkedList;
import java.util.Queue;

/**
 * java.util.Queue
 * 队列
 * 队列也可以放一组元素，但是存取元素必须遵循：先进先出原则
 */
public class QueueDemo {
    public static void main(String[] args) {
        /**
         * LinkedList也实现了队列接口，因为它可以保存一组元素，并且首尾删快。正好符合队列的特点
         */
        Queue<String> queue = new LinkedList<String>();

        /*
        boolean offer(E e)
        入队操作，向队尾追加一个新元素
         */
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");
        queue.offer("four");
        queue.offer("five");
        queue.offer("six");
        System.out.println(queue); //[one, two, three, four, five, six]

        /*
        E poll()
        出队操作，从队首获取元素，获取后该元素就从队列中被删除了
         */
        String str = queue.poll();
        System.out.println(str); //one
        System.out.println(queue); //[two, three, four, five, six]

        /*
        E peek()
        引用队首元素，但是不做出队操作
         */
        str = queue.peek();
        System.out.println(str); //two
        System.out.println(queue); //[two, three, four, five, six]

        System.out.println("遍历开始");
        for(int i=queue.size();i>0;i--){ //倒着写，queue.size()会随着每次poll取数而改变
            str = queue.poll();
            System.out.print ("元素："+str+"   "); //元素：two   元素：three   元素：four   元素：five   元素：six
        }
        System.out.println(); //换行
        /*
        while(queue.size()>0){
            str = queue.poll();
            System.out.println("元素："+str);
        }
         */
        System.out.println("遍历结束");
        System.out.println(queue); //[]
    }
}

二、Deque栈

1、Deque接口及LinkedList实现

1）Deque是Queue的子接口，定义了所谓“双端队列”即从队列的两端分别可以入队（offer）和出队（poll）

2）如果将Deque限制为只能从一端入队和出队，则可实现“栈”（Stack）的数据结构，对于栈而言，入栈称为为push，出栈称之为pop

3）存储一组元素，但是存取元素必须遵循先进后出的原则

4）通常为了实现后退这类功能时会使用栈（word文档中的回退和前进）

在这里插入图片描述

2、Deque常用方法

Queue常用方法

方法	功能
void push(E e)	入栈操作，最后入栈的元素在栈顶（第一个元素位置）
E pop()	出栈操作

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

/**
 * 栈
 * 存储一组元素，但是存取元素必须遵循先进后出的原则
 * 通常为了实现后退这类功能时会使用栈（word文档中的回退和前进）
 */
public class StackDemo {
    public static void main(String[] args) {
        /*
        java.util.Deque
        双端队列，两端都可以进出队
        当子调用从一端进出队操作时，就形成了栈结构
        因此，双端队列为栈提供了两个方法：push，pop
         */
        Deque<String> stack = new LinkedList<String>();

        /*
        void push(E e)
        入栈操作，最后入栈的元素在栈顶（第一个元素位置）
         */
        stack.push("one");
        stack.push("two");
        stack.push("three");
        stack.push("four");
        System.out.println(stack); //[four, three, two, one]

        /*
        出栈操作
        E pop()
         */
        String str = stack.pop();
        System.out.println(str); //four
        System.out.println(stack); //[three, two, one]

        str = stack.peek();
        System.out.println(str); //three
        System.out.println(stack); //[three, two, one]

        while (stack.size()>0){
            str = stack.pop();
            System.out.print(str+" "); //three two one
        }
    }
}

三、Map集合

（1）Map看起来像是一个多行两列的表格。以key-value对的形式存放元素

（2）key可以看成是value的索引，在Map中key不允许重复（重复是依靠key的equals判断）

（3）常用的实现类为：HashMap

1、Map集合常用方法

Map集合的常用方法

方法	功能
V put(K k,V v)	将给定的key-value对存入Map。由于Map要求key不允许重复，所以使用Map已有的key存入一个新的value时的操作是替换value。那么返回值为该key原来对应的value。若是一个新的key，则返回值为null
V get(K k)	根据给定的key获取对应的value，若当前Map中没有给定的key，则返回值为null
V remove(K k)	删除给定的key所对应的key-value对，返回值为被删除的key-value对中的value

import java.util.HashMap;
import java.util.Map;

/**
 * java.util.Map
 * Map看起来像是一个多行两列的表格。以key-value对的形式存放元素
 * 在Map中key不允许重复（重复是依靠key的equals判断）
 * 常用的实现类为：HashMap
 */
public class MapDemo {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();

        /*
        V put(K k,V v)
        将给定的key-value对存入Map
        由于Map要求key不允许重复，所以使用Map已有的key存入一个新的value时的操作是替换value
        那么返回值为该key原来对应的value。若是一个新的key，则返回值为null
         */
        Integer value = map.put("语文",90);
        System.out.println(value); //null
        map.put("语文",45);
        map.put("数学",23);
        map.put("英语",75);
        map.put("物理",45);
        map.put("化学",45);
        System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=45, 英语=75}

        value = map.put("语文",90);
        System.out.println(value); //45
        System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=90, 英语=75}

        /*
        V get(K k)
        根据给定的key获取对应的value，若当前Map中没有给定的key，则返回值为null
         */
        value = map.get("数学");
        System.out.println("数学："+value); //数学：23
        value = map.get("体育");
        System.out.println("体育："+value); //体育：null

        /*
        V remove(K k)
        删除给定的key所对应的key-value对
        返回值为被删除的key-value对中的value
         */
        value = map.remove("数学");
        System.out.println(value); //23
        System.out.println(map); //{物理=45, 化学=45, 语文=90, 英语=75}
    }
}

2、HashMap基本原理

在这里插入图片描述

3、重写equals和hashCode方法

import java.util.Objects;

/**
 * 当一个类的实例作为HashMap的key时，它的equals方法与hashcode方法的重写直接影响着散列表（HashMap）的查询性能
 * 在API文档中Object对这两个方法的重写做了说明：
 * 当我们重写一个类的equals方法时，就应当连着重写hashcode方法
 * 这两个方法重写应当遵循：
 * 1：一致性，当两个对象equals比较为true时，hashcode方法返回的数字必须相等
 * 反过来虽然不是必须的，也应当遵循，否则在HashMap中会形成链表影响性能
 * 所以两个对象hashcode值相同，equals比较也应当为true
 * 2：稳定性：hashcode方法多次调用后返回的数字应当相同，不应是一个变化的值
 * 除非参与equals比较的属性值发生了改变
 */
public class Key {
    private int x;
    private int y;

    public Key(int x, int y){
        super();
        this.x = x;
        this.y = y;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Key keyDemo = (Key) o;
        return x == keyDemo.x && y == keyDemo.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

4、HashMap应用

（1）Map集合是面向查询优化的数据结构，在大数据量情况下有优良的查询性能

（2）用于根据Key检索value的业务场景：

用户登录数据缓冲：用户名是Key，用户对象是value，在登录验证时根据用户名快速查询用户信息
登录会话状态保持：在网站编程中，用户会话状态保持经常采用Map存储，可以快速在数以万计的信息中快速确认用户是否已经登录

5、HashMap性能调优

（1）Capacity：容量，hash表里bucket（桶）的数量，也就是散列数组大小

（2）Intital capacity：初始容量，创建hash表时，初始bucket的数量，默认构建容量是16，也可以使用特定容量

（3）Load factor：加载因子，默认值0.75（就是75%），当向散列表增加数据时如果size/capacity的值大于Load factor则发生扩容并且重新散列（rehash）

性能优化：加载因子较小时，散列查栈性能会提高，同时也浪费了散列桶空间容量。0.75是性能和空间相对平衡结果。在创建散列表时指定合理容量，减少rehash提高性能

6、Map遍历（迭代）

（1）遍历所有的key

（2）遍历所有的key-value对

（3）遍历所有的value（相对不常用

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 遍历Map三种方式：遍历所有的key、遍历所有的key-value对、遍历所有的value（相对不常用）
 */
public class MapDemo01 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("语文",45);
        map.put("数学",23);
        map.put("英语",75);
        map.put("物理",45);
        map.put("化学",45);
        System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=45, 英语=75}

        /*
        遍历所有的key
        Set<K> keySet()
        该方法会将当前Map中所有的key存入一个Set集合后返回
        那么遍历该集合就等于遍历了所有的key
         */
        Set<String> keySet = map.keySet();
        for(String key:keySet){
            System.out.print("key:"+key+"   "); //key:物理   key:数学   key:化学   key:语文   key:英语
        }
        System.out.println();

        /*
        遍历每一组键值对
        Map中每一组键值对都是由Map的内部类：
        java.util.Map.Entry的一个实例表示的。
        Entry有两个方法：getKey、getValue，可以分别获取这一组键值对中的key与value

        Set<Entry> entrySet
        该方法会将Map中每一组键值对（Entry实例）存入一个Set集合后返回
         */
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for (Map.Entry<String,Integer> e:entrySet){
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.print(key+":"+value+"   "); //物理:45   数学:23   化学:45   语文:45   英语:75
        }
        System.out.println();

        /*
        遍历所有的value
        Collection values()
        该方法会将当前Map中所有的value存入一个集合后返回
         */
        Collection<Integer> values = map.values();
        for(Integer value : values){
            System.out.print("value:"+value+"   "); //value:45   value:23   value:45   value:45   value:75
        }
    }
}

小鹿快跑～

关注

5
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java API（十五）：Queue队列、Deque栈、Map集合

包括Queue接口及LinkedList实现、Queue常用方法、Deque接口及LinkedList实现、Deque常用方法、Map集合常用方法、HashMap基本原理、重写equals和hashCode方法、HashMap应用、HashMap性能调优、Map遍历（迭代）。
复制链接

扫一扫