HashMap 的 7 种遍历方式与性能分析

news2024/9/21 0:30:57

随着 JDK 1.8 Streams API 的发布，使得 HashMap 拥有了更多的遍历的方式，但应该选择那种遍历方式？反而成了一个问题。

本文先从 HashMap 的遍历方法讲起，然后再从性能、原理以及安全性等方面，来分析 HashMap 各种遍历方式的优势与不足，本文主要内容如下图所示：

HashMap遍历

HashMap遍历从大的方向来说，可分为以下4类：

  1. 迭代器（Iterator）方式遍历；

  2. For Each方式遍历；

  3. Lambda表达式遍历（JDK1.8+)

  4. Streams API遍历（JDK1.8+)

但每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为以下 7 种：

  1. 使用迭代器(Iterator)EntrySet的方式进行遍历；

  2. 使用迭代器（Iterator)KeySet的方式进行遍历；

  3. 使用 For Each EntrySet 的方式进行遍历；

  4. 使用 For Each KeySet 的方式进行遍历；

  5. 使用 Lambda 表达式的方式进行遍历；

  6. 使用 Streams API 单线程的方式进行遍历；

  7. 使用 Streams API 多线程的方式进行遍历。

迭代器EntrySet

public class HashMapTest{
    public static void main(String[] args){
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群"); 
        //遍历
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

迭代器 KeySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        Iterator<Integer> iterator = map.keySet().iterator();
        while(iterator.hasNext()){
            Integer key = iterator.next();
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

ForEach EntrySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        for(Map.EntrySet<Integer,String> entry: map.entrySet()){
            System.out.print(entry.getKey());
            System.out.print(entry.getValue());
        }
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

ForEach KeySet

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        for(Integer key: map.keySet()){
            System.out.print(key);
            System.out.print(map.get(key));
        }
   }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Lambda

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        map.forEach((key, value)->{
            System.out.print(key);
            System.out.print(value);
        });
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Streams API 单线程

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        map.forEach((key, value)->{
            System.out.print(key);
            System.out.print(value);
        });
    }
}

以上程序的执行结果为：1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群

Streams API多线程

public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        map.forEach((key, value)->{
            System.out.print(key);
            System.out.print(value);
        });
    }
}

以上程序的执行结果为：4 MyBatis framework 5 Java中文社群 1 Java 2 JDK 3 Spring Framework

性能测试

接下来我们使用Oracle官方提供的性能测试工具JMH(Java Microbenchmark Harness, JAVA 微基准测试套件)来测试一下这 7 种循环的性能。

首先，我们先要引入JMH框架，在pom.xml文件中添加如下配置：

<!--https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.23</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.23</version>
    <scope>provided</scope>
</dependency>

然后编写测试代码，如下所示：

package com.example.hashmaptest;
​
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;
​
/**
 * @author allycoding
 * @Date: 2022/8/8 21:37
 */
@BenchmarkMode(Mode.Throughput)//测试类型：吞吐量
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) //预热 2 轮，每次 1s
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS) //测试5轮，每次3s
@Fork(1) //fork 1个线程
@State(Scope.Thread) //每个测试线程一个实例
public class HashMapCycle {
​
    static Map<Integer, String> map = new HashMap(){
        {
            // 添加数据
            for(int i=0;i<10;i++){
                this.put(i,"val:"+i);
            }
        }
    };
​
    public static void main(String[] args) throws RunnerException {
        //启动基准测试
        Options opt = new OptionsBuilder()
                .include(HashMapCycle.class.getSimpleName()) //要导入的测试类
                .output("./jmh-map.log") //输出测试结果的文件
                .build();
        new Runner(opt).run();//执行测试
    }
​
    @Benchmark
    public void entrySet(){
        //遍历
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
​
    @Benchmark
    public void keySet(){
        //遍历
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            Integer key = iterator.next();
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
​
    @Benchmark
    public void forEachEntrySet(){
        //遍历
        for(Map.Entry<Integer, String> entry: map.entrySet()){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
​
    @Benchmark
    public void forEachKeySet(){
        //遍历
        for(Integer key:map.keySet()){
            System.out.println(key);
            System.out.println(map.get(key));
        }
    }
​
    @Benchmark
    public void lambda(){
        //遍历
        map.forEach((key, value) -> {
            System.out.println(key);
            System.out.println(value);
        });
    }
​
    @Benchmark
    public void streamApi(){
        //单线程遍历
        map.entrySet().stream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
​
    @Benchmark
    public void parallelStreamApi(){
        //多线程遍历
        map.entrySet().parallelStream().forEach((entry) -> {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
​
}

所有被添加了 @Benchmark 注解的方法都会被测试，测试结果如下：

其中 Score 列表示平均执行时间， ± 符号表示误差。从以上结果可以看出，如果加上后面的误差值的话，可以得出的结论是，除了并行循环的 parallelStream 性能比极高之外（多线程方式性能肯定比较高），其他方式的遍历方法在性能方面几乎没有任何差别。

性能原理分析

要理解性能测试的结果，我们需要把所有遍历代码通过 javac，编译成字节码来看具体的原因，编译之后我们使用 Idea 打开字节码信息，内容如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
​
package com.example;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
​
public class HashMapTest {
    static Map<Integer, String> map = new HashMap() {
        {
            for(int var1 = 0; var1 < 2; ++var1) {
                this.put(var1, "val:" + var1);
            }
​
        }
    };
​
    public HashMapTest() {
    }
​
    public static void main(String[] var0) {
        entrySet();
        keySet();
        forEachEntrySet();
        forEachKeySet();
        lambda();
        streamApi();
        parallelStreamApi();
    }
​
    public static void entrySet() {
        Iterator var0 = map.entrySet().iterator();
​
        while(var0.hasNext()) {
            Entry var1 = (Entry)var0.next();
            System.out.println(var1.getKey());
            System.out.println((String)var1.getValue());
        }
​
    }
​
    public static void keySet() {
        Iterator var0 = map.keySet().iterator();
​
        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1);
            System.out.println((String)map.get(var1));
        }
​
    }
​
    public static void forEachEntrySet() {
        Iterator var0 = map.entrySet().iterator();
​
        while(var0.hasNext()) {
            Entry var1 = (Entry)var0.next();
            System.out.println(var1.getKey());
            System.out.println((String)var1.getValue());
        }
​
    }
​
    public static void forEachKeySet() {
        Iterator var0 = map.keySet().iterator();
​
        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1);
            System.out.println((String)map.get(var1));
        }
​
    }
​
    public static void lambda() {
        map.forEach((var0, var1) -> {
            System.out.println(var0);
            System.out.println(var1);
        });
    }
​
    public static void streamApi() {
        map.entrySet().stream().forEach((var0) -> {
            System.out.println(var0.getKey());
            System.out.println((String)var0.getValue());
        });
    }
​
    public static void parallelStreamApi() {
        map.entrySet().parallelStream().forEach((var0) -> {
            System.out.println(var0.getKey());
            System.out.println((String)var0.getValue());
        });
    }
}

从结果可以看出，除了 Lambda 和 Streams API 之外，通过迭代器循环和 for 循环的遍历的 EntrySet 最终生成的代码是一样的，他们都是在循环中创建了一个遍历对象 Entry ，如下所示：

public static void entrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}
public static void forEachEntrySet() {
    Iterator var0 = map.entrySet().iterator();
    while(var0.hasNext()) {
        Entry var1 = (Entry)var0.next();
        System.out.println(var1.getKey());
        System.out.println((String)var1.getValue());
    }
}

而通过迭代器和 for 循环遍历的 KeySet 代码也是一样的，如下所示：

public static void keySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
} 
public static void forEachKeySet() {
    Iterator var0 = map.keySet().iterator();
    while(var0.hasNext()) {
        Integer var1 = (Integer)var0.next();
        System.out.println(var1);
        System.out.println((String)map.get(var1));
    }
}

可以看出 KeySet 在循环中创建了一个 Integer 的局部变量，并且值是从 map 对象中直接获取的。

所以通过字节码来看，使用 EntrySet 和 KeySet 代码差别不是很大，并不像网上说的那样 KeySet 的性能远不如 EntrySet，因此从性能的角度来说 EntrySet 和 KeySet 几乎是相近的，但从代码的优雅型和可读性来说，还是推荐使用 EntrySet。

安全性测试

从上面的性能测试结果和原理分析，我想大家应该选用那种遍历方式，已经心中有数的，而接下来我们就从「安全」的角度入手，来分析那种遍历方式更安全。

我们把以上遍历划分为四类进行测试：迭代器方式、For 循环方式、Lambda 方式和 Stream 方式，测试代码如下。

迭代器方式

Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
    Map.Entry<Integer, String> entry = iterator.next();
    if (entry.getKey() == 1) {
        // 删除
        System.out.println("del:" + entry.getKey());
        iterator.remove();
    } else {
        System.out.println("show:" + entry.getKey());
    }
}

以上程序的执行结果：

show:0

del:1

show:2

测试结果：迭代器中循环删除数据安全。

For循环方式

for (Map.Entry<Integer, String> entry : map.entrySet()) {
  if (entry.getKey() == 1) {
    *// 删除*
    System.out.println("del:" + entry.getKey());
    map.remove(entry.getKey());
  } else {
    System.out.println("show:" + entry.getKey());
  }
}

Lambda方式

map.forEach((key, value) -> {
    if (key == 1) {
        System.out.println("del:" + key);
        map.remove(key);
    } else {
        System.out.println("show:" + key);
    }
});

Lambda删除的正确方式：

map.forEach((key, value) -> {
    if (key == 1) {
        System.out.println("del:" + key);
        map.remove(key);
    } else {
        System.out.println("show:" + key);
    }
});

以上程序的执行结果：

show:0

show:2

从上面的代码可以看出，可以先使用 Lambda 的 removeIf 删除多余的数据，再进行循环是一种正确操作集合的方式。

Stream 方式

map.entrySet().stream().forEach((entry) -> {
    if (entry.getKey() == 1) {
        System.out.println("del:" + entry.getKey());
        map.remove(entry.getKey());
    } else {
        System.out.println("show:" + entry.getKey());
    }
});

Stream循环的正确方式：

map.entrySet().stream().filter(m->1 != m.getKey()).forEach((entry) -> {
    if(entry.getKey()==1){
        System.out.println("del:"+entry.getKey())
    } else {
        System.out.println("show:"+entry.getKey());
    }
});

以上程序的执行结果：

show:0

show:2

从上面的代码可以看出，可以使用Stream的filter过滤无用的数据，再进行遍历也是一种安全的操作集合的方式。

小结

我们不能在遍历中使用集合 map.remove() 来删除数据，这是非安全的操作方式，但我们可以使用迭代器的 iterator.remove() 的方法来删除数据，这是安全的删除集合的方式。同样的我们也可以使用 Lambda 中的 removeIf 来提前删除数据，或者是使用 Stream 中的 filter 过滤掉要删除的数据进行循环，这样都是安全的，当然我们也可以在 for 循环前删除数据在遍历也是线程安全的。

总结

本文我们讲了 HashMap 4 大类（迭代器、for、lambda、stream）遍历方式，以及具体的 7 种遍历方法，除了 Stream 的并行循环，其他几种遍历方法的性能差别不大，但从简洁性和优雅性上来看，Lambda 和 Stream 无疑是最适合的遍历方式。除此之外我们还从「安全性」方面测试了 4 大类遍历结果，从安全性来讲，我们应该使用迭代器提供的 iterator.remove() 方法来进行删除，这种方式是安全的在遍历中删除集合的方式，或者使用 Stream 中的 filter 过滤掉要删除的数据再进行循环，也是安全的操作方式。

总体来说，本文提供了 7 种方式肯定也不是最全的，我是想给读者在使用 HashMap 时多一种选择，然而选择那一种形式的写法，要综合：性能、安全性、使用环境的 JDK 版本以及优雅性和可读性等方面来综合考虑。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/512248.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++实践模拟（vector list，反向迭代器)

C++实践模拟（vector list，反向迭代器)

vector与list的模拟实现&#xff0c;主要是在实现过程中体会模板在编程中的应用&#xff0c;了解C中迭代器的底层实现机制&#xff0c;因此笔者会将重点内容放在模板应用&#xff0c;迭代器底层实现&#xff0c;反向迭代器&#xff0c;迭代器失效等方面&#xff0c;至于其他的增…
阅读更多...
Webpack5构建性能优化：构建耗时从150s到60s再到10s | 京东云技术团队

Webpack5构建性能优化：构建耗时从150s到60s再到10s | 京东云技术团队

作者&#xff1a;京东科技 牛志伟 近期对Webpack5构建性能进行了优化&#xff0c;构建耗时从150s到60s再到10s&#xff0c;下面详细讲解下优化过程。 优化前现状 1.历史项目基于Vue3 Webpack5技术栈&#xff0c;其中webpack配置项由开发者自己维护&#xff08;没有使用vue/…
阅读更多...
有哪些入耳舒服的蓝牙耳机？公认佩戴舒适度最高蓝牙耳机

有哪些入耳舒服的蓝牙耳机？公认佩戴舒适度最高蓝牙耳机

数码科技市场日益发展的更加智能化&#xff0c;日常所接触到的各类产品都开始往智能化发展&#xff0c;鲜为人知的蓝牙耳机一直是不过时的&#xff0c;因为小巧易携带深受大众喜欢&#xff0c;下面整理了几款佩戴舒适的蓝牙耳机给大家。 一、南卡小音舱Lite2蓝牙耳机 售价&am…
阅读更多...
java语法（一）基本概念、数据类型、字符串类、集合、Stream流、异常处理、文件处理IO流

java语法（一）基本概念、数据类型、字符串类、集合、Stream流、异常处理、文件处理IO流

文章目录 java程序运行流程JDK、JRE、JVM的关系 java数据类型基本数据类型基本数据类型之间的转换 引用数据类型数组类Java Bean重写 equals和hashcode 接口接口与类之间的关系 内置包装类装箱和拆箱包装类的应用Object类toString()equals()方法getClass() 方法接收任意引用类型…
阅读更多...
QT如何打包生成独立可执行.exe文件

QT如何打包生成独立可执行.exe文件

一、将QT程序使用Release编译 二、新建一个文件夹&#xff0c;将Release编译生成的exe文件复制到新建文件夹中 先找到Release编译生成的exe文件夹位置&#xff0c;与项目创建的文件夹有关&#xff1a; 临时文件夹 --》 release --》 xx .exe文件 比如我的这个就是在D:\QtPro\b…
阅读更多...
vulnhub-RAVEN:2(MYSQL-UDF提权，手工提权/工具自动提权)

vulnhub-RAVEN:2(MYSQL-UDF提权，手工提权/工具自动提权)

镜像下载&#xff1a;Raven: 2 ~ VulnHub 实验环境&#xff1a;kali&#xff1a;192.168.78.128 vulnhub镜像&#xff1a;192.168.78.133 1、kali查看本地ip地址&#xff0c;以便使用nmap扫描ip段存活主机 2、nmap扫描IP段&#xff0c;发现靶机的IP地址为192.168.78.133 4、访问…
阅读更多...
十款常用的Jupyter Notebook Extensions插件

十款常用的Jupyter Notebook Extensions插件

Table of Contents&#xff1a;一款可以在笔记本左侧生成目录树的插件。它可以让你快速导航到不同的章节&#xff0c;也可以折叠和展开各级标题。Codefolding&#xff1a;一款可以折叠代码块的插件。它可以让你隐藏不需要查看的代码&#xff0c;只显示关键的部分&#xff0c;提…
阅读更多...
【Linux】Linux的文件操作

【Linux】Linux的文件操作

文件操作对于不少编程初学者来说都是一件头疼的事情&#xff0c;不管你学习的是什么编程语言&#xff0c;C/C/Java/Go/Python ,因为我们学习到的文件相关的操作对你来说都是一个黑盒&#xff0c;我们只是知道我们应该怎么使用相应的文件函数进行操作&#xff0c;而对于内部的实…
阅读更多...
Linux线程同步（2）——初识互斥锁

Linux线程同步（2）——初识互斥锁

互斥锁&#xff08;mutex&#xff09;又叫互斥量&#xff0c;从本质上说是一把锁&#xff0c;在访问共享资源之前对互斥锁进行上锁&#xff0c;在访问完成后释放互斥锁&#xff08;解锁&#xff09;&#xff1b;对互斥锁进行上锁之后&#xff0c;任何其它试图再次对互斥锁进行加…
阅读更多...
C语言：青蛙跳台与汉诺塔问题

C语言：青蛙跳台与汉诺塔问题

青蛙跳台 原理&#xff1a;一只青蛙跳n个台阶&#xff0c;青蛙可以一次性跳1个台阶&#xff0c;也可以跳2个台阶&#xff0c;问&#xff0c;有多少种跳法&#xff0c;可以跳过n个台阶。 分析&#xff1a;青蛙跳台本质上是递归问题&#xff0c;那它为什么是递归问题呢&#xff…
阅读更多...
cleanmymac在哪下载?中文官网安装教程

cleanmymac在哪下载?中文官网安装教程

CleanMyMac是一个系统清理工具&#xff0c;删除系统缓存文件 , 多余的应用程序语言包 , PowerPc软件运行库等。 是个给你的硬盘瘦身的好工具。 系统&#xff1a;macOS 10.14&#xff08;在10.15以及Big Sur中的安装激活教程相同&#xff09;登录CleanMyMac X下载页面&#xff0…
阅读更多...
第十四章_缓存双写一致性之更新策略探讨

第十四章_缓存双写一致性之更新策略探讨

缓存双写一致性的理解 如果redis中有数据 需要和数据库中的值相同 如果redis中无数据 数据库中的值要是最新值&#xff0c;且准备回写redis 缓存按照操作来分&#xff0c;细分2种 只读缓存 读写缓存 同步直写策略 写数据库后也同步写redis缓存&#xff0c;缓存和数据库…
阅读更多...
01:mysql基本操作---DDL

01:mysql基本操作---DDL

目录 前言: 1:SQL分类 2:类型 3:sql表的创建----简单版本 前言: 1:SQL语句可以单行或多行书写&#xff0c;以分号结尾。 2:SQL语句可以使用空格/缩进来增强语句的可读性。 3:MySQL数据库的SQL语句不区分大小写&#xff0c;关键字建议使用大写 4:注释: 单行注释:-- 注释…
阅读更多...
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）

RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）

消费模式 参考官网&#xff1a;https://www.rabbitmq.com/getstarted.html 简单模式 Simple, 参考RabbitMQ详解&#xff08;二&#xff09;&#xff1a;消息模式 Simple(简单)模式 简单模式是最简单的消息模式&#xff0c;它包含一个生产者、一个消费者和一个队列。生产者向队…
阅读更多...
量化散户交易数据：追涨爆亏99%，杀跌少赚28倍？| 追涨杀跌一时爽，散户钱包火葬场？【邢不行】

量化散户交易数据：追涨爆亏99%，杀跌少赚28倍？| 追涨杀跌一时爽，散户钱包火葬场？【邢不行】

你第一次炒股的经历是不是这样的&#xff1a; 你有一个朋友&#xff0c;他说在XX股票上大赚了一笔&#xff0c;你听后是既羡慕又不服。 于是你下载了炒股软件&#xff0c;看了眼这只股票&#xff0c;有点心动。但由于没有交易经验&#xff0c;股价又确实涨了不少&#xff0c;…
阅读更多...
Python基础入门编程代码练习（四）

Python基础入门编程代码练习（四）

一、遍历列表 通过 input输入3个人信息&#xff0c;每个人有姓名和年龄&#xff0c;将信息存入字典中&#xff0c;并将将字典存入列表。 遍历列表&#xff0c;打印每个人的信息&#xff0c;打印格式如下&#xff1a; 张三 20李四 22王五 23 1. 输入三个人的信息 (输入 inpu…
阅读更多...
qiankun 微前端 demo（Vue2）

qiankun 微前端 demo（Vue2）

前言 这是我最近刚开始学微前端&#xff08;qiankun框架&#xff09;做的一个小demo&#xff0c;做的时候还是遇到很多问题的&#xff0c;在网上也是看了很多别人的Blog&#xff0c;最后也是磨出来了&#x1f602;&#x1f602;&#x1f602;&#xff1b;这篇文章总统分为分为…
阅读更多...
国产麒麟操作系统 myCat1.6读写分离

国产麒麟操作系统 myCat1.6读写分离

我的环境是麒麟操作系统&#xff0c;我只配置读写分离 一、使用说明&#xff0c;java环境&#xff0c;解压就能用 下载地址https://raw.githubusercontent.com/MyCATApache/Mycat-download/master/1.6-RELEASE/Mycat-server-1.6-RELEASE-20161028204710-linux.tar.gz mycat 是j…
阅读更多...
OJ刷题之旅

OJ刷题之旅

题目 现在给你两种颜色的箩筐&#xff0c;需要的时候&#xff0c;就把一个个大小差一圈的筐叠上去&#xff0c;使得从上往下看时&#xff0c;边筐花色交错。这个工作现在要让计算机来完成&#xff0c;得看你的了。 输入 输入是一个个的三元组&#xff0c;分别是&#xff0c;外…
阅读更多...
SpringCloud使用SkyWalking实现分布式链路追踪1

SpringCloud使用SkyWalking实现分布式链路追踪1

文章目录 一、MicrometerTracingBrave(Sleuth)链路追踪1、MicrometerTracingBrave和Zipkin的概论2、Docker搭建Zipkin服务3、MicrometerTracingBrave和Zipkin实现链路追踪 二、SkyWaking服务的安装与使用1、SkyWalking的概论2、Java探针的环境搭建3、Java探针实现日志监控4、Sk…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023