1. Toy模板网首页
  2. > Toy博客

Scala入门，idea关联Scala

7月前 作者：陆卿之 分类：Toy博客 阅读(34) 违法举报

这篇具有很好参考价值的文章主要介绍了Scala入门，idea关联Scala。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

idea关联Scala

创建maven项目

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

配置maven仓库

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

添加Scala插件

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

添加相关依赖

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sin</groupId>
    <artifactId>Demo-scala</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.12</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-graphx_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

    </dependencies>

</project>

添加scala的SDK
需要将其提前安装好：安装Scala
Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

创建Scala文件

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

Scala入门，idea关联Scala,大数据,intellij-idea,scala,python

案例

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }

}

阶乘

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object Factorial {
  def factorial(n: Int): Int = {
    if (n == 0) 1
    else n * factorial(n - 1)
  }

  def main(args: Array[String]): Unit = {
    val result = factorial(5)
    println(result) // 输出120
  }

}

素数

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object IsPrime {
  def isPrime(num: Int): Boolean = {
    if (num <= 1) false
    else if (num == 2) true
    else !(2 to (Math.sqrt(num).toInt + 1)).exists(x => num % x == 0)
  }

  def main(args: Array[String]): Unit = {
    println(isPrime(7)) // 输出true
    println(isPrime(15)) // 输出false
  }


}

列表中最大的数

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object ListMax {
  def main(args: Array[String]): Unit = {
    val numbers = List(2, 8, 1, 6, 10, 4)
    val maxNumber = numbers.max
    println(maxNumber) // 输出10
  }
}

计算列表中所有的和

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5)
    val sum = numbers.sum

    println(sum) // 输出15
  }
 
}

遍历列表

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object ForEachList {
  def main(args: Array[String]): Unit = {
    val fruits = List("apple", "banana", "orange")

    fruits.foreach(println)
    // 输出:
    // apple
    // banana
    // orange
  }
}

判断天气

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object IfWeather {
  def main(args: Array[String]): Unit = {
    println(weatherType("sunny")) // 输出It's a sunny day!
    println(weatherType("snowy")) // 输出Unknown weather type.
  }
  def weatherType(weather: String): String = weather match {
    case "sunny" => "It's a sunny day!"
    case "cloudy" => "It's a cloudy day."
    case "rainy" => "Don't forget your umbrella!"
    case _ => "Unknown weather type."
  }
}

九九乘法表

package com.sin

/**
 * @CreateName SIN
 * @CreateDate 2023/08/28 16:36
 * @description
 */
object Multiplication {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$j * $i = ${i * j}\t")
      if (i == j) println()
    }
  }
}

类

Scala的类可以使用class关键字类定义，用法与 Java 类定义相似。类可以包含成员变量、方法、构造函数等。

package com.sin

class Person(name: String, age: Int) {
  // 成员变量
  var gender: String = ""
  
  // 方法
  def greet(): Unit = {
    println(s"你好，我叫 $name 我今年 $age 岁")
  }
  
  // 构造函数
  def this(name: String, age: Int, gender: String) {
    this(name, age)
    this.gender = gender
  }
}

object Demo7 {


  def main(args: Array[String]): Unit = {
   new Person("张三",18).greet;
  }
}

单例模式

可以使用关键字 object 来定义一个单例对象。单例对象只有一个实例，因此它们一般用来保存应用程序的全局状态或提供共享功能。

package com.sin

object Counter {
  // 一个计数器
  private var count = 0
  
  // 增加计数器值的方法
  def increment(): Unit = {
    count += 1
  }
  
  // 获取计数器值的方法
  def getCount(): Int = {
    count
  }

  def main(args: Array[String]): Unit = {
    // 调用 Counter 单例对象的方法并输出计数器的值
    println(Counter.getCount())   // 输出： 0

    Counter.increment()
    Counter.increment()

    println(Counter.getCount())   // 输出： 2

  }
}

模式匹配

package com.sin

/**
 * @author SIN
 * @createTime ${YEAY}/09/15 11:53
 * @use
 */
object Demo7 {


  def matchExample(x: Any): String = x match {
    case 1 => "One"
    case "hello" => "Greeting"
    case true => "True"
    // 通配符模式
    case _ => "Other" // 匹配其他情况
  }

  def main(args: Array[String]): Unit = {
    println(matchExample(1)) // 输出：One
    println(matchExample("hello")) // 输出：Greeting
    println(matchExample(true)) // 输出：True
    
    println(matchExample(10)) // 输出：Other

  }
}

创建文件

package com.sin
/**
 * @author SIN
 * @createTime 2023/09/18 10:38
 * @use 创建文件
 */
object CreateFile {
  def main(args: Array[String]): Unit = {
    //调用createFile方法来创建文件
    createFile("E:/test.txt");
    println("创建成功");
  }

  /**
   * import : 导入包
   * java.io.File ： Java提供的io流包，
   * 互操作性，scala和Java操作的是同一个jvm所以scala可以调用java包
   */
  import java.io.File;
  /**
   * 创建文件
   * @param filename 需要创建的文件名称
   */
  def createFile(filename: String):Unit={
    // 文件，创建文件的地址名称
    val file = new File(filename);
    // 创建新文件
    file.createNewFile();
  }
}

删除文件

package com.sin

/**
 * @author SIN
 * @createTime 2023/09/18 10:57
 * @use 删除文件
 */
object DeleteFIle {
  def main(args: Array[String]): Unit = {
    // 调用deleteFile方法来删除文件
   println( deleteFile("E:/test.txt"))
  }
  import java.io.File;
  /**
   * 删除文件
   * @param fileName 删除文件的地址
   */
  def deleteFile(fileName:String):Boolean={
    //文件，删除文件的地址
    val file = new File(fileName);
    // 判断文件是否存在 （如果文件不存在，则不调用delete方法，减少程序的负荷
    if (file.exists()){
      // 如果存在则删除文件
      return file.delete();
    }else{
      // 如果不存在输出语句
      println(fileName+"该文件不存在")
      return false;
    }
  }
}

写入文件

package com.sin

import java.io.PrintWriter

/**
 * @author SIN
 * @createTime 2023/09/18 11:22
 * @use 将数据写入到文件中
 */
object WriteFile {

  def main(args: Array[String]): Unit = {
    // 调用writeFile方法写入文件
    writeFile("E:/test.txt","Hello,Scala!");
    println("写入成功")
  }

  import java.io.PrintWriter;
  /**
   * 写入文件
   * @param fileName 写入目标文件地址
   * @param content 写入数据
   */
  def writeFile(fileName:String,content:String):Unit={
    // 创建新的打印写入器
    val writer = new PrintWriter(fileName);
    // 写入字符串数据
    writer.write(content);
    //关闭文件流
    writer.close();
  }
}

读文件

package com.sin


/**
 * @author SIN
 * @createTime ${YEAY}/09/15 11:53
 * @use
 */
object Demo7 {

  def main(args: Array[String]): Unit = {
    // 调用 readFile 方法读取文件
    readFile("E:/input.txt")
  }

  import scala.io.Source
  // 读取文件内容并打印
  def readFile(filename: String): Unit = {
    val lines = Source.fromFile(filename).getLines()
    for (line <- lines) {
      println(line)
    }
  }
}

案例任务

将文件中的数据读取存放到List列表中，进行分析数据

package com.sin

import scala.io.Source

/**
 * @author SIN
 * @createTime ${YEAY}/09/18 8:56
 * @use
 */
// 只能通过object对象来运行
// object定义的是一个单例对象，
// 单例对象只是一个实例，一般用来保持应用程序
// 的全局状态，或者提供的共享功能
object PersonTest {
  // 读取文件内容到 List
  def readFileToList(filename: String): List[String] = {
    /**
     * 使用Scala标准库中的Source类来读取文件的内容，并将每一行作为一个字符串元素存储到一个List中。
     *
     * Source.fromFile(filename)：使用Source类的fromFile方法打开指定的文件，并返回一个Source对象，该对象用于读取文件内容。
     * getLines()：Source对象的getLines()方法将文件内容逐行读取，并返回一个迭代器（Iterator），该迭代器包含了文件的每一行。
     * toList：对迭代器调用toList方法，将所有的行组成的集合转换为一个List，其中每个元素都是文件中的一行字符串。
     */
    val lines = Source.fromFile(filename).getLines().toList
    lines
  }

  // 调用 readFileToList 方法读取文件并存储到 List 中
  val dataList = readFileToList("data.txt")

  // 打印 List 中的数据
  dataList.foreach(println)

  // 进行数据分析
  val dataCount = dataList.length
  val dataSum = dataList.map(_.toDouble).sum
  val dataAvg = dataSum / dataCount


  def main(args: Array[String]): Unit = {
    // 打印分析结果
    println(s"数据个数：$dataCount")
    println(s"数据和：$dataSum")
    println(s"数据平均值：$dataAvg")
  }
}

RDD

RDD（弹性分布式数据集）是 Apache Spark 中的核心抽象概念之一。它是一个具有容错性和可并行处理的分布式数据集合，通常用于在大规模数据集上进行并行计算。

RDD 是不可变的，意味着一旦创建就不能修改。它可以从分布式存储系统（比如 HDFS）中加载数据，也可以通过转换操作从已存在的 RDD 或其他数据集创建。

RDD 提供了一组用于数据转换和操作的方法，例如 map、filter、reduce 等。这些转换操作是惰性求值的，意味着它们并不会立即执行，而是在遇到动作操作（如 collect、count、saveAsTextFile 等）时才会触发执行。

RDD 的另一个重要特性是容错性。当某个节点上的数据丢失或失败时，RDD 可以通过日志记录重新计算丢失的数据，从而实现容错和数据恢复。

除了基本的转换和动作操作，RDD 还支持缓存（缓存在内存中）以提高性能，以及自动分区和分片等功能，以便在分布式计算环境中高效地处理大规模数据集。

Spark读取员工薪资数据创建RDD

从内存存储系统中读取数据创建RDD

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

object SparkRDDFromMemory {
  def main(args: Array[String]): Unit = {
    // 创建 SparkConf 对象
    // 创建一个新的 SparkConf 对象，用于存储 Spark 应用程序的配置信息。
    val conf = new SparkConf()
      // 通过 setAppName 方法为 SparkConf 对象设置应用程序的名称为 "SparkRDD从内存中"。
      // 应用程序的名称将在 Spark 集群的 Web UI 或日志中显示，方便识别。
      .setAppName("SparkRDD从内存中")
      // 设置 Spark 应用程序的运行模式为本地模式（local mode）
      // 本地模式是一种在单机上运行 Spark 的模式，而 [*] 则表示使用所有可用的 CPU 核心。
      // 这样设置可以让 Spark 在本地模式下充分利用机器上的全部 CPU 资源进行计算。
      .setMaster("local[*]")

    // 创建 SparkContext 对象
    // SparkContext 是与 Spark 集群进行交互的主要入口点。它负责连接到 Spark 集群并协调应用程序的执行。
    //使用 SparkContext 对象，您可以执行各种操作，如创建 RDD、应用转换和动作操作、管理共享变量等。
    val sc = new SparkContext(conf)

    // 定义数据集合
    val data = List(1, 2, 3, 4, 5)

    // 使用 parallelize 方法将数据集 data 转换为 RDD。data 可以是一个数组、列表或其他可以迭代的数据结构。
    // parallelize 方法将数据拆分成一系列的分区，并将它们分布在 Spark 集群的不同节点上进行并行处理。
    // 每个分区都会被作为一个任务在集群中的一个计算节点上执行，从而实现数据的并行处理。
    val rdd = sc.parallelize(data)

    // 对 RDD 进行操作，例如打印每个元素
    rdd.foreach(println)

    // 关闭 SparkContext
    sc.stop()
  }
}

从外部存储系统中读取数据

package com.sin;

import org.apache.spark.sql.SparkSession
/**
 * @author SIN
 * @createTime 2023/09/18 11:38
 * @use 读取员工工资数据
 */
object EmployeeDataAnalysis {

  def main(args: Array[String]): Unit = {
    // 创建SparkSession对象
    val spark = SparkSession.builder()
      // 给Spark应用程序指定一个名称，
      .appName("员工数据分析")
      // 设置Spark的运行模式为本地模式，并使用所有可用的处理器核心
      // local[*]表示所有的可用的处理器类来运行Spark应用程序
      .master("local[*]")
      // 创建或获取一个SparkSession对象，如果之前已经存在一个SparkSession对象，则会返回该对象，
      // 否则会创建一个新的SparkSession对象，
      .getOrCreate()

    // 读取员工薪资数据文件
    // sparkContext属性获取了一个SparkContext对象，它是与Spark环境进行交互的主要入口
    // textFile方法会将文件的每一行作为RDD中的每一个元素，返回一个RDD[String]对象，其中每一个元素都表示文件中的一行数据
    val employeeDataRDD = spark.sparkContext.textFile("test.txt")

    // 对每一行进行处理，提取员工ID和薪资字段，并创建新的RDD

    /**
     * map对employeeDataRDD中的每个元素进行映射操作
     * 在映射操作中，使用了匿名函数 line => {...} 其中 line 是 employeeDataRDD 的每个元素（即每行数据）。
     */
    val employeeSalaryRDD = employeeDataRDD.map(line => {
      //调用 split(",") 方法，将 line 按逗号分隔成一个字符串数组 fields
      val fields = line.split(",");
      // fields(0) 转换为整型并赋值给 employeeID 变量，
      val employeeID = fields(0).toInt;
      // 将 fields(1) 转换为双精度浮点型并赋值给 salary 变量。
      val salary = fields(1).toDouble;
      // 使用元组 (employeeID, salary) 包装 employeeID 和 salary 变量，并作为 map 操作的结果返回。
      (employeeID, salary);
    })

    // 打印RDD中的数据
    employeeSalaryRDD.foreach(println)



    // 关闭SparkSession对象
    spark.stop()
  }
}

从外部存储系统中读取薪资排名前三的员工

package com.sin

import org.apache.spark.sql.SparkSession

object EmployeeDataAnalysis {

  def main(args: Array[String]): Unit = {
    // 创建SparkSession对象
    val spark = SparkSession.builder()
      // 给Spark应用程序指定一个名称，
      .appName("员工数据分析")
      // 设置Spark的运行模式为本地模式，并使用所有可用的处理器核心
      // local[*]表示所有的可用的处理器类来运行Spark应用程序
      .master("local[*]")
      // 创建或获取一个SparkSession对象，如果之前已经存在一个SparkSession对象，则会返回该对象，
      // 否则会创建一个新的SparkSession对象，
      .getOrCreate()

    // 读取员工薪资数据文件
    // sparkContext属性获取了一个SparkContext对象，它是与Spark环境进行交互的主要入口
    // textFile方法会将文件的每一行作为RDD中的每一个元素，返回一个RDD[String]对象，其中每一个元素都表示文件中的一行数据
    val employeeDataRDD = spark.sparkContext.textFile("test.txt")

    // 对每一行进行处理，提取员工ID和薪资字段，并创建新的RDD

    /**
     * map对employeeDataRDD中的每个元素进行映射操作
     * 在映射操作中，使用了匿名函数 line => {...} 其中 line 是 employeeDataRDD 的每个元素（即每行数据）。
     */
    val employeeSalaryRDD = employeeDataRDD.map(line => {
      //调用 split(",") 方法，将 line 按逗号分隔成一个字符串数组 fields
      val fields = line.split(",");
      // fields(0) 转换为整型并赋值给 employeeID 变量，
      val employeeID = fields(0).toInt;
      // 将 fields(1) 转换为双精度浮点型并赋值给 salary 变量。
      val salary = fields(1).toDouble;
      // 使用元组 (employeeID, salary) 包装 employeeID 和 salary 变量，并作为 map 操作的结果返回。
      (employeeID, salary);
    })

    // 对薪资进行降序排序，并获取前三个员工
    /**
     * employeeSalaryRDD是一个包含员工ID和薪资的元组的RDD，它是通过对原始数据进行映射操作得到的。
     * top操作的参数为3，表示我们希望获取前三个元素。
     * Ordering[Double].on(_._2)指定了排序的方式。_._2表示以元组的第二个元素（薪资）作为排序依据。
     * Ordering[Double]表示按照双精度浮点数进行排序，并且降序排列
     */
    val top3Employees = employeeSalaryRDD.top(3)(Ordering[Double].on(_._2))

    // 输出结果
    /**
     * top3Employees是一个包含前三个员工的元组（员工ID和薪资）的RDD。
     * foreach方法用于对RDD进行迭代，对RDD中的每个元素执行指定的操作。
     * { case (employeeID, salary) => ... }是一个Scala语言特有的模式匹配语法。
     * 它将元组中的两个值分别绑定到employeeID和salary变量，并在括号内执行打印操作。
     */
    top3Employees.foreach{ case (employeeID, salary) =>
      // println(s"员工ID：$employeeID，薪资：$salary")用于将员工ID和薪资信息打印到控制台上，格式化字符串中的$employeeID和$salary将被实际的值替换。
      println(s"员工ID：$employeeID，薪资：$salary")
    }
    // 关闭SparkSession对象
    spark.stop()
  }
}

模拟数据

101,5000.0
102,6000.0
103,4500.0
104,7000.0
105,5500.0

查询薪资超过5千的员工

package com.sin

import org.apache.spark.sql.SparkSession

object EmployeeDataAnalysis {

  def main(args: Array[String]): Unit = {
    // 创建SparkSession对象
    val spark = SparkSession.builder()
      // 给Spark应用程序指定一个名称，
      .appName("员工数据分析")
      // 设置Spark的运行模式为本地模式，并使用所有可用的处理器核心
      // local[*]表示所有的可用的处理器类来运行Spark应用程序
      .master("local[*]")
      // 创建或获取一个SparkSession对象，如果之前已经存在一个SparkSession对象，则会返回该对象，
      // 否则会创建一个新的SparkSession对象，
      .getOrCreate()

    // 读取员工薪资数据文件
    // sparkContext属性获取了一个SparkContext对象，它是与Spark环境进行交互的主要入口
    // textFile方法会将文件的每一行作为RDD中的每一个元素，返回一个RDD[String]对象，其中每一个元素都表示文件中的一行数据
    val employeeDataRDD = spark.sparkContext.textFile("test.txt")

    // 对每一行进行处理，提取员工ID和薪资字段，并创建新的RDD

    /**
     * map对employeeDataRDD中的每个元素进行映射操作
     * 在映射操作中，使用了匿名函数 line => {...} 其中 line 是 employeeDataRDD 的每个元素（即每行数据）。
     */
    val employeeSalaryRDD = employeeDataRDD.map(line => {
      //调用 split(",") 方法，将 line 按逗号分隔成一个字符串数组 fields
      val fields = line.split(",");
      // fields(0) 转换为整型并赋值给 employeeID 变量，
      val employeeID = fields(0).toInt;
      // 将 fields(1) 转换为双精度浮点型并赋值给 salary 变量。
      val salary = fields(1).toDouble;
      // 使用元组 (employeeID, salary) 包装 employeeID 和 salary 变量，并作为 map 操作的结果返回。
      (employeeID, salary);
    })

    // 筛选出薪资大于5万的员工
    val highSalaryEmployeeRDD = employeeSalaryRDD.filter { case (employeeID, salary) =>
      salary > 5000
    }

    // 输出结果
    // 打印符合条件的员工信息
    highSalaryEmployeeRDD.foreach { case (employeeID, salary) =>
      println(s"员工ID：$employeeID，薪资：$salary")
    }
    // 关闭SparkSession对象
    spark.stop()
  }
}

查询所有员工的平均数

package com.sin

import org.apache.spark.sql.SparkSession

object EmployeeDataAnalysis {

  def main(args: Array[String]): Unit = {
    // 创建SparkSession对象
    val spark = SparkSession.builder()
      // 给Spark应用程序指定一个名称，
      .appName("员工数据分析")
      // 设置Spark的运行模式为本地模式，并使用所有可用的处理器核心
      // local[*]表示所有的可用的处理器类来运行Spark应用程序
      .master("local[*]")
      // 创建或获取一个SparkSession对象，如果之前已经存在一个SparkSession对象，则会返回该对象，
      // 否则会创建一个新的SparkSession对象，
      .getOrCreate()

    // 读取员工薪资数据文件
    // sparkContext属性获取了一个SparkContext对象，它是与Spark环境进行交互的主要入口
    // textFile方法会将文件的每一行作为RDD中的每一个元素，返回一个RDD[String]对象，其中每一个元素都表示文件中的一行数据
    val employeeDataRDD = spark.sparkContext.textFile("test.txt")

    // 对每一行进行处理，提取员工ID和薪资字段，并创建新的RDD

    /**
     * map对employeeDataRDD中的每个元素进行映射操作
     * 在映射操作中，使用了匿名函数 line => {...} 其中 line 是 employeeDataRDD 的每个元素（即每行数据）。
     */
    val employeeSalaryRDD = employeeDataRDD.map(line => {
      //调用 split(",") 方法，将 line 按逗号分隔成一个字符串数组 fields
      val fields = line.split(",");
      // fields(0) 转换为整型并赋值给 employeeID 变量，
      val employeeID = fields(0).toInt;
      // 将 fields(1) 转换为双精度浮点型并赋值给 salary 变量。
      val salary = fields(1).toDouble;
      // 使用元组 (employeeID, salary) 包装 employeeID 和 salary 变量，并作为 map 操作的结果返回。
      (employeeID, salary);
    })

    // 计算薪资的总和和总人数
    // reduce操作对员工薪资RDD进行聚合操作，将每个元素的值按照指定的逻辑进行合并
    // reduce操作接受一个函数作为参数，这个函数定义了如何合并两个元素的值。
    // 函数中的参数((id1, salary1), (id2, salary2))表示两个元素，分别由员工ID和薪资组成。
    val totalSalaryAndCount = employeeSalaryRDD.reduce { case ((id1, salary1), (id2, salary2)) =>
      // 在reduce操作中，将两个元素的薪资进行相加，并保持员工ID不变。
      // 这样就得到了一个新的元素，包含了累加后的薪资总和以及最后一个员工的ID。
      (id1, salary1 + salary2)
    }
    // totalSalaryAndCount是一个元组，其中包含了最后一个员工的ID和累加后的薪资总和。
    // 通过totalSalaryAndCount._2可以获取元组的第二个元素，即累加后的薪资总和，并将其赋值给totalSalary变量。
    val totalSalary = totalSalaryAndCount._2
    // employeeSalaryRDD.count()用于计算员工薪资RDD中的元素个数，即员工人数，并将结果赋值给totalCount变量。
    val totalCount = employeeSalaryRDD.count()

    // 计算薪资的平均值
    // totalSalary是薪资的总和，由前面的代码计算得到。
    //totalCount是员工人数，由前面的代码计算得到。
    //将薪资的总和totalSalary除以员工人数totalCount，得到薪资的平均值。
    val averageSalary = totalSalary / totalCount

    println(s"薪资的平均值为：$averageSalary")
    // 关闭SparkSession对象
    spark.stop()
  }
}

计算前十的成绩

import scala.io.Source

object DataAnalysis {
  def main(args: Array[String]): Unit = {
    // 从外部文件中读取数据
    val dataFilePath = "test.txt"  // 替换为实际的数据文件路径
    val data = readDataFromFile(dataFilePath)

    // 分析数据，计算每个人的平均成绩
    val averageScores = calculateAverageScores(data)

    // 输出前10名的平均成绩
    outputTop10AverageScores(averageScores)
  }

  //读取文件并存放到list列表中
  def readDataFromFile(filePath: String): List[(String, List[Double])] = {
    // 从给定的文件路径读取数据文件，并将内容按行读取为字符串列表
    val lines = Source.fromFile(filePath).getLines().toList
    // 遍历每一行数据，进行处理和转换
    lines.map { line =>
      // 将每一行数据按空格分割成数组
      val split = line.split("\\s+")
      // 取数组的第一个元素作为名字
      val name = split.head
      // 取数组的剩余部分，并将其中的每个字符串转换成双精度浮点数，并转换为列表类型
      val scores = split.tail.map(_.toDouble).toList
      // 返回名字和分数列表组成的二元组
      (name, scores)
    }
  }



//  计算平均分
  def calculateAverageScores(data: List[(String, List[Double])]): List[(String, Double)] = {
    // 对于输入的数据列表中的每个元素（每个二元组），进行处理和转换
    data.map { case (name, scores) =>
      // 计算分数列表的总和，并除以列表的长度，得到平均分
      val averageScore = scores.sum / scores.length
      // 将学生的名字和平均分组成一个二元组
      (name, averageScore)
    }
  }

// 输出前十的学生
  def outputTop10AverageScores(averageScores: List[(String, Double)]): Unit = {
    // 根据平均成绩对学生列表进行降序排序
    val sortedScores = averageScores.sortBy(_._2)(Ordering[Double].reverse)
    // 取出排序后的前10个元素，即前10名学生的平均成绩
    val top10Scores = sortedScores.take(10)

    // 输出前10名学生的平均成绩
    println("前10的平均成绩:")
    var a: Int = 1;
    top10Scores.foreach { case (name, score) =>
      // 逐行输出学生姓名和平均成绩
      println(s"第$a 名 $name\t$score")
      a += 1
    }
  }

}

统计分析竞赛网站用户访问日志数据

import scala.io.Source

object LogAnalysis {
  def main(args: Array[String]): Unit = {
    // 读取日志文件
    val filePath = "test.txt"
    val logLines = Source.fromFile(filePath).getLines().toList

    // 统计总的访问次数
    val numVisits = logLines.length

    // 统计每个用户的访问次数
    val visitsByUser = logLines
      .map(_.split("\t")(0)) // 假设日志文件以制表符分隔，并用户ID在第一列
      .groupBy(identity)
      .mapValues(_.length)

    // 输出结果
    println(s"总访问次数: $numVisits")
    println("每个用户的访问次数:")
    visitsByUser.foreach { case (user, count) =>
      println(s"用户 $user: $count 次访问")
    }
  }
}

模拟数据文章来源地址https://www.toymoban.com/news/detail-679166.html

user1    2023-09-20 10:00:00
user2    2023-09-20 12:00:00
user1    2023-09-20 14:00:00
user3    2023-09-21 09:00:00
user1    2023-09-21 11:00:00
user2    2023-09-22 08:00:00
user3    2023-09-23 15:00:00
user2    2023-09-20 12:00:00

访问最多和最好用户

import scala.io.Source

object LogAnalysis {
  def main(args: Array[String]): Unit = {
    // 读取日志文件
    val filePath = "test.txt"
    val logLines = Source.fromFile(filePath).getLines().toList

    // 统计总的访问次数
    val numVisits = logLines.length

    // 统计每个用户的访问次数
    val visitsByUser = logLines
      .map(_.split("\t")(0)) // 假设日志文件以制表符分隔，并用户ID在第一列
      .groupBy(identity)
      .mapValues(_.length)

    // 输出结果
    println(s"总访问次数: $numVisits")
    println("每个用户的访问次数:")
    visitsByUser.foreach { case (user, count) =>
      println(s"用户 $user: $count 次访问")
    }

    // 找出访问最多和访问最少的用户
    val maxVisits = visitsByUser.maxBy(_._2)
    val minVisits = visitsByUser.minBy(_._2)

    println(s"访问最多的用户: ${maxVisits._1}，访问次数: ${maxVisits._2}")
    println(s"访问最少的用户: ${minVisits._1}，访问次数: ${minVisits._2}")
  }
}

将读取的数据存放到另外一文件中

import scala.io.Source
import java.io.File
import java.io.PrintWriter

object LogAnalysis {
  def main(args: Array[String]): Unit = {
    // 读取日志文件
    val filePath = "test.txt"
    val logLines = Source.fromFile(filePath).getLines().toList

    // 统计总的访问次数
    val numVisits = logLines.length

    // 统计每个用户的访问次数
    val visitsByUser = logLines
      .map(_.split("\t")(0)) // 假设日志文件以制表符分隔，并用户ID在第一列
      .groupBy(identity)
      .mapValues(_.length)

    // 输出结果到控制台
    println(s"总访问次数: $numVisits")
    println("每个用户的访问次数:")
    visitsByUser.foreach { case (user, count) =>
      println(s"用户 $user: $count 次访问")
    }

    // 将结果写入到文件
    val outputFile = new File("output.txt")
    val writer = new PrintWriter(outputFile)
    writer.println(s"总访问次数: $numVisits")
    writer.println("每个用户的访问次数:")
    visitsByUser.foreach { case (user, count) =>
      writer.println(s"用户 $user: $count 次访问")
    }
    writer.close()
    println(s"结果已经写入到文件 ${outputFile.getAbsolutePath}")
  }
}

到了这里，关于Scala入门，idea关联Scala的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java开发+Intellij-idea+Maven+工程构建

    Java开发+Intellij-idea+Maven+工程构建

    Intellij-idea是一款流行的Java集成开发环境，它支持Maven作为项目管理和构建工具。Maven可以帮助开发者自动下载项目依赖的jar包，执行编译、测试、打包等生命周期任务。本资源将介绍如何在Intellij-idea中创建、导入、转换和编译Maven工程，以及如何配置Maven的相关参数和插件。

    2024年02月01日
    浏览(70)
  • Java项目使用intellij-IDEA查看依赖包版本是否有冲突（方法及工具）附截图

    Java项目使用intellij-IDEA查看依赖包版本是否有冲突（方法及工具）附截图

    编译器及版本 idea-ultimate 依赖管理工具 maven Step1：点击右侧的maven Step2：右键依赖项，点击分析依赖关系 Step3：可以在模块名位置进行切换，左侧三角的标志则表示该包引入了多个版本，有冲突 Step4：可以看到当前这个包被引入了两个版本的 Step5：右键冲突的包名，可以看到

    2024年02月15日
    浏览(74)
  • IntelliJ IDEA下基于Scala实现的Git检查工具

    IntelliJ IDEA下基于Scala实现的Git检查工具

    本文使用Scala实现自定义的Git检查工具,读者可以基于本文的示例进行扩展与实现,也可以进行其他应用方向的尝试。 在实现Git检查工具之前需要知道程序究竟要做什么。我们知道,在管理Git分支时可以进行代码合并操作,这样可以将其他开发者提交的内容同步到当前分支中,当用

    2024年02月12日
    浏览(32)
  • 【Scala入门】Scala下载及安装（Windows）以及Idea创建第一个scala项目

    【Scala入门】Scala下载及安装（Windows）以及Idea创建第一个scala项目

    目录 一、安装准备 二、Scala下载安装 三、Idea 创建Scala项目 在安装之前，确保你的电脑上装有Jdk 8（Jdk 1.8），且环境变量配置正确。如果没有安装Jdk，请参照其他文章先安装Jdk 8（Jdk 1.8）。 （1）确认环境变量方法：使用Win + R 快捷键调出下面窗口，输入“cmd”，按下回车。

    2024年02月05日
    浏览(40)

  • 使用IntelliJ IDEA 配置Maven（入门）

    使用IntelliJ IDEA配置Maven时，需要按照以下步骤进行操作。请注意，由于涉及到软件安装和配置，以下步骤可能会因为版本更新而略有变化。 1、下载并安装IntelliJ IDEA 首先，需要下载并安装最新版本的IntelliJ IDEA集成开发环境。你可以从官方网站（https://www.jetbrains.com/idea/）下载

    2024年02月19日
    浏览(40)
  • IntelliJ IDEA创建javaweb项目入门级教程

    IntelliJ IDEA创建javaweb项目入门级教程

    目录 开始创建！ 1.创建java项目 2.创建web项目 3.创建目录文件 4.配置TomCat IDEA版本：2022.1.3 Java版本：11 Tomcat版本：9.0.17 1.创建java项目 在IDEA中选择new—Project，在New Project的选项里进行编辑项目名字，JDK版本 此时我们已经创建了一个普通的java项目，需要创建web项目  2.创建web项

    2024年02月03日
    浏览(51)
  • IntelliJ IDEA上手这一篇就够了，从入门到上瘾

    IntelliJ IDEA上手这一篇就够了，从入门到上瘾

    每次换电脑，最最最头疼的事情莫过于安装各种软件和搭建开发环境。这算是不想换电脑的一个原因吧（最主要还是穷）。除非是电脑坏了开不了机或者点一下卡一下，真不想换电脑。每次换电脑都得折腾好久。 趁着这次换电脑了，顺便整理下IDEA安装使用及配置。 官网提供

    2024年02月05日
    浏览(29)
  • 大数据技术——使用IDEA开发Scala程序

    大数据技术——使用IDEA开发Scala程序

    一、使用IDEA开发WordCount程序... 3 二、实验目的... 3 三、实验要求... 3 四、实验环境... 3 五、实验步骤... 3 4.1.1启动IDEA并创建一个新项目WordCount 3 4.1.2为WordCount项目添加Scala框架支持... 7 4.1.3数据准备... 8 4.1.4设置项目目录... 9 4.1.5新建Scala代码文件... 10 4.1.6配置pom.xml文件... 12

    2024年02月09日
    浏览(30)
  • 大数据开发语言Scala（一）——scala入门

    大数据开发语言Scala（一）——scala入门

    累了，基础配置不想写了，直接抄了→Scala的环境搭建 这里需要注意的是，创建新项目时，不要用默认的Class类，用Object，原因看→scala中的object为什么可以直接运行 package ： 包，等同于java中的package object ：，声明一个单例对象（伴生对象） main方法 ：从外部可以直接

    2024年02月05日
    浏览(45)
  • 2023最新版IntelliJ IDEA安装教程（非常详细）从零基础入门到精通，看完这一篇就够了

    2023最新版IntelliJ IDEA安装教程（非常详细）从零基础入门到精通，看完这一篇就够了

    IDEA的使用 IDEA的简单介绍 IDEA的主要优势 IDEA的卸载 IDEA的安装 第一个程序：HelloWorld 结束语 IDEA全称IntelliJ IDEA，是Java语言对的集成开发环境，IDEA在业界被认为是公认最好的Java开发工具。 ✅功能强大 ①强大的整合能力。比如：Git Maven Spring等 ②开箱即用的体验（集成版本控制

    2024年02月15日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包