Spark编程基础-RDD

news2024/11/18 3:19:11

目录

1.何为RDD

 2.RDD的五大特性

 3.RDD常用算子

3.1.Transformation算子

1.map()

2.flatMap() 

 3.reduceByKey()

4 . mapValues()

 5. groupBy()

 6.filter()

 7.distinct()

 8.union()

 9.join()

 10.intersection()

 11.glom()

 12.gruopBykey()

13.sortBy() 

14.sortByKey 

3.2 Action算子

1.countByKey() 

 2.countByValue()

 3.collect()

 4.reduce()

5.fold() 

6.first() 

7.take() 

 8.top()

 9.count()

10.takeSample() 

11.takeOdered() 

12.foreach() 

 13.saveAsTextFile()

 3.3 分区操作算子

 1.mapPartitions()

2.foreachPartition() 

3.partitionBy() 

 4.repartition()

5.groupByKey() 与 reduceByKey() 的区别

4.一些练习提示

1.何为RDD

RDD,全称Resilient Distributed Datasets，意为弹性分布式数据集。它是Spark中的一个基本概念，是对数据的抽象表示，是一种可分区、可并行计算的数据结构。其RDD来源于这篇论文（论文链接：Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing）

 RDD可以从外部存储系统中读取数据，也可以通过Spark中的转换操作进行创建和变换。RDD的特点是不可变性、可缓存性和容错性。同时，RDD提供了一种多种类型的操作，比如转换操作和行动操作，可以对RDD进行处理和计算。RDD的定义包含以下几个要素：

  1.  数据集：RDD是一个分布式的数据集合，数据可以来自于HDFS、HBase、本地文件系统等。
  2. 分区：数据集可以被分成多个分区，每个分区可以在集群中的不同节点上进行处理。
  3. 弹性：RDD的分区可以在集群中的不同节点上进行重建和恢复，从而保证了RDD的容错性。
  4. 不可变性：RDD中的数据不可被修改，只能通过转换操作生成新的RDD。
  5. 缓存性：RDD可以被缓存到内存中，以提高计算性能。
  6. 操作：RDD提供了多种类型的操作，包括转换操作和行动操作，可以对RDD进行处理和计算。

 2.RDD的五大特性

（1）A list of partitions--RDD是分区的，由许多partition构成，有多少partition就对应有多少task

（2）A function for computing each split--计算方法（函数）是作用于每个RDD的

（3）A list of dependencies on other RDDs--RDD之间有相互依赖

（4）Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)--KV型RDD可以有分区型

（5）Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)--RDD分区数据读取时尽量靠近数据所在地

具体RDD的五大特性可看这篇文章http://t.csdn.cn/gzjb7

Spark框架

 3.RDD常用算子

算子就是分布式集合对象上的API,类似于本地的函数或方法，只不过后者是本地的API，为了区分就叫其算子。

 RDD算子主要分为Transformation算子和Action算子

Transformation算子其返回值仍然是一个RDD，而且该算子为lazy的，即如果没有Action算子，它是不会工作的，就类似与Transformation算子相当于一道流水线，而Action算子是这个流水线的开关。

Action算子其返回值则不是RDD，是其他的对象，如一个数，一个迭代器等。

接下来会介绍常用算子

3.1.Transformation算子

1.map()

map(func)  将RDD一条条处理，返回新的RDD

func:f:(T)->U

rdd=sc.parallelize([1,2,3,4,5,6],3)
def func(data):
    return data*10
rdd=rdd.map(func)
print(rdd.collect())
#[10, 20, 30, 40, 50, 60]

2.flatMap() 

 flatMap(func) 对RDD执行map操作，然后进行解除嵌套（即类似拉直数组）操作

rdd1=sc.parallelize(['hadoop spark hadoop','spark hadoop hadoop','hadoop flink spakr'])
rdd2=rdd1.map(lambda x:x.split(' '))
#flatMap()将多维数组拉直
rdd3=rdd1.flatMap(lambda x:x.split(' '))
print(rdd2.collect())
print(rdd3.collect())
#map:[['hadoop', 'spark', 'hadoop'], ['spark', 'hadoop', 'hadoop'], ['hadoop', 'flink', 'spakr']]
#flaMap:['hadoop', 'spark', 'hadoop', 'spark', 'hadoop', 'hadoop', 'hadoop', 'flink', 'spakr']

 3.reduceByKey()

reduceByKey(func) 针对于kv型数据，流程为按照k分组，然后对v进行处理（聚合） func(V,V)->V
rdd=sc.parallelize([('a',1),('a',1),('b',1),('a',1)])
def func(a,b):
    return a+b
rdd=rdd.reduceByKey(func)
print(rdd.collect())
#[('a', 3), ('b', 1)]

4 . mapValues()

mapValues(func)针对于二元元组RDD，只针对其中的value进行map操作 func(V)->U
rdd=sc.parallelize([('a',1),('a',1),('b',1),('a',1)])
def func(a):
    return a*10
rdd=rdd.mapValues(func)
print(rdd.collect())
#[('a', 10), ('a', 10), ('b', 10), ('a', 10)]

 5. groupBy()

groupBy(func) 将rdd的数据进行分组 func(T)->K 通过这个函数，确定按照谁来分组（返回谁即可） 分组规则（hash分组），该函数是，拿到你的返回值，将所有相同返回值的放入一个组内，最后分组完成后，每一个组是一个二元组，key就是返回值，所有同组的数据放入一个迭代器对象中作为value

rdd=sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1),('b',1)])
def func(a):
    return a[0]
rdd=rdd.groupBy(func)
print(rdd.map(lambda x:(x[0],list(x[1]))).collect())
#[('a', [('a', 1), ('a', 1)]), ('b', [('b', 1), ('b', 1), ('b', 1), ('b', 1)])]

 6.filter()

filter(func) 过滤想要的数据进行保留 func(T)->bool 即返回值为True的数据保留
rdd=sc.parallelize([1,2,3,4,5,6])
def func(a):
    if a%2==0:
        return 1
    else:
        return 0
rdd=rdd.filter(func)#rdd.filte(lambda x:x%2==1)
print(rdd.collect())
#[2, 4, 6]

 7.distinct()

distinct(参数1) 对rdd数据进行去重 参数1-去重分区，一般不用传
rdd=sc.parallelize([1,1,2,3,1,2,2,3,4,4])
rdd=rdd.distinct()
print(rdd.collect())
#[1, 2, 3, 4]

 8.union()

union() 2个rdd合并成1个rdd返回 rdd.union(other_rdd) 只合并不去重，不同类型的RDD依旧可以混合

rdd1=sc.parallelize([1,2,4,5,1])
rdd2=sc.parallelize(['a','b','c','a'])
rdd=rdd1.union(rdd2)
print(rdd.collect())
#[1, 2, 4, 5, 1, 'a', 'b', 'c', 'a']

 9.join()

join() 对两个rdd执行join操作（可实现sql的内|外连接） 只能用于二元元组,根据二元元组的key来连接 内连接 rdd.join(other_rdd) 左外连接 rdd.leftOuterJoin(other_rdd) 右外连接 rrdd.ightOuterJoin(other_rdd)
对于缺失的，用None填充
rdd1=sc.parallelize([(1001,'a'),(1002,'b'),(1003,'c')])
rdd2=sc.parallelize([(1001,'dudu'),(1002,'huahua')])
#内连接
rdd=rdd1.join(rdd2)
print(rdd.collect())
#[(1001, ('a', 'dudu')), (1002, ('b', 'huahua'))]

#左外连接
rdd=rdd1.leftOuterJoin(rdd2)
print(rdd.collect())
#[(1001, ('a', 'dudu')), (1002, ('b', 'huahua')), (1003, ('c', None))]

#右外连接
rdd=rdd1.rightOuterJoin(rdd2)
print(rdd.collect())
#[(1001, ('a', 'dudu')), (1002, ('b', 'huahua'))]

 10.intersection()

intersection() 求2个rdd的交集，返回一个新的rdd rdd.intersection(other_rdd)

rdd1=sc.parallelize([('a',1),('b',3)])
rdd2=sc.parallelize([('a',1),('a',3)])
rdd=rdd1.intersection(rdd2)
print(rdd.collect())
#[('a', 1)]

 11.glom()

glom() 将rdd的数据，加上嵌套，按分区显示 rdd->[1,2,3,4,5]有两个分区 glom后->[[1,2,3],[4,5]]

rdd=sc.parallelize([1,2,3,4,5,6],2)
rdd=rdd.glom()
print(rdd.collect())
#[[1, 2, 3], [4, 5, 6]]

 12.gruopBykey()

groupByKey() 针对kv型rdd,自动按照key分组
rdd=sc.parallelize([('a',1),('a',2),('b',1),('b',2)])
rdd=rdd.groupByKey().map(lambda x:(x[0],list(x[1])))
print(rdd.collect())
#[('a', [1, 2]), ('b', [1, 2])]

13.sortBy() 

sortBy(func,ascending=False,numPartitions=1) 对rdd数据进行排序，基于指定的排序依据
func(T)->V
ascending True 升序 Flases 降序
numPartitions 用多少分区排序 如果要全局有序，排序分区数要设置为1

def func(a):
    return a[1]
rdd=sc.parallelize([('a',1),('b',3),('c',1),('c',2),('d',4),('a',6)],9)
rdd=rdd.sortBy(func,ascending=True, numPartitions=1)
print(rdd.collect())
#[('a', 1), ('c', 1), ('c', 2), ('b', 3), ('d', 4), ('a', 6)]

14.sortByKey 

sortByKey(ascending=True,numPartitions=None,keyfunc=<function RDD,<lambda>>) 针对kv型RDD,按照key进行排序
ascending true升序，false降序
numPartition 按照几个分区进行排序，如果全局有序，设置1
keyfunc 在排序前对key进行处理，语法是(k)->U,一个参数传入，返回一个值

rdd=sc.parallelize([('a',1),('E',1),('C',1),('D',1),('b',1),('g',1),('f',1)])
rdd=rdd.sortByKey(ascending=True,numPartitions=1,keyfunc=lambda x:x.lower())
print(rdd.collect())
#[('a', 1), ('b', 1), ('C', 1), ('D', 1), ('E', 1), ('f', 1), ('g', 1)]

3.2 Action算子

1.countByKey() 

countByKey() 统计key出现的次数（一般适用于kv型RDD）

rdd=sc.textFile('words.txt')
rdd=rdd.flatMap(lambda x:x.split(' ')).map(lambda x:(x,1))
result=rdd.countByKey()
print(result)
#defaultdict(<class 'int'>, {'hadoop': 6, 'spark': 3, 'flink': 1})

 2.countByValue()

countByValue() 根据rdd中的元素值相同的个数 返回的类型为Map[K,V],  K : 元素的值，V ：元素对应的的个数,与kv型数据中的v没有关系
rdd=sc.parallelize(['a','a','b','c','c','c','d'])
result=rdd.countByValue()
print(result)
#defaultdict(<class 'int'>, {'a': 2, 'b': 1, 'c': 3, 'd': 1})

 3.collect()

collect() 将RDD各个分区内的数据，统一收集到Driver中，形成一个list对象
用之前数据集别太大，否则会把Driver内存溢出而报错,很常用这里就不举例了

 4.reduce()

reduce(func) 队RDD数据集按照你传入的逻辑进行聚合
func:(T,T)->T
2个参数传入，1个返回值，返回值和参数要求类型一致
rdd=sc.parallelize([1,2,3,4,5,6])
result=rdd.reduce(lambda a,b:a+b)
print(result)
#21

5.fold() 

fold() 和reducce一样,接受传入逻辑进行聚合 但聚合是带有初始值的
多个分区时 这个初始值聚合会作用在 分区内和分区间

rdd=sc.parallelize([1,2,3,4,5,6,7,8,9],3)
result=rdd.fold(10,lambda a,b:a+b)
print(result)
#85

6.first() 

first() 取出RDD的第一个元素

rdd=sc.parallelize([1,2,3,4,5])
result=rdd.first()
print(result)
#1

7.take() 

take() 取RDD的前N个元素，组合成list返回
rdd=sc.parallelize([1,2,3,4,5])
result=rdd.take(5)
print(result)
#[1, 2, 3]

 8.top()

top() 对RDD数据集进行降序(从大到小)排序，取前N个，组成list返回
rdd=sc.parallelize([1,2,3,4,5])
result=rdd.top(3)
print(result)
#[5, 4, 3]

 9.count()

count() 计算RDD有多少条数据，返回一个数字

rdd=sc.parallelize([1,2,3,4,5])
result=rdd.count()
print(result)
#5

10.takeSample() 

takeSample(参数1:True or False,参数2:采样数,参数3:随机数种子) 随机抽样RDD的数据
参数1：True表示允许取同一个数据 False表示不允许取同一个数据 和数据内容无关，是否重复表示的是同一个位置的数据
参数2：抽样要几个
参数3：随机数种子（一般不传，Spark会自动给）
rdd=sc.parallelize([1,2,3,1,2,3,4,5,6,2,3,1],2)
result=rdd.takeSample(False,3)
print(result)
#[3, 1, 5] 这是随机的，每次运行结果不一样

11.takeOdered() 

takeOrdered(参数1,参数2) 对RDD进行排序取前N个
参数1：要几个数据
参数2:对排序的数据进行更改（不会更改数据本身，只是在排序的时候换个样子）
这个方法使用按照元素自然顺序升序排序，如果想按照其他规则排序，需要用参数2进行编写

rdd=sc.parallelize([3,4,5,2,2,4,5,22,9],3)
result=rdd.takeOrdered(4,lambda x:-x)
print(result)
#[22, 9, 5, 5]

12.foreach() 

foreach(func) 对RDD的每一个元素，执行你提供的逻辑的操作（类似于map），但这个方法方法没有返回值
func:(T)->None
操作是在容器内进行，不需要上传至Dirver再运行，效率较高

rdd=sc.parallelize([1,2,3,4,5,6,7],2)
result=rdd.foreach(lambda x:print(x*10))
print(result)
#10
#20
#30
#40
#50
#60
#70
#None

 13.saveAsTextFile()

saveAsTextFile() 将RDD的数据写入文本文件中 支持本地写出，hdfs
rdd有几个分区，就有几个文件

rdd=sc.parallelize([1,2,3,4,55,5,6],3)
rdd.saveAsTextFile('output/out1')

 3.3 分区操作算子

 1.mapPartitions()

mapPartitions()--Transformation
mapPartitions 一次杯传递的是一整个分区的数据作为一个迭代器（list）对象传入过来，与map不同的是，map是每次传入一个值,在网络io层面，效率和性能有很大提升
rdd=sc.parallelize([1,2,3,4,5,6,7],3)
def func(x):
    result=list()
    for i in x:
        result.append(i*10)
    return result
rdd=rdd.mapPartitions(func)
print(rdd.collect())
#[10, 20, 30, 40, 50, 60, 70]

2.foreachPartition() 

foreachPartition()--Action 和普通的foreach一致，一次传入了的是一个分区数据
rdd=sc.parallelize([1,2,3,4,5,6,7],3)
def func(x):
    result=list()
    for i in x:
        result.append(i*10)
    print(result)
rdd.foreachPartition(func)
#[10, 20]
#[30, 40]
#[50, 60, 70]

3.partitionBy() 

partitionBy(参数1,参数2)--Transformation 对RDD进行自定义分区操作
参数1：重新分区后有几个分区
参数2：自定义分区规则，函数传入 (K)->int
rdd=sc.parallelize([('a',1),('a',1),('b',1),('a',1),('c',1),('d',1)],3)
print('自定义分区前:',rdd.glom().collect())
def func(key):
    if key=='a' or key=='b':
        return 0
    elif key=='c':
        return 1
    else:
        return 2
rdd=rdd.partitionBy(3,func)
print('自定义分区后:',rdd.glom().collect())
#自定义分区前: [[('a', 1), ('a', 1)], [('b', 1), ('a', 1)], [('c', 1), ('d', 1)]]
#自定义分区后: [[('a', 1), ('a', 1), ('b', 1), ('a', 1)], [('c', 1)], [('d', 1)]]

 4.repartition()

repartition(N)--Transfromation 对RDD的分区执行重新分区（仅数量）
其底层函数为 coalesce(N,shuffle=True) 但该函数有个安全机制，即若想增加分区得shuffle=True 而减少分区则不需要
传入N 决定新的分区数  （少用，尽量减少，不要增加）
rdd=sc.parallelize([1,2,3,4,5,6],3)
print('原分区:',rdd.glom().collect())
rdd1=rdd.repartition(1)
print('重新分区后:',rdd1.glom().collect())
rdd=sc.parallelize([1,2,3,4,5,6],3)
#原分区: [[1, 2], [3, 4], [5, 6]]
#重新分区后: [[1, 2, 3, 4, 5, 6]]

5.groupByKey() 与 reduceByKey() 的区别

groupBykey()--仅仅分组
reduceByKey()--分组+聚合
redeceByKey-->先分区内聚合再分组最后再聚合 的性能远远大于 groupByKey+聚合逻辑-->先分组再聚合 网络io大

4.一些练习提示

对于两个输入文件a.txt和b.txt，编写Spark独立应用程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新文件

 数据基本为这样，想将数据转化为二元元组，然后利用union拼接，再利用distinct去重，再利字符串拼接，最后再利用coalesce转换为一个分区，然后saveAstextFile就可以得到一个文件了。

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

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

相关文章

docker+docker-compose+nginx前后端分离项目部署

docker+docker-compose+nginx前后端分离项目部署

文章目录1.安装docker1.1 基于centos的安装1.2 基于ubuntu2.配置国内加速器2.1 配置阿里云加速器&#x1f340; 找到相应页面&#x1f340; 创建 docker 目录&#x1f340; 创建 daemon.json 文件&#x1f340; 重新加载服务配置文件&#x1f340; 重启 docker 引擎2.2 配置网易…
阅读更多...
OJ系统刷题 第八篇

OJ系统刷题 第八篇

13415 - 津津的储蓄计划 时间限制 : 1 秒 内存限制 : 128 MB 津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱&#xff0c;津津会预算这个月的花销&#xff0c;并且总能做到实际花销和预算的相同。 为了让津津学习如何储蓄&#xff0c;妈妈提出&#xff0c;津…
阅读更多...
计算机组成原理---第四章 指令系统

计算机组成原理---第四章 指令系统

一、指令系统的发展与性能要求 指令系统的概述 指令就是要计算机执行某种操作的命令。可分为&#xff1a;①微指令&#xff0c;属于硬件&#xff1b;②机器指令&#xff0c;简称指令&#xff0c;完成算术逻辑操作&#xff1b;③宏指令&#xff0c;由若干条机器指令组成&#xf…
阅读更多...
[Java]JSTL标签库

[Java]JSTL标签库

EL表达式https://blog.csdn.net/m0_71229255/article/details/130173486?spm1001.2014.3001.5501 JSTL标签的使用 Java Server Pages Standard Tag Libray(JSTL): JSP标准标签库&#xff0c;是一个定制标签类库的集合&#xff0c;用于解决一些常见的问题&#xff0c;例如迭代…
阅读更多...
【2023 年第十三届 MathorCup 高校数学建模挑战赛】C 题 电商物流网络包裹应急调运与结构优化问题 建模方案及代码实现

【2023 年第十三届 MathorCup 高校数学建模挑战赛】C 题 电商物流网络包裹应急调运与结构优化问题 建模方案及代码实现

更新信息&#xff1a;2023-4-15 更新了代码 【2023 年第十三届 MathorCup 高校数学建模挑战赛】C 题 电商物流网络包裹应急调运与结构优化问题 1 题目 电商物流网络由物流场地&#xff08;接货仓、分拣中心、营业部等&#xff09;和物流场 地之间的运输线路组成&#xff0c;如…
阅读更多...
Java项目架构分层改造-项目亮点

Java项目架构分层改造-项目亮点

服务分层改造 时间操作人员2023年04月12日23:04:00创建文档Cheems 原始项目结构 所有文件糅杂在一起&#xff08;大多数公司如此&#xff09;&#xff0c;没有分层开&#xff0c;功能增加代码复杂不清晰 分层改造后 先确定思路&#xff0c;后续把功能搬过来即可&#xff01;&…
阅读更多...
关于GNSS技术介绍（一）

关于GNSS技术介绍（一）

什么是GNSS&#xff1f; GNSS的全称是全球导航卫星系统&#xff08;Global Navigation Satellite System&#xff09;&#xff0c;它是泛指所有的卫星导航系统&#xff0c;包括全球的、区域的和增强的。GNSS是覆盖全球的自主地利空间定位的卫星系统&#xff0c;用于导航与定位…
阅读更多...
Stable Diffusion成为生产力工具（四）：制作食品安全PPT所用的相关图片png、图标icon

Stable Diffusion成为生产力工具（四）：制作食品安全PPT所用的相关图片png、图标icon

S&#xff1a;你安装stable diffusion就是为了看小姐姐么&#xff1f; I &#xff1a;当然不是&#xff0c;当然是为了公司的发展谋出路~~ 预先学习&#xff1a; 安装webui《Windows安装Stable Diffusion WebUI及问题解决记录》。运行使用时问题《Windows使用Stable Diffusion时…
阅读更多...
【C语言】 数据的存储 -- 数据类型介绍 -- 存储 -- 浮点型在内存中的存储，很详细也很重要，不明白的一定要看

【C语言】 数据的存储 -- 数据类型介绍 -- 存储 -- 浮点型在内存中的存储，很详细也很重要，不明白的一定要看

目录 1、数据类型介绍 1.1 类型的基本归类 2、整型在内存中的存储 2.1 原码、反码、补码 2.2 大小端介绍 2.3 练习 3、浮点型在内存中的存储 3.1 举一个例子 3.2 浮点数存储规则 *************************************************正文开始*************************…
阅读更多...
一文了解MongoDB的各种部署模式

一文了解MongoDB的各种部署模式

单节点模式&#xff08;Standalone&#xff0c;不推荐用于生产环境&#xff09; standalone模式即单节点模式&#xff0c;指在服务器上只部署一个 mongod 进程用于读写数据。优点是部署简单&#xff0c;可以快速完成部署&#xff0c;缺点是无容灾。只推荐用于日常的开发、测试…
阅读更多...
线程(Thread)的三种等待唤醒机制详解

线程(Thread)的三种等待唤醒机制详解

1、为什么需要线程的等待和唤醒 线程的等待唤醒机制是一种经典的“生产者和消费者”模型。例如食品加工厂&#xff0c;食品加工人员和原料补给人员&#xff0c;在有充足原料时&#xff0c;补给人员是在等待&#xff0c;等到原料不够时&#xff0c;食品加工人员通知补给人员&am…
阅读更多...
linux实时性分析

linux实时性分析

什么是实时操作系统 操作系统的实时性是指执行一个特定任务的时间是确定的和可预测的&#xff0c;这个任务执行时限需要考虑任何的情况&#xff0c;包括最恶劣的情况。或者说操作系统能够在规定的时间点内完成指定的任务操作&#xff0c;一旦超过这个时间点会对整个系统带来不…
阅读更多...
【探花交友】day01—项目介绍与环境搭建

【探花交友】day01—项目介绍与环境搭建

目录 1、项目介绍 1.1、功能列表 1.2、项目背景 1.3、功能概述 1.4、技术方案 1.5、技术解决方案 2、前后端分离 2.1、前后端分离的概述 2.2、YAPI介绍 3、开发工具 3.1、虚拟机配置 3.2、Android模拟器 3.3、调试工具PostMan 4、环境搭建 4.1、MYSQL数据库 4.…
阅读更多...
【JAVA程序设计】（C00127）基于SSM+vue开发的音乐播放管理系统-有文档

【JAVA程序设计】（C00127）基于SSM+vue开发的音乐播放管理系统-有文档

基于SSMvue开发的音乐管理系统-有文档项目简介项目获取开发环境项目技术运行截图项目简介 基于ssm框架vue以及html前台的开发的音乐管理系统共分为二个角色&#xff1a;管理员、用户 管理员角色包含以下功能&#xff1a; 登录、个人中心&#xff08;修改密码、个人信息修改&am…
阅读更多...
溯源取证-内存取证 高难度篇

溯源取证-内存取证 高难度篇

今天的场景依然是windows场景&#xff0c;只不过此次场景分为两个镜像&#xff0c;本次学习主要学习如何晒别钓鱼邮件、如何提取钓鱼邮件、如何修复损坏的恶意文件、如何提取DLL动态链接库文件 本次需要使用的工具&#xff1a; volatility_2.6_lin64_standalone readpst clams…
阅读更多...
c++11 标准模板（STL）（std::unordered_multimap）（十三）

c++11 标准模板（STL）（std::unordered_multimap）（十三）

定义于头文件 <unordered_map> template< class Key, class T, class Hash std::hash<Key>, class KeyEqual std::equal_to<Key>, class Allocator std::allocator< std::pair<const Key, T> > > class unordered…
阅读更多...
交互式电子沙盘数字沙盘大数据系统开发第8课

交互式电子沙盘数字沙盘大数据系统开发第8课

交互式电子沙盘数字沙盘大数据系统开发第8课 这次我们完成的功能为拖动一个外部的UI对象到球球上&#xff1a; private void Button_PreviewMouseMove(object sender, MouseEventArgs e) { if(e.LeftButton MouseButtonState.Pressed) DragDr…
阅读更多...
Vue简易便签实现

Vue简易便签实现

Vue简易便签实现 html部分 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><meta http-equiv"X-UA-Comp…
阅读更多...
ChatGPT这么强，你该怎么办？

ChatGPT这么强，你该怎么办？

总编说&#xff1a;《生命3.0》给未来选择工作的人提出的建议显得更加重要。泰格玛克认为&#xff0c;未来选择工作前需要询问三个问题&#xff1a;是否需要与人打交道&#xff0c;运用社交智慧&#xff1f;是否需要创造力&#xff0c;解决复杂问题&#xff1f;是否需要在不确定…
阅读更多...
leetcode1306.跳跃游戏

leetcode1306.跳跃游戏

跳跃游戏 -这里有一个非负整数数组 arr&#xff0c;你最开始位于该数组的起始下标 start 处。当你位于下标 i 处时&#xff0c;你可以跳到 i arr[i] 或者 i - arr[i]。 请你判断自己是否能够跳到对应元素值为 0 的 任一 下标处。 注意&#xff0c;不管是什么情况下&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023