stream使用

stream流式计算

在Java1.8之前还没有stream流式算法的时候,我们要是在一个放有多个User对象的list集合中,将每个User对象的主键ID取出,组合成一个新的集合,首先想到的肯定是遍历,如下:

List<Long> userIdList = new ArrayList<>();
for (User user: list) {
     userIdList.add(user.id);
}

或者在1.8有了lambda表达式以后,我们会这样写:

List<Long> userIdList = new ArrayList<>();
list.forEach(user -> list.add(user.id));

List<Integer> userIdList = new ArrayList<>(Arrays.asList(0,1,2,3));
userIdList.forEach(item -> {//也可以做一些业务逻辑if(item.equals(1)){System.out.println("nihao");}
});

在有了stream之后,我们还可以这样写:

List<Long> userIdList = list.stream().map(User::getId).collect(Collectors.toList());

一行代码直接搞定,是不是很方便呢。那么接下来。我们就一起看一下stream这个流式算法的新特性吧。

由上面的例子可以看出,java8的流式处理极大的简化了对于集合的操作,实际上不光是集合,包括数组、文件等,只要是可以转换成流,我们都可以借助流式处理,类似于我们写SQL语句一样对其进行操作。java8通过内部迭代来实现对流的处理,一个流式处理可以分为三个部分:转换成流、中间操作、终端操作。如下图:

以集合为例,一个流式处理的操作我们首先需要调用stream()函数将其转换成流,然后再调用相应的中间操作达到我们需要对集合进行的操作,比如筛选、转换等,最后通过终端操作对前面的结果进行封装,返回我们需要的形式。

public class Demo {public static void main(String[] args) {User u1 = new User(1,"a",21);User u2 = new User(2,"b",22);User u3 = new User(3,"c",23);User u4 = new User(4,"d",24);User u5 = new User(5,"e",25);User u6 = new User(6,"f",26);//集合用来存储数据List<User> users = Arrays.asList(u1, u2, u3, u4, u5,u6);//stream流用来计算lambda表达式 链式编程 函数式接口 stream流式计算全都用到了users.stream().filter(u->{return u.getId()%2==0;})   //ID必须是偶数.filter(u->{return u.getAge()>23;})    //年龄大于23岁.map(u->{return u.getName().toUpperCase();})   //用户名首字母大写.sorted((uu1,uu2)->{return uu2.compareTo(uu1);})  //用户名字母倒着排序.limit(1)  //只输出一个用户.forEach(System.out::println);}
}
class User{int id;String name;int age;public User(){}public User(int id,String name,int age){this.id=id;this.name=name;this.age=age;}public int getId() {return id;}public int getAge() {return age;}public String getName() {return name;}@Overridepublic String toString() {return "user = "  + "{" + id +","+ name +"," + age + "}";}
}

下面讲对Stream进行详解

一、什么是stream

Java 8 是一个非常成功的版本,这个版本新增的Stream,配合同版本出现的Lambda ,给我们操作集合(Collection)提供了极大的便利。stream流实际上就是一个高级迭代器,可以对集合执行非常复杂的查找/筛选/过滤、排序、聚合和映射数据等操作。 

Java8 Stream 使用的是函数式编程模式,所以大部分流操作都支持 lambda 表达式作为参数,正确理解,应该说是接受一个函数式接口的实现作为参数。例如:

filter(s -> s.startsWith("c"));

以上面代码为例,可以对流进行中间操作或者终端操作

  • 中间操作:会再次返回一个流,所以,我们可以链接多个中间操作,注意这里是不用加分号的。上图中的filter 过滤,map 对象转换,sorted 排序等就属于中间操作。
  • 终端操作是对流操作的一个结束动作,一般返回 void 或者一个非流的结果。上图中的 forEach循环 就是一个终止操作。

Stream流有一些特性:

  1. Stream流不是一种数据结构,不保存数据,它只是在原数据集上定义了一组操作。
  2. 这些操作是惰性的,即每当访问到流中的一个元素,才会在此元素上执行这一系列操作。
  3. Stream不保存数据,故每个Stream流只能使用一次

二、不同类型的stream流

可以从各种数据源中创建 Stream 流,其中以 Collection 集合最为常见。如 List 和 Set 均支持 stream() 方法来创建顺序流(又称为串行流)或者是并行流。

先介绍串行流:

Arrays.asList("a1", "a2", "a3")   //asList源码就是一个ArrayList集合
        .stream() // 创建流
        .findFirst() // 找到第一个元素
        .ifPresent(System.out::println);  // 如果存在,即输出

 在集合上调用stream()方法会返回一个普通的 Stream 流。但是, 大可不必刻意地创建一个集合,再通过集合来获取 Stream 流,这种方式效率远远比上方的写法高,如下:

Stream.of("a1", "a2", "a3")
    .findFirst()
    .ifPresent(System.out::println);

可以通过 Stream.of() 从一堆对象中创建 Stream 流,除了常规对象流之外,Java 8还附带了一些特殊类型的流,用于处理原始数据类型int,long以及double,它们就是IntStream,LongStream还有DoubleStream。其中,IntStreams.range()方法还可以被用来取代常规的 for 循环,

IntStream.range(1, 4)       // 相当于 for (int i = 1; i < 4; i++) {}
    .mapToObj(i ->  + i*i)
    .forEach(System.out::println); 

将常规对象流转换为原始类型流,这个时候,中间操作 mapToInt()mapToLong() 以及mapToDouble,

 Stream.of("3", "2", "5")
        .mapToInt(Integer::parseInt) // 转成 int 基础类型类型流
        .forEach(System.out::println); 
        
        System.out.println("==============");
        
        Stream.of(1.0, 2.0, 3.0)
        .mapToInt(Double::intValue) // double 类型转 int
        .forEach(System.out::println); // for 循环打印

将原始类型流装换成对象流,可以使用 mapToObj(),

IntStream.range(1, 4)
    .mapToObj(i -> "a" + i) // for 循环 1->4, 拼接前缀 a
    .forEach(System.out::println);

三、Stream 流的处理顺序

中间操作的有个重要特性 —— 延迟性

 java的Stream以延迟性著称。他们被刻意设计成这样,即延迟操作,有其独特的原因:Stream就像一个黑盒,它接收请求生成结果。当我们向一个Stream发起一系列的操作请求时,这些请求只是被一一保存起来。只有当我们向Stream发起一个终端操作是,才会实际地进行计算。

举个例子:

Stream.of("d2", "a2", "b1", "b3", "c")
        .filter(s -> {
            System.out.println("filter: " + s);
            return true;
        });

上面这个代码没有终端操作,根本不会执行任何代码,不会有任何输出,于是添加 一行forEach终端操作如下就可以输出了

Stream.of("d2", "a2", "b1", "b3", "c")
        .filter(s -> {
            System.out.println("filter: " + s);
            return true;
        })
        .forEach(s -> System.out.println("forEach: " + s));

输出内容如下,filter和forEach的内容都能正常输出:
filter: d2
forEach: d2
filter: a2
forEach: a2
filter: b1
forEach: b1
filter: b3
forEach: b3
filter: c
forEach: c

这里很有趣,输出的结果却是随着链条垂直移动的,当 Stream 开始处理 d2 元素时,它实际上会在执行完 filter 操作后,再紧接着执行 forEach 操作,接着才会处理第二个元素。
注意有个方法是水平执行的,例如sorted,题外话:平常开发中对于这些中间操作方法的位置顺序也要注意下,正确放置也能大大提高性能,就像sql语句一样,where条件放置顺序也会影响查询速度。

为什么要设计成这样呢?

原因是出于性能的考虑。这样设计可以减少对每个元素的实际操作数,举个更清楚的例子,

Stream.of("d2", "a2", "b1", "b3", "c").map(s -> {System.out.println("map: " + s);return s.toUpperCase(); // 转大写}).anyMatch(s -> {System.out.println("anyMatch: " + s);return s.startsWith("A"); // 过滤出以 A 为前缀的元素});/*map: d2anyMatch: D2map: a2anyMatch: A2*/

方法依旧是先执行map,再anyMatch,终端操作 anyMatch()表示任何一个元素以 A 为前缀,返回为 true,就停止循环。从 d2 开始匹配,接着循环到 a2 的时候,返回为 true ,于是停止循环。所以这里只输出了4次,如果是水平移动呢,需要把map全部执行,5次,再执行anyMatch方法2次,一共7次,所以很明显减少了不必要的操作次数。

 四、数据流复用问题

 Stream 流是不能被复用的,一旦你调用任何终端操作,流就会关闭,再调用 noneMatch 就会抛出异常。

Stream<String> stream =Stream.of("d2", "a2", "b1", "b3", "c").filter(s -> s.startsWith("a"));stream.anyMatch(s -> true);    // okstream.noneMatch(s -> true);   // exception

当我们对 stream 调用了 anyMatch 终端操作以后,流即关闭了,再调用 noneMatch 就会抛出异常:

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
    at java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459)
    at test.Demo.main(Demo.java:13)

所以可以通过 Supplier 来包装一下流,通过 get() 方法来构建一个新的 Stream 流,通过构造一个新的流,来避开流不能被复用的限制,如下所示:

Supplier<Stream<String>> streamSupplier =() -> Stream.of("d2", "a2", "b1", "b3", "c").filter(s -> s.startsWith("a"));streamSupplier.get().anyMatch(s -> true);   // ok
streamSupplier.get().noneMatch(s -> true);  // ok

五、工作实践

实际工作中,stream经常用到,列举一些实际工作的业务场景:

场景一:计算两个集合的重复数据有多少

long a = sourceMpList.stream().filter(mpList::contains).count();

场景二:获取一个集合中的某个属性

集合:List<TestDTO> testVo,获取其中的某属性值存入一个专门的集合

List<String> sourList = testVo.stream().map(TestDTO::getName).collect(Collectors.toList());

当然,另一种普通写法为:

List<String> sourList = new ArrayList<>();
for (String s : testVo) {
    sourList.add(s.toUpperCase());
}

场景三:过滤掉为null的字段值以及去重

集合:List<Integer> commPortList;

List<Integer> portList = commPortList.stream().distinct().filter(Objects::nonNull).collect(Collectors.toList());
场景四:从一个集合中剔除多个其他集合的值
List<String> listAll = Stream.of("value1", "value2", "value3").collect(Collectors.toList());
List<String> list1 = Stream.of("value1").collect(Collectors.toList());
List<String> list2 = Stream.of("value2").collect(Collectors.toList());
//从listAll剔除掉list1与list2的数据,找出未使用的
List<String> list3 = listAll.stream().filter(item -> !list1.contains(item) && !list2.contains(item)).collect(Collectors.toList());
System.out.println(list3);  //[value3]
场景五: 判断集合会否存在重复以及空值
List<Integer> list1 = new ArrayList<>(Arrays.asList(1,1,2,3,4,5,null));
long list2 = list1.stream().distinct().count(); //6
//判断设备编号会否存在重复以及空值
if(list1.size()>list2 || list1.contains(null) || list1.contains("")){}
场景六:关于boxed用法

首先boxed的源码如下:

@Override
public final Stream<Integer> boxed() {return mapToObj(Integer::valueOf);
}@Override
public final Stream<Double> boxed() {return mapToObj(Double::valueOf);
}

 boxed的作用就是将int等类型的stream转成了Integer等类型的Stream,

也就是基本类型流转换位对象流,需要使用boxed方法

流库中有直接存储基本类型值的类型IntStream、LongStream和DoubleStream,比如

IntStream是int类型的流。stream<Integer 是Integer类型的流

现在定义一个Integer类型的数据流,用来存IntStream的流,必须使用boxed

IntStream stream = IntStream.of(1,1,2,3,5);
List<Integer> integers = stream.boxed().collect(Collectors.toList());

比如double转Double

List<Double> list = Arrays.stream(new double[]{-1.0, -0.5, 0,0.5}).boxed().collect(Collectors.toList());
 场景七:合并两个集合值
List<Integer> list1 = new ArrayList<>(Arrays.asList(1,1,2));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,4,5,null));
List<Integer> list3 = Stream.of(list1,list2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
System.out.println(list3); //[1, 2, 3, 4, 5, null]
场景八: 如果一个流的集合数据过大,根据需要进行拆分,进而通过循环或者多线程来处理数据
List<Integer> list1 = new ArrayList<>(Arrays.asList(0,1,2,3));
System.out.println(Lists.partition(list1,2));
//[[0, 1], [2, 3]]
场景九: 根据equals过滤出想要的value值或者集合
User user = new User(1,"mac");
List<User> list = new ArrayList<>();
list.add(user);
//根据需要输出想要的value值
Integer value = list.stream().filter(p->p.getName().equals("mac")).collect(Collectors.toList()).get(0).getAge();
System.out.println(value); // 1 

或者这样写

List<Integer> list = new ArrayList<>(Arrays.asList(1,2));
List<User> userList = new ArrayList<>();
userList.add(new User(1,"mac1"));
userList.add(new User(2,"mac2"));
userList.add(new User(3,"mac3"));
List<User> list1 = userList.stream().filter(user -> Objects.equals(list.get(1),user.getAge())).collect(Collectors.toList());
System.out.println(list1);
// [User(age=2, name=mac2)]
场景十: 声明一个带对象的集合并对该对象的属性进行封装
List<Integer> list = new ArrayList<>(Arrays.asList(1,2));
List<User> userList = list.stream().map(id->{//对userList属性进行封装User user = new User();user.setAge(id);user.setName("mac");return user;
}).collect(Collectors.toList());
System.out.println(userList);
//[User(age=1, name=mac), User(age=2, name=mac)]
场景十一: noneMatch、anyMatch、allMatch

anyMatch:判断的条件里,任意一个元素成功,返回true

allMatch:判断条件里的元素,所有的都是,返回true

noneMatch:与allMatch相反,判断条件里的元素,所有的都不是,返回true

List<Integer> list = new ArrayList<>(Arrays.asList(1,2));
System.out.println(list.stream().noneMatch(x->1==x)); //falseStream<String> stream = Stream.of("aaa", "bbb", "ccc");
// 判断stream中其中任何一个元素中只要有包含b字符串或者l字符串就返回true
boolean isMatch = stream.anyMatch(str -> str.contains("b") || str.contains("l"));
System.out.println(isMatch);  // true
场景十二:findFirst,查找集合中符合条件的第一个对象

 Optional<A> firstA= AList.stream() 
                          .filter(a -> "小明".equals(a.getUserName())) 
                          .findFirst();

关于Optional,java API中给了解释,一个容器对象,它可能包含也可能不包含非空值。如果存在一个值,isPresent()将返回true;

List<Integer> list = new ArrayList<>(Arrays.asList(1,2));
Optional<Integer> a = list.stream().filter(p->p==1).findFirst();
if (a.isPresent()){  //trueSystem.out.println("true");
}
场景十三:sorted,comparator

java8的lambda表达式排序,理应用comparing,多字段 后面增加thenComparing,默认排序规则为正序

现在有个排序需求:
a-倒序
b-当a相同时,正序
c-当b相同时,倒序

 List<UserCouponVo> newList = list.stream().sorted(Comparator
                    .comparing(UserCouponVo::getA,Comparator.reverseOrder())
                    .thenComparing(UserCouponVo::getB)
                    .thenComparing(UserCouponVo::getC,Comparator.reverseOrder())
            ).collect(Collectors.toList());

List<Yue> yueList = new ArrayList<>();
yueList.add(new Yue(4,1));
yueList.add(new Yue(2,2));
yueList.add(new Yue(6,3));
List<Yue> list1 = yueList.stream().sorted(Comparator.comparing(Yue::getA)).collect(Collectors.toList());
System.out.println(list1);
//[Yue(a=2, b=2), Yue(a=4, b=1), Yue(a=6, b=3)]List<Yue> list = yueList.stream().sorted(Comparator.comparing(Yue::getA,Comparator.reverseOrder())).collect(Collectors.toList());
System.out.println(list);
//[Yue(a=6, b=3), Yue(a=4, b=1), Yue(a=2, b=2)]

如何a值分别为正序246,倒序642

场景十四:Collectors.groupingBy
List<User> userList = new ArrayList<>();
userList.add(new User(1,"mac1"));
userList.add(new User(2,"mac2"));
userList.add(new User(3,"mac3"));
userList.add(new User(3,"mac3"));
System.out.println(userList.stream().collect(Collectors.groupingBy(User::getAge)));
//{
// 1=[User(age=1, name=mac1)], 
// 2=[User(age=2, name=mac2)], 
// 3=[User(age=3, name=mac3), User(age=3, name=mac3)]
// }
场景十五: 批量修改某个集合的属性
List<User> userList = new ArrayList<>();
userList.add(new User(1,"mac1"));
userList.add(new User(2,"mac2"));
userList.stream().map(p->{p.setAge(2+p.getAge());return p;}).collect(Collectors.toList());
System.out.println(userList);
//[User(age=3, name=mac1), User(age=4, name=mac2)]

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

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

通过pymysql读取数据库中表格并保存到excel(实用篇)

本篇文章是通过pymysql将本地数据库中的指定表格保存到excel的操作。 这里我们假设本地已经安装了对应的数据库管理工具&#xff0c;里面有一个指定的表格&#xff0c;现在通过python程序&#xff0c;通过调用pymysql进行读取并保存到excel中。 关于数据库管理工具是Navicat P…

Android Studio学习7——常用控件view

Android控件 双击shift键——>搜索想要找的文件 Ctrlshift回车——>补全“&#xff1b;”号 CtrlX——>删除一行&#xff0c;只需把鼠标放在那一行 windows自带字体

LC 111.二叉树的最小深度

111. 二叉树的最小深度 给定一个二叉树&#xff0c;找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明&#xff1a; 叶子节点是指没有子节点的节点。 示例 1&#xff1a; 输入&#xff1a; root [3,9,20,null,null,15,7] 输出&#xff1a;…

mongodb的简单操作

文章目录 前言数据库的创建和删除集合的创建和删除文档的插入和查询异常处理更新数据局部修改符合条件的批量更新加操作 删除文档删除全部数据删除符合条件的数据 统计count统计有多少条数据统计特定条件有多少条数据 分页查询排序查询正则查询比较查询包含查询条件连接查询索引…

Docker 哲学 - push 本机镜像 到 dockerhub

注意事项&#xff1a; 1、 登录 docker 账号 docker login 2、docker images 查看本地镜像 3、注意的是 push镜像时 镜像的tag 需要与 dockerhub的用户名保持一致 eg&#xff1a;本地镜像 express:1 直接 docker push express:1 无法成功 原因docker不能识别 push到哪里 …

轻松上手 Tanssi:应用链开发与部署终极指南

随着 Polkadot 2.0 的推进&#xff0c;一个既强大又用户友好的技术支撑成为推动生态进步的关键&#xff0c;目的是为了降低应用链启动的成本和复杂度。在这个转折点上&#xff0c;Tanssi 逐渐成为应用链开发的首选解决方案。Tanssi 是一个旨在简化应用链部署流程的模块化基础设…

kubernetes-Pod基于污点、容忍度、亲和性的多种调度策略(二)

Pod调度策略 一.污点-Taint二.容忍度-Tolerations三.Pod常见状态和重启策略1.Pod常见状态2.Pod的重启策略2.1测试Always重启策略2.2测试Never重启策略2.3测试OnFailure重启策略&#xff08;生产环境中常用&#xff09; 一.污点-Taint 在 Kubernetes 中&#xff0c;污点&#x…

采用大语言模型进行查询重写——Query Rewriting via Large Language Models

文章&#xff1a;Query Rewriting via Large Language Models&#xff0c;https://arxiv.org/abs/2403.09060 摘要 查询重写是在将查询传递给查询优化器之前处理编写不良的查询的最有效技术之一。 手动重写不可扩展&#xff0c;因为它容易出错并且需要深厚的专业知识。 类似地…

codeforces Edu 142 D. Fixed Prefix Permutations 【思维、字典树求LCP】

D. Fixed Prefix Permutations 题意 给定 n n n 个长度为 m m m 的排列 a 1 , a 2 , . . . a n a_1,a_2,...a_n a1​,a2​,...an​ 定义一个排列 p p p 的 价值 为 最大顺序长度 k k k&#xff1a; p 1 1 , p 2 2 , p 3 3 , . . . p k k p_1 1,p_2 2, p_3 3, ...…

CLIP网络结构解析 openai/CLIP (Contrastive Language-Image Pre-Training)

1、简单介绍 CLIP是openai公司提出的网络&#xff0c;可以处理文本和图像&#xff0c;是一个多模态网络&#xff0c;对多模态的研究具有一定的推动作用。作为学习&#xff0c;记录一下对CLIP的理解。 clip的官方网站&#xff1a; https://openai.com/research/clip clip的GitH…

优于五大先进模型,浙江大学杜震洪团队提出 GNNWLR 模型:提升成矿预测准确性

卡塔尔世界杯自 2010 年荣膺举办权&#xff0c;直至 2022 年辉煌成功举办&#xff0c;累计投入资金高达约 2,290 亿美元。相较之下&#xff0c;此前七届世界杯的总花费仅约 400 多亿美元。这场体育盛事展现出奢华无度的风采&#xff0c;归根结底源于卡塔尔这个国度的深厚底蕴。…

nginx配置多vue项目

1. 找到linux docker安装好的nginx目录文件 进入nginx内 把打包好的vue项目放在html文件下 如上 三个文件夹下对应着三个不同的vue项目 2. 配置default.conf的配置文件&#xff0c; 一个nginx配置文件可以多个项目进行代理 进入到conf 找到conf.d下面的default.conf 文件…

SV学习笔记(二)

接口 什么是接口&#xff1f; 接口 主要用作验证 &#xff0c;国外有些团队会使用sv进行设计&#xff0c;那么接口就会用作设计。验证环境中&#xff0c;接口可以 使连接变得简洁而不易出错 。interface和module的使用性质很像&#xff0c; 可以定义端口&#xff0c;也可以定…

[C/C++] -- 二叉树

1.简介 二叉树是一种每个节点最多有两个子节点的树结构&#xff0c;通常包括&#xff1a;根节点、左子树、右子树。 满二叉树&#xff1a; 如果一棵二叉树只有度为0的结点和度为2的结点&#xff0c;并且度为0的结点在同一层上&#xff0c;则这棵二叉树为满二叉树。深度为k&a…

如何备份极狐GitLab 信任域名证书

本文作者&#xff1a;徐晓伟 GitLab 是一个全球知名的一体化 DevOps 平台&#xff0c;很多人都通过私有化部署 GitLab 来进行源代码托管。极狐GitLab 是 GitLab 在中国的发行版&#xff0c;专门为中国程序员服务。可以一键式部署极狐GitLab。 本文主要讲述了如何使用极狐GitLa…

WebCopilot:一款功能强大的子域名枚举和安全漏洞扫描工具

关于WebCopilot WebCopilot是一款功能强大的子域名枚举和安全漏洞扫描工具&#xff0c;该工具能够枚举目标域名下的子域名&#xff0c;并使用不同的开源工具检测目标存在的安全漏洞。 工具运行机制 WebCopilot首先会使用assetsfinder、submaster、subfinder、accumt、finddom…

华为OD机试 - 最大社交距离(Java 2024 C卷 100分)

华为OD机试 2024C卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试&#xff08;JAVA&#xff09;真题&#xff08;A卷B卷C卷&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;每一题都有详细的答题思路、详细的代码注释、样例测试…

ubuntu20.04 运行 lio-sam 流程记录

ubuntu20.04 运行 lio-sam 一、安装和编译1.1、安装 ROS11.2、安装 gtsam1.3、安装依赖1.4、下载源码1.5、修改文件1.6、编译和运行 二、官方数据集的运行2.1、casual_walk_2.bag2.2、outdoor.bag、west.bag2.3、park.bag 三、一些比较好的参考链接 记录流程&#xff0c;方便自…

【威胁情报综述阅读3】Cyber Threat Intelligence Mining for Proactive Cybersecurity Defense

【威胁情报综述阅读1】Cyber Threat Intelligence Mining for Proactive Cybersecurity Defense: A Survey and New Perspectives 写在最前面一、介绍二、网络威胁情报挖掘方法和分类A. 研究方法1&#xff09; 第 1 步 - 网络场景分析&#xff1a;2&#xff09; 第 2 步 - 数据…

Python 之 Flask 框架学习

毕业那会使用过这个轻量级的框架&#xff0c;最近再来回看一下&#xff0c;依赖相关的就不多说了&#xff0c;直接从例子开始。下面示例中的 html 模板&#xff0c;千万记得要放到 templates 目录下。 快速启动 hello world from flask import Flask, jsonify, url_forapp F…