SparkDay02

最新推荐文章于 2024-08-08 21:10:23 发布
最新推荐文章于 2024-08-08 21:10:23 发布
阅读量276 收藏
点赞数
分类专栏： spark 文章标签： scala spark big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65996579/article/details/124852830
版权

spark

一、Union合并两个RDD

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo13Union {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("union")
    val sc = new SparkContext(conf)

    val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6))
    val rdd2: RDD[Int] = sc.parallelize(List(3, 4, 5, 6, 7, 8, 9))

    println(s"rdd1:${rdd1.getNumPartitions}")
    println(s"rdd2:${rdd2.getNumPartitions}")

    /**
     *
     * union：合并两个RDD 不会对数据做去重 两个RDD的类型完全一致
     * 在物理层面并没有合并 只是在逻辑层面合并了
     *
     */

    val unionRDD: RDD[Int] = rdd1.union(rdd2)

    println(s"unionRDD:${unionRDD.getNumPartitions}")

    unionRDD.foreach(println)
  }

}

二、Join

1、innerJoin

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo14Join {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setAppName("union")
    conf.setMaster("local")
    val sc = new SparkContext(conf)

    val idNameRDD: RDD[(String, String)] = sc.parallelize(List(
      ("001", "小伟"),
      ("002", "张三"),
      ("003", "刘思思"),
      ("004", "王五")
    ))

    val idAgeRDD: RDD[(String, String)] = sc.parallelize(List(
      ("001", "23"),
      ("002", "24"),
      ("003", "25"),
      ("004", "23")
    ))

    /**
     * innerJoin：两个表都有才能关联上
     *
     */

    val innerJoinRDD: RDD[(String, (String, String))] = idNameRDD.join(idAgeRDD)

    //整理数据
    innerJoinRDD
      .map {
        case (id: String, (name: String, age: String)) =>
          (id, name, age.toInt)
      }
      .foreach(println)

2、leftOuterJoin

 /**
     * leftOuterJoin：以左表为基础 如果右表没有这个Key 补None
     *
     * Option：可选的值 有值或者没有值
     *
     */

    val leftJoinRDD: RDD[(String, (String, Option[String]))] = idNameRDD.leftOuterJoin(idAgeRDD)

    //整理数据
    leftJoinRDD
      .map {
        //关联上的处理方式
        case (id: String, (name: String, Some(age))) =>
          (id, name, age.toInt)

        //没有关联上的处理方式
        case (id: String, (name: String, None)) =>
          (id, name, 0)
      }
      .foreach(println)

3、fullOuterJoin

/**
     * fullOuterJoin：以两个表为基础 有一边有数据就会出来结果 另一边补None
     *
     */

    val fullJoinRDD: RDD[(String, (Option[String], Option[String]))] = idNameRDD.fullOuterJoin(idAgeRDD)

    fullJoinRDD
      .map {
        case (id: String, (Some(name), None)) =>
          (id, name, 0)

        case (id: String, (None, Some(age))) =>
          (id, "默认值", age)

        case (id:String,(Some(name),Some(age)))=>
          (id,name,age)
      }
      .foreach(println)

  }
}

三、MapValues

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo15MapValues {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    conf.setMaster("local")
    conf.setAppName("union")

    val sc = new SparkContext(conf)

    val idAgeRDD: RDD[(String, Int)] = sc.parallelize(List(
      ("001", 23),
      ("002", 24),
      ("003", 25),
      ("004", 23)
    ))

    /**
     * mapValues：key不变 对value做处理
     *
     */

    val rdd: RDD[(String, Int)] = idAgeRDD.mapValues(age => age + 1)

    rdd.foreach(println)
  }

}

四、Sort

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo16Sort {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    conf.setMaster("local")
    conf.setAppName("group")

    val sc = new SparkContext(conf)

    val linesRDD: RDD[String] = sc.textFile("data/score.txt")

    //取出学号和分数
    val scoreRDD: RDD[(String, Int)] = linesRDD
      .map(line => line.split(","))
      .filter(arr => arr.length == 3)
      .map {
        case Array(id: String, _: String, sco: String) =>
          (id, sco.toInt)
      }

    //计算总分
    val sumScoreRDD: RDD[(String, Int)] = scoreRDD.reduceByKey(_ + _)

    /**
     * sortBy：指定一个字段进行排序
     * sortByKey：通过Key进行排序
     * 默认是升序
     */

    val sortByRDD: RDD[(String, Int)] = sumScoreRDD.sortBy(kv => kv._2, ascending = false)

    sortByRDD.foreach(println)
  }

}

五、Distinct

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo17Distinct {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    conf.setAppName("group")
    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val rdd1: RDD[Int] = sc.parallelize(List(1, 1, 12, 5, 2, 2, 52, 41, 5, 3, 32, 4, 5))

    /**
     * distinct：对数据去重 会产生shuffle
     *
     */

    val distinctRDD: RDD[Int] = rdd1.distinct()

    distinctRDD.foreach(println)
  }

}

七、RDDAction算子

package com.shujia.spark.core

import com.shujia.spark.util.HDFSUtil
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo18Action {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    conf.setMaster("local")
    conf.setAppName("group")

    val sc = new SparkContext(conf)

    val studentRDD: RDD[String] = sc.textFile("data/students.txt")

    /**
     * action算子：每一个action算子都会产生一个job
     *
     */

    /**
     * count：统计RDD的数据行数
     *
     */
    val count: Long = studentRDD.count()

    println(count)


    /**
     *sum：对RDD中的数据求和 RDD中的数据类型必须是数字
     */

    val sumAge: Double = studentRDD
      .map(line => line.split(",")(2).toInt)
      //对所有数据求和 只能是数字类型
      .sum()

    println(sumAge /count)

    /**
     * take：取top 返回下一个数组 不能取太多 会导致内存溢出
     *
     */

    val top10: Array[String] = studentRDD.take(10)

    top10.foreach(println)

    /**
     * collect：将RDD转换成数组 如果RDD数据量比较大 会导致内存溢出 （1G）
     *
     */

    val array: Array[String] = studentRDD.collect()

    array.foreach(println)

    /**
     * foreach：遍历RDD中的数据 也是一个action算子
     * foreachPartition：一次讲一个分区的数据传递给后面的函数
     *
     */
    studentRDD.foreach(println)

    studentRDD.foreachPartition((iter:Iterator[String])=>{
      iter.foreach(println)
    })

    /**
     * saveAsTextFile：将数据保存到HDFS中
     *
     */

    HDFSUtil.deletePath("data/test")

    studentRDD.saveAsTextFile("data/test")

    while (true){

    }
  }

}

八、StudentTest统计偏科最严重的前100名学生

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo19Student {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    conf.setAppName("student")
    conf.setMaster("local")

    val sc = new SparkContext(conf)

    /**
     * 4、统计偏科最严重的前100名学生
     *
     * 通过方差评估偏科程度
     *
     * 1、计算方差
     * 2、计算每个人多个科目的平均值
     *
     */

    //1、读取数据
    val scoresRDD: RDD[String] = sc.textFile("data/score.txt")

    //整理数据
    val kvRDD: RDD[(String, String, Double)] = scoresRDD
      //拆分数据
      .map(_.split(","))
      //过滤脏数据
      .filter(_.length == 3)
      .map {
        case Array(sId: String, cId: String, sco: String) =>
          (sId, cId, sco.toDouble)
      }

    //3、按照学号进行分组
    val groupByRDD: RDD[(String, Iterable[(String, String, Double)])] = kvRDD.groupBy(_._1) //(line => line._1)

    //计算方差
    val stdRDD: RDD[(String, Double)] = groupByRDD.map {
      case (id: String, iter: Iterable[(String, String, Double)]) =>
        //取出分数
        val scores: List[Double] = iter.map(_._3).toList //(line =>line._3)

        /**
         * 计算方差
         * 1、计算平均值
         * 2、套公式算方差
         *
         */
        val avg: Double = scores.sum / scores.length

        val std: Double = scores.map(i => (i - avg) * (i - avg)).sum / scores.length

        (id, std)
    }

    //按照方差排序
    val sortByRDD: RDD[(String, Double)] = stdRDD.sortBy(_._2, ascending = false)

    //偏科最严重的前100名学生
    val top100: Array[(String, Double)] = sortByRDD.take(100)

    top100.foreach(println)
  }

}

九、Submit在集群中运行

package com.shujia.spark.core

import com.shujia.spark.util.HDFSUtil
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo20Submit {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()

    //提交到集群中运行则需要先删除master
//    conf.setMaster("local")
    conf.setAppName("submit")

    val sc = new SparkContext(conf)

    //读取HDFS中的数据
    val studentRDD: RDD[String] = sc.textFile("/data/students.txt")

    //读取班级
    val kvRDD: RDD[(String, Int)] = studentRDD
      .map(line => {
        val split: Array[String] = line.split(",")
        (split(4), 1)
      })

    //统计班级的人数
    val classNumRDD: RDD[(String, Int)] = kvRDD.reduceByKey(_ + _)

    //整理数据
    val resultRDD: RDD[String] = classNumRDD
      .map {
        case (clazz: String, num: Int) =>
          s"$clazz\t$num"
      }

    //删除输出路径
    HDFSUtil.deletePath("/data/clazz_num")
    //将数据包到HDFS中
    resultRDD.saveAsTextFile("/data/clazz_num")


    /**
     * 将项目打包上传到集群上
     *
     * spark-submit --class com.shujia.spark.core.Demo20Submit --master yarn-client spark-1.0.jar
     */
  }

}

十、StudentTest统计每科都及格的学生

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo21Student {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setAppName("student")
    conf.setMaster("local")
    val sc = new SparkContext(conf)

    /**
     * 3、统计每科都及格的学生
     *
     */

    //1、读取分数表
    val scoreRDD: RDD[String] = sc.textFile("data/score.txt")

    //2、读取科目表
    val subjectRDD: RDD[String] = sc.textFile("data/subject.txt")

    //将数据转换为kv格式
    val scoreKVRDD: RDD[(String, (String, Int))] = scoreRDD
      .map(_.split(","))
      .filter(_.length == 3)
      .map {
        case Array(sid: String, cid: String, sco: String) =>
          (cid, (sid, sco.toInt))
      }

    val subjectKVRDD: RDD[(String, Int)] = subjectRDD
      .map(_.split(","))
      .filter(_.length == 3)
      .map {
        case Array(cid: String, _: String, sumSco: String) =>
          (cid, sumSco.toInt)
      }

    //关联学生表和分数表
    val joinRDD: RDD[(String, (Int, (String, Int)))] = subjectKVRDD.join(scoreKVRDD)

    //整理数据
    val comRDD: RDD[(String, String, Int, Int)] = joinRDD.map {
      case (cid: String, (sumSco: Int, (sid: String, sco: Int))) =>
        (sid, cid, sumSco, sco)
    }

    //取出所有及格的分数
    val filterRDD: RDD[(String, String, Int, Int)] = comRDD.filter {
      case (_: String, _: String, sumSco: Int, sco: Int) =>
        sco >= sumSco * 0.6
    }

    //统计每个学生及格的科目数量
    val groupByRDD: RDD[(String, Iterable[(String, String, Int, Int)])] = filterRDD.groupBy(_._1)
    val resultRDD: RDD[(String, Iterable[(String, String, Int, Int)])] = groupByRDD.filter(_._2.size == 6)

    //将数据展开
    val doujigeRDD: RDD[(String, String, Int, Int)] = resultRDD.flatMap(kv => kv._2)

    doujigeRDD.foreach(println)
  }

}

十一、用代码求PI

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

import scala.util.Random

object Demo22PI {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setAppName("pi")
    conf.setMaster("local[8]")
    val sc = new SparkContext(conf)

    val list: Range = 0 until 1000000

    //总数
    val length: Int = list.length

    //1、生成一个包含很多行的一个RDD
    val listRDD: RDD[Int] = sc.parallelize(list, 8)

    //2、循环随机生成点 随机生成正方形内的点
    val pointsRDD: RDD[(Double, Double)] = listRDD.map(i => {
      //生成-1到1的随机数
      val x: Double = Random.nextDouble() * 2 - 1
      val y: Double = Random.nextDouble() * 2 - 1
      (x, y)
    })

    //取出圆内的点
    val yuanPointRDD: RDD[(Double, Double)] = pointsRDD.filter {
      case (x: Double, y: Double) =>
        (x * x + y * y) < 1
    }

    //套公式
    val PI: Double = yuanPointRDD.count().toDouble / length * 4.0

    println(s"PI is :$PI")
  }

}

十二、Acc累加器

package com.shujia.spark.core

import org.apache.spark.rdd.RDD
import org.apache.spark.util.LongAccumulator
import org.apache.spark.{SparkConf, SparkContext}

object Demo23Acc {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setAppName("acc")
    conf.setMaster("local")
    val sc = new SparkContext(conf)

    val studentRDD: RDD[String] = sc.textFile("data/students.txt",2)

    //算子的代码运行在Driver端
    var count = 0

    studentRDD.foreach(stu=>{
      //算子内的代码运行在Executor端
      //在Spark写代码的时候不能在算子内取修改算子外的一个普通变量
      //就算修改了 在算子外也不会生效
      count+=1
      println(count)
    })

    println(count)

    /**
     *
     * 累加器
     *
     */

    //1、自定义累加器
    val countAcc: LongAccumulator = sc.longAccumulator

    studentRDD.foreach(stu =>{

      //2、在算子内对累加器进行累加
      countAcc.add(1)
    })

    //3、在算子外获取累加的结果
    println(countAcc.value)

    while (true){

    }
  }

}

十三、Bro广播函数

package com.shujia.spark.core

import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo24Bro {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setAppName("bro")
    conf.setMaster("local")
    val sc = new SparkContext(conf)

    val studentRDD: RDD[String] = sc.textFile("data/students.txt")

    val scoreRDD: RDD[String] = sc.textFile("data/score.txt")

    //在算子内不能使用其他的RDD来写代码
    //    scoreRDD.foreach(sco=>{
    //      studentRDD.foreach(println)
    //    })

    //将RDD的数据拉取到Driver端，构建成一个数组
    val studentArray: Array[String] = studentRDD.collect()
    //转换为kv格式
    val kvStuRDD: Array[(String, String)] = studentArray.map(stu => {
      val split: Array[String] = stu.split(",")
      val id: String = split(0)
      (id, stu)
    })

    //转换map集合
    val stuMap: Map[String, String] = kvStuRDD.toMap

    //将一个普通的变量广播出去
    val stuMapBro: Broadcast[Map[String, String]] = sc.broadcast(stuMap)

    /**
     * mapjoin：在map端进行表关联 不会产生shuffle
     * 当一个大表和一个小表进行关联的时候可以使用mapjoin
     *
     */

    val joinRDD: RDD[(String, String)] = scoreRDD.map(sco => {
      val split: Array[String] = sco.split(",")
      val id: String = split(0)
      //使用id到学生表的map集合中获取学生的信息
      //在算子内获取广播变量的值
      val broValue: Map[String, String] = stuMapBro.value
      val stuInfo: String = broValue.getOrElse(id, "默认值")
      (stuInfo, sco)
    })

    joinRDD.foreach(println)

    while (true) {

    }
  }

}
刘浩浩yyds
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Pair RDD的操作
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-01 801
大数据实验教学系统Pair RDD的操作一些Spark操作只在键值对的RDDs上可用。Spark在包含key/value对的RDDs上提供了专门的transformation API，包括reduceByKey、groupByKey、sortByKey和join等。   Pair RDDs让我们能够在key上并行操作，或者跨网络重新组织数据。Key/value RDDs常被用于执行聚合操作，以及常被用来完成初始的ETL(extract, transform, load)以获取key/value格式数据。掌握
Spark基础学习：掌握RDD算子（3）
weixin_54425212的博客
06-16 1471
RDD
Java Spark Rdd详解
u013982921的专栏
03-28 2867
说明：掌握spark的一个关键，就是要深刻理解掌握RDD各个函数的使用场景，这样我们在写业务逻辑的时候就知道在什么时候用什么样的函数去实现，得心应手，本文将逐步收集整理各种函数原理及示例代码，持续更新，方便大家学习掌握。 函数列表： 1、join的使用 2、cogroup的使用 3、GroupByKey的使用 4、map的使用 5、flatmap的使用 6、mapPartitions的使用 7...
Spark RDD常用的函数
nwpuxhld
04-25 1320
Spark RDD常用函数
java rdd 聚合_SparkCore系列(二)rdd聚合操作,rdd之间聚合操作
weixin_42342010的博客
02-13 257
countval conf = new SparkConf().setAppName("HelloWorld").setMaster("local")val sc = new JavaSparkContext(conf).scval dataLength = sc.textFile("/software/java/idea/data").flatMap(x=>x.split("\\|"))....
Java 函数组合
qq_36438618的博客
12-11 516
函数组合是一项把多个函数合并到一个函数的技术。你可以自己将多个独立的函数合并成一个函数（比如一个或多个 Java Lambda 表达式），但是对于函数组合 Java 也提供了内置的支持使其变得更为简单。在这篇文章中，我会介绍如何通过你自己或者 Java 内置的支持来组合函数。
Spark每日半小时（8）——PairRDD的聚合操作
DK_ing的博客
06-04 526
当数据集以键值对形式组织的时候，聚合具有相同键的元素进行一些统计是很常见的操作。前面讲解过基础RDD上的fold()、combine()、reduce()等行动操作，pairRDD上则有响应的针对键的转化操作。Spark有一组类似的操作，可以组合具有相同键的值。这些操作返回RDD，因此他们是转化操作而不是行动操作。 reduceByKey() reduceByKey()与reduce()相当类...
【SparkAPI JAVA版】JavaPairRDD——combineByKey（九）
菜鸟sdut的博客
03-20 1041
JavaPairRDD的combineByKey方法讲解 官方文档说明 /** * Generic function to combine the elements for each key using a custom set of aggregation * functions. Turns a JavaPairRDD[(K, V)] into a result of type J...
spark案例分析之：订单数据案例--计算订单分类成交金额
weixin_45484707的博客
09-20 1806
需求： 订单数据案例：（数据检索并将计算结果保存到MySQL中） （1）需求： 在给定的订单数据中，根据订单的分类ID进行聚合，然后按照订单分类名称，统计出某一天商品哥哥分类的成交金额；然后将计算结果保存到MySQL中。 （2）字段说明： oid：订单id，String类型 cid: 商品分类id，Int类型 money: 订单金额，Double类型 longitude: 经度，Double类型 latitude: 纬度，Double类型 （3）分类信息：1.家具；2.手机；3.服装。
Spark核心编程-RDD操作原理分析
上海一九四三
08-11 769
一、union算子内部实现原理剖析 说明：将两个RDD合并，返回两个RDD的并集，返回元素不去重。 二、groupByKey算子内部实现原理剖析 说明：将RDD[K, V]中每个K对应的V值合并到一个集合Iterable[V]中。 三、reduceByKey算子内部实现原理剖析 说明：将RDD[K, V]中每个K对应的V值根据映射函数来运算。 四、distinc...
Spark常用算子
qq_51628990的博客
08-11 4212
fullOuterJoin算子(K,,V)格式的RDD和(K,V)格式的RDD，使用fullOuterJoin结合是以两边的RDD出现的key为主，得到(K(Option(V),Option(W)))会产生shuffle,(K,V)格式的RDD和(K,V)格式的RDD按照相同的K，join得到(K,(V,W))格式的数据，分区数按照大的来。取RDD的差集，subtract两个RDD的类型要一致，结果RDD的分区数与subtract算子前面的RDD分区数多的一致。...
Scala与Spark：大数据处理的完美组合
2401_85639015的博客
08-07 866
函数式编程：支持高阶函数、不可变数据结构等。面向对象编程：支持类和对象的定义，并具备继承、多态等特性。与Java兼容：可以与Java代码互操作，方便使用现有的Java库。表达能力强：代码简洁，能够用更少的代码实现更多功能。Apache Spark是一个开源的分布式计算框架，用于处理大规模数据集。内存计算：通过将数据存储在内存中，显著提升计算速度。RDD（弹性分布式数据集）：提供了一个可以并行处理的数据结构。支持多种编程语言：包括Java、Python、Scala和R。丰富的库支持。
Flink开发：选择Java还是Scala？
王卫东 博客
08-08 541
在大数据实时处理领域，Apache Flink无疑已经成为了一个重要的角色。随着Flink生态的不断成熟，越来越多的企业和开发者开始着手使用Flink来构建高性能、可扩展的实时数据处理应用。然而，在开始Flink项目的时候，一个常见的问题便是：应该使用Java还是Scala进行开发？
基于springboot+mybatis实现的学生管理系统
08-14
springboot 但功能包含(学生，教师，管理员),项目基于springboot2.1.x实现的管理系统。如果你是spring boot初学者，那么此项目非常适合你。如果喜欢，请随手给个star，谢谢。 编译环境 ： jdk 1.8 mysql 5.5 tomcat 7 框架 ： springboot2.0 mybatis jar包管理工具： Maven 编译器 ： IDEA 系统功能 : 学生信息管理 班级信息管理 教师信息管理 课程信息管理 选课信息管理 考勤信息管理 请假信息管理 成绩信息管理 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
rabbitmq-server-3.8.30-1.el7.noarch.rpm
08-14
rabbitmq-server-3.8.30-1.el7.noarch.rpm 是 RabbitMQ 3.8.30 版本的 RPM 软件包，专为 CentOS 7、RHEL 7 等使用 el7 标识的 Linux 发行版构建的。noarch 表示该包是架构无关的，即适用于任何 CPU 架构。此软件包包含 RabbitMQ 服务器及其所需的运行时组件。 rabbitmq-server-3.8.30-1.el7.noarch.rpm 是 RabbitMQ 3.8.30 版本的 RPM 软件包，专为 CentOS 7、RHEL 7 等使用 el7 标识的 Linux 发行版构建的。noarch 表示该包是架构无关的，即适用于任何 CPU 架构。此软件包包含 RabbitMQ 服务器及其所需的运行时组件。
BMS电池管理常用芯片-ads1256(耘天科技).pdf
08-14
BMS电池管理常用芯片，让设计与众不同。
基于Android网络音乐播放器APP设计与实现.docx
08-14
基于Android网络音乐播放器APP设计与实现.docx
Evidently AI - 内部机器学习平台的终极清单
最新发布
08-14
Evidently AI - 内部机器学习平台的终极清单
整理的openjpeg-2.5.2源码，含vs解决方案和vs工程文件、第三方库工程以及两个测试程序
08-14
整理的openjpeg-2.5.2源码，含vs解决方案和vs工程文件、第三方库工程以及两个测试程序，下载下来就能直接编译。OpenJPEG 是用 C 语言编写的开源 JPEG 2000 编解码器。它的开发是为了促进JPEG 2000的使用，这是来自联合图像专家组 ( JPEG ) 的静态图像压缩标准。自 2015 年 5 月起，OpenJPEG 被 ISO/IEC 和 ITU-T 正式认可为JPEG 2000 参考软件。
印象阿里政委体系之阿里政委定位与职责精解.pptx
08-14
印象阿里政委体系之阿里政委定位与职责精解.pptx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刘浩浩yyds

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

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

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

打赏作者

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

抵扣说明：

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

余额充值