Java API(十五):Queue队列、Deque栈、Map集合

文章目录

  • Java API
  • 一、Queue队列
    • 1、Queue接口及LinkedList实现
    • 2、Queue常用方法
  • 二、Deque栈
    • 1、Deque接口及LinkedList实现
    • 2、Deque常用方法
  • 三、Map集合
    • 1、Map集合常用方法
    • 2、HashMap基本原理
    • 3、重写equals和hashCode方法
    • 4、HashMap应用
    • 5、HashMap性能调优
    • 6、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();

Java API(十五):Queue队列、Deque栈、Map集合_第1张图片

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文档中的回退和前进)

Java API(十五):Queue队列、Deque栈、Map集合_第2张图片

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基本原理

Java API(十五):Queue队列、Deque栈、Map集合_第3张图片

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 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 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
        }
    }
}

你可能感兴趣的:(Java知识点,java)