java中stack、queue、deque、hashmap和List的操作

已于 2023-02-03 14:49:21 修改
阅读量587 收藏 1
点赞数 1
分类专栏： java 文章标签： java 算法
于 2022-07-19 15:26:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23858785/article/details/125873159
版权

java中stack、queue、deque、hashmap和List的操作

本文目录

Stack

基本操作
Stack<String> stack = new Stack<>();

// 为空返回true，不为空返回false
stack.isEmpty()

// 添加元素
stack.push()

// 移除栈顶
stack.pop()

// 获取栈顶值，为空返回null，元素不出栈
stack.peek()

// 为空返回0，不为空返回一个大于1的整数
stack.size()

// 对元素进行排序，如果不指定则按照Z-A排序
stack.sort(null);

// 查找一个对象是否在堆栈中存在(true/false)
stack.contains("February");

// 栈底元素位0，输出指定位置的元素
stack.elementAt(0));

// 返回该元素的位置(栈顶为1)，否则返回-1
stack.search("April");
示例
public static void stackTest() {
    String[] months = { "January", "February", "March", "April", "May", "June", "July", "August", "September",
                "October", "November", "December" };
    Stack<String> stack = new Stack<>();
    for(int i = 0; i < months.length; i ++){
        stack.push(months[i]);
    }
    stack.sort(null);
    System.out.println(stack.search("April"));
    System.out.println(stack.contains("April"));
    System.out.println(stack.elementAt(0));//输出指定位置的元素
    System.out.println(stack.size());
    for(int i = 0; i < months.length; i ++){
        System.out.println(stack.pop());
    }
}

// 结果
12
true
April
12
September
October
November
May
March
June
July
January
February
December
August
April
遍历

  • 1 增强for循环

    for(Object o : stack) {
    System.out.println(o);
}

  • 2 while循环条件判断

    while(!stack.isEmpty()) {
    System.out.println(stack.pop());
}

  • 3 Iterator迭代器

    Iterator it = stack.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

queue

基本操作
Queue<String> queue = new LinkedList<>();

// 将元素添加到队尾，如果成功，则返回true，否则返回false
offer()

// 将队首的元素删除，并返回该元素，如果队列为空，则返回null
poll()

// 返回队首的元素，但不进行删除操作，如果队列为空，则返回null
peek()

// 将指定的元素插入队列，成功返回true，否则异常
add()

// 返回队列的开头。如果队列为空，则引发异常。
element()

// 返回并删除队列的头部，队列为空，则引发异常
remove()
示例
public static void queueTest() {
    Queue<String> queue = new LinkedList<>();

    queue.offer("one");
    queue.offer("two");
    queue.offer("three");
    queue.offer("four");
    System.out.println(queue);

    //从队首取出元素并删除
    String poll = queue.poll();
    System.out.println(poll);
    System.out.println(queue);

    //从队首取出元素但是不删除
    String peek = queue.peek();
    System.out.println(peek);
    System.out.println(queue);

    //遍历队列，这里要注意，每次取完元素后都会删除
    //整个队列会变短，所以只需要判断队列的大小即可
    while(queue.size() > 0) {
        System.out.println(queue.poll());
    }

}

// 结果
[one, two, three, four]
one
[two, three, four]
two
[two, three, four]
two
three
four
遍历

  • 1 增强for循环

    for (Object o : queue) {
    System.out.println(o);
}

  • 2 while循环条件判断

    while (!queue.isEmpty()) {
    System.out.println(queue.poll());
}

  • 3 Iterator迭代器

    Iterator it = queue.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

deque

基本操作
Deque<String> deque = new ArrayDeque<>();

// 在双端队列的开头添加指定的元素。如果双端队列已满，则返回false
offerFirst()

// 在双端队列的末尾添加指定的元素。如果双端队列已满，则返回false
offerLast()

// 返回双端队列的第一个元素。如果双端队列为空，则返回null。
peekFirst() 

// 返回双端队列的最后一个元素。如果双端队列为空，则返回null
peekLast()

// 返回并删除双端队列的第一个元素。如果双端队列为空，则返回null
pollFirst()

// 返回并删除双端队列的最后一个元素。如果双端队列为空，则返回null
pollLast()

// 在双端队列的开头添加指定的元素，如果双端队列已满，则引发异常
addFirst() 

// 在双端队列的末尾添加指定的元素，如果双端队列已满，则引发异常
addLast()

// 返回双端队列的第一个元素。如果双端队列为空，则引发异常
getFirst()

// 返回双端队列的最后一个元素。如果双端队列为空，则引发异常
getLast()

// 返回并删除双端队列的第一个元素。如果双端队列为空，则引发异常
removeFirst()

// 返回并删除双端队列的最后一个元素。如果双端队列为空，则引发异常
removeLast()

以下是Deque接口提供的用于实现堆栈的方法：

push() - 在双端队列的开头添加元素

pop() - 从双端队列的开头删除元素

peek() - 从双端队列的开头返回一个元素
示例
public static void addStrings(String num1, String num2) {
    // 使用ArrayDeque类创建Deque
    Deque<Integer> numbers = new ArrayDeque<>();

    //添加元素到Deque
    numbers.offer(1);
    numbers.offerLast(2);
    numbers.offerFirst(3);
    System.out.println("Deque: " + numbers);

    //访问Deque的元素
    int firstElement = numbers.peekFirst();
    System.out.println("第一个元素： " + firstElement);

    int lastElement = numbers.peekLast();
    System.out.println("最后一个元素： " + lastElement);

    //从Deque 移除元素
      int removedNumber1 = numbers.pollFirst();
    System.out.println("移除第一个元素： " + removedNumber1);

    int removedNumber2 = numbers.pollLast();
    System.out.println("移除最后一个元素： " + removedNumber2);

    System.out.println("更新后的Deque： " + numbers);

}

// 结果
Deque: [3, 1, 2]
第一个元素： 3
最后一个元素： 2
移除第一个元素： 3
移除最后一个元素： 2
更新后的Deque： [1]
遍历

  • 1 增强for循环

    for(Object o : deque) {
    System.out.println(o);
}

  • 2 while循环条件判断

    while(deque.pollLast()!=null) {
    System.out.println(deque.pollLast());
}

while(!deque.isEmpty()) {
    System.out.println(deque.pollFirst());
}

  • 3 Iterator迭代器

    Iterator it = deque.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

hashmap

示例
public static void addStrings() {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    System.out.println(Sites);
    System.out.println(Sites.size());

    // 输出 key 和 value
    for (Integer i : Sites.keySet()) {
        System.out.println("key: " + i + " value: " + Sites.get(i));
    }
    // 返回所有 value 值
    for (String value: Sites.values()) {
        // 输出每一个value
        System.out.print(value + ", ");
    }

    // 遍历
    for (Entry<Integer, String> entry : map.entrySet()) {
        entry.getKey();
        entry.getValue();
    }

    //通过 lambda 表达式使用 forEach()
    Sites.forEach((key, value) -> {
        System.out.print(key + "=" + value + " ");
    });

    System.out.println(Sites.get(3));

    Sites.remove(4);
    System.out.println(Sites);

    Sites.clear();
    System.out.println(Sites);

}  

// 结果
{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
4
key: 1 value: Google
key: 2 value: Runoob
key: 3 value: Taobao
key: 4 value: Zhihu
Google, Runoob, Taobao, Zhihu, Taobao
{1=Google, 2=Runoob, 3=Taobao}
{}

List

基础操作
List<String> list = new ArrayList<>();

// 添加
list.add(e);　

// 获取
list.get(index);　　

// 替换该索引位置的值
list.set(index, element); 

// 按照索引删除
list.remove(index);

// 按照元素内容删除　　
list.remove(Object o);

// 返回true或者false
list.contains(Object o);

// 第一个该值的索引
list.indexOf();

// 最后一个该值的索引
list.lastIndexOf();

// list中的元素数的和
list.size();

// 利用list中索引位置重新生成一个新的list（截取集合）
list.subList(fromIndex, toIndex);

// 对比两个list中的所有元素
list1.equals(list2));

// list是否为空
list.isEmpty()
ArrayList
List<String> list = new ArrayList<>();

ArrayList是使用的动态数组的数据结构
ArrayList 的特点是可重复的，有序的，顺序就是储存添加时候的数据
通过一个add 添加到集合，通过get(index)取出集合中的元素 下标的位置从0开始

LinkedList
LinkedList<String> list =new LinkedList<>();
list.addFirst("first");
list.addLast("last");

LinkedList使用的是双向链表的数据结构
插入方便，任意节点之间都可以插入，但是查询并不方便，效率不高

遍历
// for循环遍历，使用get()方法获取数据
for(int i = 0; i < list.size(); i++){
    System.out.println(list.get(i));
}

// for循环的简化版
for(String s: list) {
    System.out.println(s);
}

// 传统迭代器方式
Iterator<String> iter = list.iterator();
while(iter.hasNext()) {
    String s = iter.next();
    System.out.println(s);
}

// 传统迭代器方式
for(Iterator<String> it = list.iterator(); it.hasNext();){
    String value = it.next();
}

// forEach遍历
list.forEach(i -> {
    System.out.println(i);
});

// stream遍历
list.stream().forEach(i -> {
    System.out.println(i);
});
排序
// 排序
Collections.sort(list);

// 翻转（不排序）
Collections.sort(list);

// 自定义排序

List<String> list = new LinkedList<>();
list.add("3");
list.add("1");
list.add("2");
list.add("4");
list.add("5");

Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
});

list.stream().forEach(i -> {
    System.out.println(i);
});

// 输出
5
4
3
2
1
anjushi_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈（Stack）和队列（Queue）的基本操作
qq_19926581的博客
08-14 744
栈和队列的基本操作
list deque java_Java 集合 -- Deque
weixin_35715235的博客
02-16 233
使用 Deque我们知道，Queue是队列，只能一头进，另一头出。如果把条件放松一下，允许两头都进，两头都出，这种队列叫双端队列(Double Ended Queue)，学名Deque。Java集合提供了接口Deque来实现一个双端队列，它的功能是：既可以添加到队尾，也可以添加到队首；既可以从队首获取，又可以从队尾获取。比较一下Queue和Deque出队和入队的方法：Deque接口实际上扩展自Qu...
聊一聊java.util包中的Queue、Deque以及Stack分别是什么
最新发布
github_38727595的博客
04-09 1111
聊一聊队列、栈，以及java中的Queue，Deque，stack分别是什么
java集合中List、Set、Map、Queue、Deque、Stack、遍历方式及特点
qq_49194786的博客
05-14 2704
一、List（是一个接口）： 特点 list是最基础的一种集合，有序表（可重复）。 内部按照放入元素的先后顺序存放，可以索引查找。有两个实现类（Arraylist（内部采用数组来存储数据，也是最常用的）（所以array和Arraylist之间是可以相互转化的）和Linkedlist）。 Arraylist Linkedlist 获取元素速度很快 获取元素速度需从头开始查找 添加元素到末尾速度快- 添加元素到末尾速度很快 在指定位置删除或添加需要移动元素 在指定位置删除或添加不需要移动
Java 数据结构：Stack和Hashtable
wjl__ai__的博客
01-08 136
import java.util.Enumeration; import java.util.Hashtable; import java.util.Stack; public class Stack_Hashtable { public static void main(String[] args) { // Stack类 // 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。 // 堆栈只定义了默认构造函数，用来创建一个空栈。
Java中集合的简介(List Set Queue Deque Stack Map）
m0_66605858的博客
05-25 116
Java中集合的简介
Java中Collection、List、Set、Map之间的关系总结
08-26
LinkList允许null元素，通常在首部或者尾部操作，所以常被使用做堆栈(stack)、队列(queue)和双向队列(deque)。Vector类似于ArrayList，但Vector是同步的，Stack继承自Vector。 Set是一种不包含重复元素的Collection...
List,set,Map 的用法和区别
07-31
这些操作使 LinkedList 可被用作堆栈（stack）、队列（queue）或双向队列（deque）。ArrayList 类实现了可变大小的数组。它允许所有元素，包括 null。ArrayList 没有同步。size、isEmpty、get、set 方法运行时间为...
Java超详细！Java实现数据结构PPT课件
02-24
栈（Stack） 队列（Queue） 双端队列（Deque） 循环队列 哈希表（HashTable） 树形数据结构 二叉树（BinaryTree）、二叉搜索树（BinarySearchTree、BST） 平衡二叉搜索树（BalancedBinarySearchTree、BBST） AVL树...
超全Java集合框架讲解.md
08-11
超全Java集合框架讲解 - 超全Java集合框架讲解 - 集合框架总览 - Iterator Iterable ListIterator - Map 和 Collection 接口 - Map 集合体系详解 - HashMap - LinkedHashMap - TreeMap - WeakHashMap - ...
Java 基础核心总结 +经典算法大全.rar
11-08
LinkedList Queue接口Deque 接口 AbstractQueue 抽象类LinkedList ArrayDeque PriorityQueue 反射的思想及作用 反射的基本使用 获取类的 Class 对象构造类的实例化对象获取-个类的所有信息 获取类中的变量(Field) ...
Java 的栈(stack)和堆(heap)
it_zhang_PG的博客
08-20 227
1.Java 内存机制: (1)堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出（FIFO—first in first out）。栈，先进后出(FILO—First-In/Last-Out)。 (2)Java...
Java中集合遍历方式（List、Set、Queue、Deque、Stack、Map）
仙草不加料的博客
05-12 1190
什么是集合？通俗的讲，集合就是存储一组数据的容器，那么，相比较于同样是存储数据的数组，集合的优势就体现在集合的长度是可变的，而数组的长度是固定的。在我们常见的集合中，主要有两大类： Collection接口单列集合和Map双列集合（键值对集合）接口，其中实现Collection接口的集合主要有：List、Set、Queue（队列），实现Map接口的集合主要是HashMap、LinkedHashMap、TreeMap等。下面分别介绍这些集合是如何来便利的。 List集合（接口） 特点：有序，可重复 主
Java集合(三)—List和Queue集合
沧海一粟
10-09 1739
公众号： 菜鸡干Java 欢迎关注 文章目录Java集合—List集合ArrayList和VectorStack类(Vector的子类)固定长度的ListJava集合-Queue集合PriorityQueue类Deque接口与ArrayDequeLinkedList类线性表性能分析 Java集合—List集合 与Set集合不同，List集合是有序，可重复的，而且默认以添加顺序设置索引。List子接口是继承了Collection接口，则可以使用其中的方法。 特别的是List增加了根据索引插入、替换、删除.
java队列转集合_java中 列表，集合，数组之间的转换
weixin_35911221的博客
02-24 3965
java中 列表，集合，数组之间的转换java中 列表，集合，数组之间的转换java中 列表，集合，数组之间的转换List和Set都是接口，它们继承Collection(集合)，集合里面任何数据类型都可以添加List是有序的队列，可以用重复的元素；而Set是数学概念中的集合，不能有重复的元素。数组 长度固定 可存储任何数据类型 集合 长度可变(包括：list，set)可存储任何数据类...
java中使用队列:java.util.Queue
LvanNeo的专栏
04-18 1176
在java5中新增加了java.util.Queue接口，用以支持队列的常见操作。该接口扩展了java.util.Collection接口。 Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优 点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如
java队列转集合_Java-集合第四篇Queue集合
weixin_42508785的博客
02-24 597
1、什么是Queue模拟队列数据结构，先进先出(FIFO)，从队尾加元素，从队头取元素。2、Queue接口中定义了如下几个方法：1》void add(Object o)：将指定元素加入此队列的尾部。2》Object element()：获取队列头部的元素，但是不删除该元素。3》boolean offer(Object e)：将指定元素加入此队列的尾部。当使用有容量限制的队列时，此方法通常比add(...
java 使用queue_使用Queue - 廖雪峰 Java 教程
weixin_34017901的博客
02-21 560
队列(Queue)是一种经常使用的集合。Queue实际上是实现了一个先进先出(FIFO：First In First Out)的有序表。它和List的区别在于，List可以在任意位置添加和删除元素，而Queue只有两个操作：把元素添加到队列末尾；从队列头部取出元素。超市的收银台就是一个队列：在Java的标准库中，队列接口Queue定义了以下几个方法：int size()：获取队列长度；boolea...
Java arrayDeque分割List实现大批量导入功能
u010172714的专栏
01-12 939
今天做的导入功能出现了个bug，超过了2100条的数据做批量导入的时候，数据库会报错(小弟用的是sql server2012版本)。 这一块的问题在于sql server 2012不能支持超过2100个参数的语句，而我这里的做法是使用Mybatis的语句，一次把多个进行update。所以才会导致了这个错误。 于是，考虑到的解决方法就是切割这一个List,刚刚是打算分割成多个L
java中有哪些一对一的数据解构
07-14
在Java中，有许多一对一的数据解构，其中一些常见的包括： 1. Map（映射）：Map是一种键值对的数据结构，...Java中的LinkedList实现了List和Deque接口。 这些都是一对一的数据解构，它们在不同场景下有着不同的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

anjushi_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值