spark入门（4）----scala扫盲（1）

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

scala方法和函数区别

注意：方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型

  //定义方法
    def m2(f:(Int,Int)=>Int) = f(2,6)

    //定义函数
    val f2 = (x:Int,y:Int) => x-y

    val a = m2(f2)

    println("the result is: "+a)

    //将方法转化为函数(神奇的“_”将m2这个方法变为了函数)
    val f1 = m2 _

    println(f1(f2))

数组、映射、元组、集合

//初始化一个长度为8的定长数组，其所有元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)

    //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

    //////////////////////////////////////////////////
    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab

    //在数组某个位置插入元素用insert
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove
    ab.remove(8, 2)
    println(ab)
  }

遍历数组

//初始化一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for(i <- arr)
      println(i)

    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }

数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

  //定义一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //用yield关键字生成一个新的数组
    val res = for( e <- arr if e%2==0 )
      yield e*2
    println(res.toBuffer)

    //map方法更好用
    val res2 = arr.filter(_%2==0).map(_*2)
    println(res2.toBuffer)

数组转换

  //定义一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //用yield关键字生成一个新的数组
    val res = for( e <- arr if e%2==0 )
      yield e*2
    println(res.toBuffer)

    //map方法更好用
    val res2 = arr.filter(_%2==0).map(_*2)
    println(res2.toBuffer)

数组常用算法

 val arr = Array(2,5,1,4,3)
    //求和
    println(arr.sum)
    //秋最大值
    println(arr.max)
    //排序
    println(arr.sorted.toBuffer)

哈希表（映射）

注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变

//第一种：->
    val scores1 = Map("tom"->85,"jetty"->99,"kitty"->90)
    println(scores1)

    //第二种：元组
    val scores = Map(("tom",85),("jetty",99),("kitty",90))
    println(scores)


    //获取
    println(scores("jetty"))

    //getOrElse
    val o1= scores.getOrElse("tian",0)
    println(o1)

    //修改scala.collection.mutable.Map中的值
    val scores2 = scala.collection.mutable.Map("tom"->80,"jim"->40)
    scores2("jim")=50
    println(scores2)

常用函数

//创建一个List
    val lst0 = List(1,7,9,8,0,3,5,4,6,2)
    //将lst0中每个元素乘以10后生成一个新的集合
    val tem = lst0.map(_*10)
    println(tem)

    //将lst0中的偶数取出来生成一个新的集合
    val tem1 = lst0.filter( x=> x%2==0)
    println(tem1)

    //将lst0排序后生成一个新的集合
    val tem2 = lst0.sorted
    println(tem2)

    //反转顺序
    println(lst0.reverse)

    //将lst0中的元素4个一组,类型为Iterator[List[Int]]
    val tem3 = lst0.grouped(4)
    println(tem3.toList)

    //将Iterator转换成List
    val tem4 = lst0.grouped(4).toList
    println(tem4)

    //将多个list压扁成一个List
    println(tem4.flatten)

    val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")
    //先按空格切分，在压平
    val line = lines.flatMap(_.split(" ")).map((_,1))
      .groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))

    println(line.toList.sortBy(_._2).reverse)


    //并行计算求和
     lst0.par
    println(lst0.par.reduce(_+_))

    //化简：reduce
    //将非特定顺序的二元操作应用到所有元素
//    reduce()
    //按照特定的顺序
//    reduceLeft()



    //折叠：有初始值（无特定顺序）
//    fold()()

    //折叠：有初始值（有特定顺序）
//    floldLeft()


    //聚合
    val arr = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))
    val result = arr.aggregate(0)(_+_.sum,_+_)
    println(result)


    val l1 = List(5,6,4,7)
    val l2 = List(1,2,3,4)
    //求并集
    val temp1 = l1.union(l2)
//    val temp1 = l1 union l2
    println(temp1)

    //求交集
    val temp2 = l1.intersect(l2)
    println(temp2)

    //求差集
    val temp3 = l1.diff(l2)
    println(temp3)
################################

    val lines = List("wo shi ni hao","wo shi shi tian jun","ha ha ha ha")
//    val line = lines.map(_.split(" ")).flatten
    val line = lines.flatMap(_.split(" "))
    val words = line.map((_,1)).groupBy(_._1)

    //方法一：
    val total = words.map(t=>(t._1,t._2.size))
    val result1 = total.toList.sortBy(_._2).reverse
    println(result1)

    //方法二：
    val result2 = words.mapValues(_.size)
    println(result2)

    //方法三：
    val total3=words.mapValues(_.foldLeft(0)(_+_._2))
    println(total3)
List((ha,4), (shi,3), (wo,2), (hao,1), (ni,1), (jun,1), (tian,1))
Map(tian -> 1, ha -> 4, jun -> 1, shi -> 3, ni -> 1, wo -> 2, hao -> 1)
Map(tian -> 1, ha -> 4, jun -> 1, shi -> 3, ni -> 1, wo -> 2, hao -> 1)

scala和java混合开发的pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>tianjun.cmcc.org</groupId>
  <artifactId>mytest</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>

  <name>A Camel Scala Route</name>
  <url>http://www.myorganization.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
      </dependency>
      <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-parent</artifactId>
        <version>2.18.1</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-scala</artifactId>
    </dependency>

    <!-- scala -->
    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>2.11.7</version>
    </dependency>
    <dependency>
      <groupId>org.scala-lang.modules</groupId>
      <artifactId>scala-xml_2.11</artifactId>
      <version>1.0.4</version>
    </dependency>

    <!-- logging -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-slf4j-impl</artifactId>
      <scope>runtime</scope>
    </dependency>

    <!-- testing -->
    <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>repository.junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.2.2</version>
    </dependency>
  </dependencies>



  <build>
    <defaultGoal>install</defaultGoal>
    <sourceDirectory>src/main/scala</sourceDirectory>
    <testSourceDirectory>src/test/scala</testSourceDirectory>

    <plugins>

      <!-- the Maven compiler plugin will compile Java source files -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.5.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.0.1</version>
        <configuration>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>

      <!-- the Maven Scala plugin will compile Scala source files -->
      <plugin>
        <groupId>net.alchim31.maven</groupId>
        <artifactId>scala-maven-plugin</artifactId>
        <version>3.2.2</version>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>testCompile</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <!-- configure the eclipse plugin to generate eclipse project descriptors for a Scala project -->
      <!--<plugin>-->
        <!--<groupId>org.apache.maven.plugins</groupId>-->
        <!--<artifactId>maven-eclipse-plugin</artifactId>-->
        <!--<version>2.10</version>-->
        <!--<configuration>-->
          <!--<projectnatures>-->
            <!--<projectnature>org.scala-ide.sdt.core.scalanature</projectnature>-->
            <!--<projectnature>org.eclipse.jdt.core.javanature</projectnature>-->
          <!--</projectnatures>-->
          <!--<buildcommands>-->
            <!--<buildcommand>org.scala-ide.sdt.core.scalabuilder</buildcommand>-->
          <!--</buildcommands>-->
          <!--<classpathContainers>-->
            <!--<classpathContainer>org.scala-ide.sdt.launching.SCALA_CONTAINER</classpathContainer>-->
            <!--<classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>-->
          <!--</classpathContainers>-->
          <!--<excludes>-->
            <!--<exclude>org.scala-lang:scala-library</exclude>-->
            <!--<exclude>org.scala-lang:scala-compiler</exclude>-->
          <!--</excludes>-->
          <!--<sourceIncludes>-->
            <!--<sourceInclude>**/*.scala</sourceInclude>-->
            <!--<sourceInclude>**/*.java</sourceInclude>-->
          <!--</sourceIncludes>-->
        <!--</configuration>-->
      <!--</plugin>-->

      <!-- allows the route to be run via 'mvn exec:java' -->
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.5.0</version>
        <configuration>
          <mainClass>tianjun.cmcc.org.MyRouteMain</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>
tianjun2012
关注
专栏目录
Scala_1
lixiaoguang0515的博客
10-16 549
学习Scala第一天 REPL:Read(取值) -> Evaluation(求值)->Print(打印) ->Loop(循环) paste是计入粘贴模式 tab键可以自动补全 内置变量 例如: 输入1+1 会看到res0:lnt=2 2.0*res0,返回res1: double=4.0 声明变量 1.val : 值不可变 2.var : 值可变 指定类型 无论声明变量v...
Spark（七） -- Scala快速入门
weixin_30872867的博客
05-18 291
Scala作为Spark的开发语言，想要成为Spark高手，精通Scala是必须要走的一条路 然后一门语言并不是你想精通就能够精通的，更何况是Scala这种面向对象又面向函数的编程语言，个人觉得其学习的门槛会比C#，Java等面向对象语言要高 所以，这篇文章是建立在有一点编程语言知识的基础上的（如学过C#或者Java等），其实所有语言都是大同小异的，学会了一门语言在学其他的...
Scala与Spark：大数据处理的完美组合
最新发布
2401_85639015的博客
08-07 1118
函数式编程：支持高阶函数、不可变数据结构等。面向对象编程：支持类和对象的定义，并具备继承、多态等特性。与Java兼容：可以与Java代码互操作，方便使用现有的Java库。表达能力强：代码简洁，能够用更少的代码实现更多功能。Apache Spark是一个开源的分布式计算框架，用于处理大规模数据集。内存计算：通过将数据存储在内存中，显著提升计算速度。RDD（弹性分布式数据集）：提供了一个可以并行处理的数据结构。支持多种编程语言：包括Java、Python、Scala和R。丰富的库支持。
带你走进Spark编程之Scala入门
weixin_34023863的博客
08-04 187
写在前边的话： 1：什么是Scala？ Scala是一门多范式的编程语言，类似于Java，并集成了面向对象编程和函数式编程的各种特性，具体可参考知乎上的一个帖子 2：本篇博客包含哪些内容？ Scala中变量的声明与函数定义 Scala中的控制结构 Scala中的数据类型 Scala中的类详解 1：变量...
Spark(一) ：Scala
qq_35909080的博客
08-10 2402
1  Scala是一门怎样的语言，具有哪些优点  一致性 : 静态类型系统+面向对象+函数式编程 面向对象 : 所有的变量和方法都封装在对象中 函数式编程 :函数可以独立存在，可以定义一个函数作为 另外一个函数的返回值，也可以接受函数作为函数的参数 异步编程 : 函数式编程提倡变量不可变，使得异步编程变得十分容易 基于JVM : Scala会被编译成为Bytecode，所以Scala能无...
Scala_(1)_基础
在路上
05-18 529
1.函数 sum(1 to 100:_*)// 提取出1-100中的所有元素,并实现sum操作 2.lazy 只有在初次运行时调用 如：lazy val content = fromFile(path) 3.集合 val arr = new Array[Int](5) 4.高阶函数 arr.filter(_%2 == 0).map(i =>i * i
spark-3.2.4-bin-hadoop3.2-scala2.13 安装包
08-28
1. **Spark**: Spark的核心在于它的弹性分布式数据集（RDD），这是一个容错的内存计算模型。它提供了一组高级APIs，支持批处理、交互式查询（Spark SQL）、实时流处理（Spark Streaming）和机器学习（MLlib）等多种...
spark-Scala-介绍-教程-入门-手册-调研1
08-03
如果使用`java`命令，需要确保`scala-library.jar`在classpath中。 5. **Scala开发环境** 安装Scala通常涉及下载安装包并设置环境变量`SCALA_HOME`和`PATH`。Windows用户可以选择MSI安装包，自动配置环境变量。...
spark-archetype-scala:用于引导Spark Scala项目的Maven原型
05-12
Maven原型将支持一个新的Spark Scala项目 有关最新版本，请转到 。 此回购仅在原型开发过程中使用，但随后的所有更改和错误修复都归于官方书籍的回购中。 不是最新的： 生成一个新项目 由于IntelliJ IDEA在尝试...
Spark-Scala-Maven-示例：Spark，Scala项目的示例Maven配置
02-03
4. **Maven Scala插件**：使用`maven-scala-plugin`来编译Scala源代码。 5. **Maven Surefire Plugin**：用于执行测试，确保在构建过程中包含Scala测试。 6. **Maven Assembly Plugin**或`maven-shade-plugin`：用于...
spark-3.5.1-bin-hadoop3.tgz
04-22
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab ...与 Hadoop 不同，Spark 和 Scala 能够紧密集成，其中的 Scala 可以像操作本地集合对象一样轻松地操作分布式数据集。
Spark 入门之 Scala 语言解释及示例讲解
02-24
Scala 语言衍生自 Funnel 语言。Funnel 语言尝试将函数式编程和 Petri 网结合起来，而 Scala 的预期目标是将面向对象、函数式编程和强大的类型系统结合起来，同时让人要能写出优雅、简洁的代码。本文希望通过一系列 Java 与 Scala 语言编写的相同程序代码的对比，让读者能够尽快地熟悉 Scala 语言。
scala 写spark
tantieshuai的博客
04-20 769
package DAO; import java.sql._ import java.text.SimpleDateFormat import java.util.{List, Date, HashMap, Properties} import com.google.protobuf.TextFormat.ParseException import org.apache.hadoop.conf
Spark学习--scala
ddhdzt的专栏
08-07 501
Scala语法 1.值和变量 val 值，不能发生变化 var 变量，可以发生变化 scala> val a:Int = 1 a: Int = 1 scala> a = 2; :12: error: reassignment to val a = 2; ^ scala> var a:Int = 2 a: Int = 2 scala> a = 3 a: In
spark学习—Scala（基础部分）
weixin_42663941的博客
11-22 271
Spark学习—Scala（基础部分） （一）Scala简介 scala 是一种多范式编程软件，既包括函数式编程又包括面向对象式编程。什么是函数式编程？函数式编程是一种编程模型，将计算机运算看做是数学中函数的计算，并且避免了状态以及变量的概念。（对于函数式编程可以参考我的Spark学习—官方文档学习这篇文章里的代码） （二）编程实践 Scala编程支持命令行的形式也可以通过idea的Scala插件...
Scala 开发 Spark 程序
草宝虫的博客
04-22 448
看spark和scala版本 运行spark-shell Welcome to ____ __ / __/__ ___ _____/ /__ _\ \/ _ \/ _ `/ __/ '_/ /___/ .__/\_,_/_/ /_/\_\ version 1.6.0 /_/ Using Scala version 2.10.5 (Java HotSpot(TM) 64-Bit...
Scala | Spark核心编程 | SparkCore | 算子
liujiesxs的博客
07-21 703
RDD算子-Transformations转换算子、Action行动算子与持久化算子介绍及实战
03 Spark组件 —— Scala统一类型
qq_43028664的博客
03-10 171
03 Scala 统一类型Scala类型层次结构类型转换Nothing和Null 在Scala中，所有的值都有类型，包括数值和函数。下图阐述了类型层次结构的一个子集。 Scala类型层次结构 Any是所有类型的超类型，也称为顶级类 型。它定义了一些通用的方法如equals、hashCode和toString。Any有两个直接子类：AnyVal和AnyRef。 AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Bo
Spark-RDD-Scala 算子操作数据源分析
"data01.txt 是一个用于 Spark RDD Scala 算子操作的示例数据文件，包含多行数据，每行数据由四部分组成：姓名、技能领域、在该领域的评分（可能是技能掌握程度）和未知字段。数据涉及多个计算机科学和技术主题，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值