Scala基础部分知识点

最新推荐文章于 2024-09-11 14:10:29 发布
最新推荐文章于 2024-09-11 14:10:29 发布
阅读量180 收藏
点赞数
文章标签： 大数据 scala spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnswerLinWJ/article/details/115085874
版权

Scala

scala基础

数据类型

在这里插入图片描述

易混淆：

在这里插入图片描述

变量和常量的声明

package scala.basic

/**
  * scala:
  * 1. scala object 相当于java中的单例，object中定义的全是静态的（相当与java的工具类）
  * 2. scala 中定义变量使用var，定义常量使用val，变量可变，常量不可变
  * 3. scala 中每行后面会有分号自动推断机制，可以不写“；”
  * 4. 建议Scala中命名使用驼峰命名法
  */

object objectClass {
  def main(args: Array[String]): Unit = {
    val a = 100;
    var b = 200
    b = 300
    println(a)
    println(b)
    
  }

}

类和对象

package scala.basic

/**
  * scala:
  * 5. Scala类中可以传参，传参一定要指定类型，有了参实就有了默认构造
  * 6. 类中属性默认有getter和setter方法
  * 7. 类中重写构造,构造中第一行必须先调用默认构造。def this（。。）{。。}
  * 8. Scala当new class 时，类中除了方法不执行【除构造】，其他都执行。在类中可直接写语句
  * 9. 在同一个scala文件中，class名称和Object名称一样时，这个类叫做这个对象的伴生类，这个对象叫做这个类的半生对象，它们可以互相访问私有变量
  * 10. 对象不能传参，要传参，使用apply方法
  */

//类
class Person(name:String,age:Int){
  val xname = name
  var xage = age

  var gender = 'M'

  //重写构造
  def this(yname:String,yage:Int,ygender:Char){
    //必须调用默认构造
    this(yname,yage)
    this.gender = ygender
  }

  //方法
  def sayName():Unit = {
    println("hello " + xname)
  }
}

//对象
object objectClass {
  def main(args: Array[String]): Unit = {

    val p = new Person("lisi",20)
    println(p.xname)
    println(p.xage)
    p.xage = 40
    println(p.xage)

  }

}

简单语法

  1. if 语句与java没有区别

  2. for循环

    for(i <- 1 to 10){println(i)}

    1. 1 to 10 :左闭右闭

    2. 1 until 10 ：左闭右开

    3. 九九乘法表

      package scala.basic

object basic {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + i * j + "\t")
          //print(s"$i * $j = " + i*j)
      }
      println()
    }
  }
}
//方法二
for (i <- 1 to 9;j <- 1 to i) {
      print(j + "*" + i + "=" + i * j + "\t")
      if(i==j) println()
    }

  3. while与do…while

    与java相同

方法与函数

方法的定义

  1. 语法：

    def max//名称(x:Int,y:Int//参数):Int//返回值 = {
//方法体
}

package scala.basic

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

    /**
      * 方法定义
      *  1. 方法体的返回值可以省略，没有return时可省略，默认将方法体中最后一行作为返回结果
      *  2. 方法体最后可以使用return，如果使用了return，那么方法体的返回类型一定要指定
      *  3. 定义的方法传入的参数一定要指定类型
      *  4. 方法的方法体如果可以一行写完那方法体的括号可以省略
      *  5. 如果定义方法省略了方法名称和方法体间的“=”，那么无论方法体最后一行计算的结果都会被丢弃，返回Unit
      *
      * @param a
      * @param b
      * @return
      */
    def max(a: Int, b: Int): Int = {
      if (a > b) {
        a
      } else {
        b
      }
      //方法二
      //if(a > b) a else b
    }

    println(max(100,2))
  }
}

其余函数

package scala.basic

import java.util.Date

object 方法2 {
  def main(args: Array[String]): Unit = {

    /**
      * 递归方法要显式的显示返回类型
      * @param num
      * @return
      */
    def fun(num:Int): Int ={
      if(num == 1){
        1
      }else{
        num*fun(num-1)
      }
    }

    println(fun(5))

    /**
      * 参数有默认值的方法
      */
    def fun1(a:Int=10,b:Int=20): Int ={
      a+b
    }


    /**
      * 可变长参数的方法
      * 多个参数只能传同种类型的
      */
    def fun2(s:String*): Unit ={
      s.foreach(println)
    }
    fun2("a","b","c")

    /**
      * 匿名函数
      * (a:Int,b:Int) => {a+b}
      */
    val function: (Int, Int) => Int = (a:Int,b:Int) => {a+b}
    println(function(10, 20))


    /**
      * 嵌套方法
      */
      def fun3(num:Int): Int ={
        def fun4(a:Int):Int={
          if(a == 1){
            1
          }else{
            a*fun(a-1)
          }
        }
        fun4(num)
      }

      println(fun3(5))

    /**
      * 偏应用函数
      * 某些情况下，方法中参数非常多，每次调用只有固定的某个参数变化其他的都不变，可以定义偏应用函数
      */
      def showlog(date:Date,log:String): Unit ={
        println("date is " + date + "log is " + log)
      }
      val date = new Date()
      showlog(date,"a")
      showlog(date,"b")
      showlog(date,"c")

      def fun6 = showlog(date,_:String)
      fun6("aaa")

    /**
      * 高级函数
      * 1. 方法的参数是函数
      * 2. 方法的返回是函数
      * 3. 方法的参数和返回都是函数
      */

    //参数是函数
      def fun7(f:(Int,Int)=>Int,s:String): Int ={
        val i: Int = f(100,200)
        i
      }

      def f(a:Int,b:Int) ={
        a+b
      }

      println(fun7(f, "aa"))
    println(fun7((a: Int, b: Int) => {
      a * b
    }, "aaaa"))

    //返回值是函数
    def fun8(s:String):(String,String)=>String = {
      def fun9(s1:String,s2:String):String={
        s1+"\t"+s2+"\t"+s
      }
      fun9
    }

    println(fun8("aaa")("a","b"))


    /**
      * 柯里化函数
      */
    def fun10(a:Int,b:Int)(c:Int,d:Int): Int ={
      a+b+c+d
    }

    println(fun10(1, 2)(3, 4))
  }
}

字符串和集合

字符串

  1. 与java相似

集合

Array
package scala.basic

import scala.collection.mutable.ArrayBuffer

object Array_demo {
  def main(args: Array[String]): Unit = {
    //默认不可变
    //创建
    val array: Array[String] = Array[String]("a","b","c")

    val array2 = new Array[Int](5)//()中参数为Array长度，存在默认初始值
    array2.foreach(println)
    println("*******************")
    //赋值
    array2(0) = 10
    array2(3) = 20
    array2.foreach(println)
    println("*******************")
    //二维数组
    val array3 = new Array[Array[Int]](3)
    array3(0) = Array[Int](1,2,3)
    array3(1) = Array[Int](1,2,3)
    array3(2) = Array[Int](1,2,3)
    for (i <- array3){
      for (j <- i){
        println(j)
      }
    }
    //遍历
    println("*******************")
    array.foreach(println)
    for(i <- array){
      println(i)
    }

    //方法
    //两个数组合并
    val concat = Array.concat(array,array)
    //初始化一个长度为5值为hello的数组
    val fill = Array.fill(5)("HEllo")


    //可变数组
    val ab = new ArrayBuffer[Int](3)
    ab.+=(10)
    ab.+=:(100)
    ab.foreach(println)
  }
}
List
package scala.basic

import scala.collection.mutable.ListBuffer

object List_Deom {
  def main(args: Array[String]): Unit = {
    //创建
    val ints: List[Int] = List(1,2,3)

    //遍历
    ints.foreach(println)
    for (i <- ints){
      println(i)
    }

    //过滤
    val intsfilter = ints.filter(s => {
      s == 1
    })
    intsfilter.foreach(println)

    //返回符合条件的数据条数
    val i = ints.count(_ >= 2)
    println(i)

    //可变list
    val buffer = ListBuffer[Int](1,2,3)
    buffer.foreach(println)
    //追加元素
    buffer.append(4,5,6)

  }
}
Set
package scala.basic

object Set_Deom {
  def main(args: Array[String]): Unit = {
    //创建
    val set1 = Set[Int](1,2,2,3,4,5,5,6)
    //遍历
    set1.foreach(println)

    //方法
    //交集
    val set2 = Set[Int](2,3)
    val result = set1.intersect(set2)
    println(result)
    //差集
    val result2 = set1.diff(set2)
    println(result2)
    //操作符操作
    //交集
    val result3 = set1 & set2
    println(result3)
    //差集
    val result4 = set1 &~ set2
    println(result4)
    //filter
    val set3 = set1.filter(_ > 2)
    set3.foreach(println)

    //可变set
    import scala.collection.mutable.Set
    val set5 = Set[Int](1,2,3)
    set5.+=(100)


  }
}
Map
package scala.basic

object Map_Deom {
  def main(args: Array[String]): Unit = {
    //创建
    val map = Map[Int,Int](1 -> 10,2 -> 20,(3,30),(3,40))
    //相同的Key后面的会覆盖前面的
    //遍历
    for (i <- map){
      println(i)
    }

    map.foreach(println)

    //按键取值
    val maybeInt: Int = map.get(1).get
    println(maybeInt)
    //当KEY的值可能不存在时
    val result = map.get(1).getOrElse("null")
    println(result)

    //获取所有的KEY
    val keys = map.keys
    keys.foreach(key=>{
      println(map.get(key).get)
    })

    //遍历所有的VALUE值
    val values = map.values
    values.foreach(println)

    //map合并,合并时后面的KEY的值覆盖前面的
    val map1 = Map[String,Int](("a",1),("b",2),("c",3))
    val map2 = Map[String,Int](("a",4),("e",5),("d",6))
    val inmap = map1.++(map2)
    inmap.foreach(println)

    //可变MAP
    import scala.collection.mutable.Map
    val map3 = Map[Int,Int]((1,1))
    map3.put(2,3)
    //filter
    val filmap = map3.filter(x => {
      x._1 == 1
    })
    filmap.foreach(println)
  }

}
Tuple
package scala.basic

object Tuple_demo {
  def main(args: Array[String]): Unit = {
    //创建
    val tuple1 = new Tuple1("hello")
    val tuple2: (Int, Int) = new Tuple2(1,20)
    val tuple3 = Tuple3(1,2,3)
    val tuple4 = (1,2,3,4)
    //Tuple最多22个元素
    //元组使用 ._x 取值 x 表示第几个元素，下标从1开始
    //遍历
    val iterator = tuple4.productIterator
    iterator.foreach(println)
    
    //Tuple2 有 swap反转方法
  }
}

Traitl

package scala.basic

trait Read {
  def read(name:String): Unit = {
    println(name)
  }
}

trait Listen {
  def listen(name:String): Unit = {
    println(name)
  }
}

/**
  * trait可以有方法的实现也可以有方法的不实现
  */
trait equal{
  def isequal(o:Any):Boolean
  def isnoeq(o:Any):Boolean = !isequal()
}

class Point(x:Int,y:Int) extends equal {
  val xx = x
  val yy = y

  override def isequal(o: Any): Boolean = {
    o.isInstanceOf[Point]&&o.asInstanceOf[Point].xx == this.xx
  }
}

//继承多个trait 第一个用 extends 后面的使用 with
class Person1() extends Read with Listen {

}

object Traitl_Demo {
  def main(args: Array[String]): Unit = {
    val person = new Person1()
    person.read("zhangsan")
    person.listen("lisi")
  }
}

模式匹配|偏函数

package scala.basic

object model_demo {
  def main(args: Array[String]): Unit = {
    val tuple = (1,1.1,"abc",true,"a")
    val iterator = tuple.productIterator
    iterator.foreach(MatchTest(_))
    //模式匹配可以匹配值还可以匹配类型
    //匹配过程中存在数值的转换
    //从上往下匹配，匹配上后会自动停止
    def MatchTest(o:Any)={
      o match {
        case 1 => println("num is " + 1)
        case i:Int => println("num "+i)
        case s:String => println("String:"+ s )
        case _ => println("no") // 默认匹配什么都匹配不上，放在最后
      }
    }

    //偏函数
    //[匹配值类型，返回值类型]
    def myTest:PartialFunction[String,Int]={
      case "abc" => 2
      case "a" => 200
      case _ => 404
    }
    val i = myTest("a")
    println(i)
  }
}

样例类

package scala.basic

//使用case关键字修饰的类就是样例类
case class p(name:String,age:Int){
  //参数默认有getter和setter方法
  //实现了toString，equals，copy和hashCode方法
}

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

    val p1 = new p("zhangsan",10)
    val p2 = new p("zhangsan",10)
    println(p1.equals(p2))
    
  }
}

字符串操作

  1. charAt(int index)：返回指定位置的字符
  2. concat(String str)：将指定字符串连接到此字符串的结尾

日期

val nowdate = LocalDate.now()
    println("LocalDate.now()-->现在的时间是"+LocalDate.now())
    println("nowdate.plusDays-->明天是-->"+nowdate.plusDays(1))
    println("nowdate.minusDays-->昨天是-->"+nowdate.minusDays(1))
    println("nowdate.plusMonths-->今天加一个月-->"+nowdate.plusMonths(1))
    println("nowdate.minusMonths-->今天减一个月-->"+nowdate.minusMonths(1))
    println("nowdate.getDayOfYear-->今天是今年的第"+nowdate.getDayOfYear+"天")
    println("nowdate.getDayOfMonth->这个月有"+nowdate.getDayOfMonth+"天")
    println("nowdate.getDayOfWeek-->今天星期"+nowdate.getDayOfWeek)
    println("nowdate.getMonth-->这个月是"+nowdate.getMonth)

object Test_Time001 {
  def main(args: Array[String]): Unit = {
//    获取今天日期
    def getNowDate():String={
      var now:Date = new Date()
      var  dateFormat = FastDateFormat.getInstance("yyyy-MM-dd")
      var today = dateFormat.format( now )
      today
    }
 
//    获取昨天的时间
    def getYesterday():String= {
      var dateFormat = FastDateFormat.getInstance("yyyy-MM-dd")
      var cal = Calendar.getInstance()
      cal.add(Calendar.DATE, -1)
      var yesterday = dateFormat.format(cal.getTime())
      yesterday
    }
 
//    获取本周开始日期
    def getNowWeekStart():String={
      var day:String=""
      var cal:Calendar =Calendar.getInstance();
      var df =  FastDateFormat.getInstance("yyyy-MM-dd");
      cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
      //获取本周一的日期
      day=df.format(cal.getTime())
      day
    }
 
//    获取本周末日期
    def getNowWeekEnd():String={
      var day:String=""
      var cal:Calendar =Calendar.getInstance();
      var df = FastDateFormat.getInstance("yyyy-MM-dd");
      cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);//这种输出的是上个星期周日的日期，因为老外把周日当成第一天
      cal.add(Calendar.WEEK_OF_YEAR, 1)// 增加一个星期，才是我们中国人的本周日的日期
      day=df.format(cal.getTime())
      day
    }
 
//    本月的第一天
    def getNowMonthStart():String= {
      var day: String = ""
      var cal: Calendar = Calendar.getInstance();
      var df = FastDateFormat.getInstance("yyyy-MM-dd");
      cal.set(Calendar.DATE, 1)
      day = df.format(cal.getTime()) //本月第一天
      day
    }
 
//    本月最后一天
    def getNowMonthEnd():String={
      var day:String=""
      var cal:Calendar =Calendar.getInstance();
      var df = FastDateFormat.getInstance("yyyy-MM-dd");
      cal.set(Calendar.DATE, 1)
      cal.roll(Calendar.DATE,-1)
      day=df.format(cal.getTime())//本月最后一天
      day
    }
 
//    将时间戳转化成日期/时间
    def DateFormat(time:String):String={
      var sdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")
      var date:String = sdf.format(new Date((time.toLong)))
      date
    }
 
//    计算时间差
    def getCoreTime(start_time:String,end_Time:String)={
      var df = FastDateFormat.getInstance("HH:mm:ss")
      val begin = start_time
      val end = end_Time
      var between = (end.toLong - begin.toLong)/1000  //转化成秒
      var minute = between % 60 //转化为分钟
      val hour = between % (60*60) //转化为小时

}
_知多少_
关注
Scala基础知识总结
栖溪阁晓生的博客
05-26 1850
scala是运行在JVM上的多范式编程语言，同时支持面向对象和面向函数编程。早期，scala刚出现的时候，并没有怎么引起重视，随着Spark和Kafka这样基于scala的大数据框架的兴起，scala逐步进入大数据开发者的眼帘。scala的主要优势是它的表达性。 Scala语言主要用于开发大数据应用程序，如：Spark程序、Flink程序；它具有表达能力强，一行代码抵得上多行java代码，开发速度快；它也兼容Java，可以访问庞大的Java类库，例如：操作mysql、redis、freemarker、act
Scala知识点总结
qq_46078139的博客
01-18 517
Scala 是一门类 Java 的编程语言，它结合了面向对象编程和函数式编程。
印度朋友手把手教你学Scala（4）：对象
weixin_33744141的博客
03-21 157
2019独角兽企业重金招聘Python工程师标准>>> ...
Scala 知识点总结大全
yang灬仔
07-16 1415
一、变量、数据类型、运算符 1.1语法声明 变量的类型在变量名之后等号之前声明。 var | val 变量名 ：变量类型 = 变量值 变量的类型如果能够通过变量值推断出来，那么可以省略类型声明 1.2 变量初始化 Scala语法中，必须显示进行初始化操作。 1.3 可变变量& 不可变变量 值可以改变的变量，称之为可变变量，但是变量类型无法发生改变, Scala中可变变量使用关键字var进行声明 ​ 值一旦初始化后无法改变的变量，称之为不可变变量。Scala中不可变变量使用关键字va
Scala基础知识大全
Markble
08-21 3793
二、变量和数据类型 2.1 注释 Scala注释使用和Java完全一样。 注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。 1）基本语法 （1）单行注释：// （2）多行注释：/* */ （3）文档注释： /** * */ 2）代码规范 （1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移 （2）或者使用ctrl + alt + L来进行格式化 （3）运算符两边习惯性各加一个空格。比如：2 ...
scala的基础知识点
2401_87076427的博客
09-08 1676
6.5.1 抽象属性和抽象方法1）基本语法​ （1）定义抽象类：abstract class Person{} //通过abstract关键字标记抽象类​ （2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性​ （3）定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法val name: String //抽象属性def hello(): Unit //抽象方法2）继承&重写。
Spark基础之Scala知识总结
Jason_YBK的博客
09-24 1144
史上最全的Scala知识点整理第一章 变量及基本数据类型1.1 注释1.2 标识符命名规范1.3 变量1.4 字符串1.5 数据读取1.6 数据类型1.6.1 概述1.6.2 类型转换1.7 运算符第二章 流程控制2.1 块表达式2.2 If判断2.3 For循环2.3.1 Scala中方法调用的两种方式2.3.2 基本语法2.3.3 循环返回值2.4 While循环2.5 Switch2.6 中断循环第三章 面向函数编程3.1 概念3.2 函数的定义3.2.1 基本语法3.2.2 方法与函数3.2.3 参
Scala常用知识点总结
qm5132的博客
10-05 790
前述：Scala文件会被编译为Java的class字节码文件，而且最终运行在JVM之上，所以有些操作会受限于JVM。 使用注意点： 1、List(1, 2, 3, "44") 语句正确执行，但返回得到是List[Any]，即根据Int和String，将类型转为了Any。所以，List仍需要全部原始的类型一致。 2、scala语法级别的惰性执行lazy，只能对val起作用：一旦val常...
大数据—— Scala 知识点整理
Vicky_Tang
09-13 894
1. Scala 语言的优点 Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性 Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序 Scala 源代码被变编译成 Java 字节码，所以它可以运行于 JVM之上，并可以调用现有的 Java 类库 作为流行的开源大数据内存计算引擎 Spark 的源码编程语言，Spark 有着良好的性能优势 Scala 将成为未来大数据处理的主流语言 2. Scala 中的闭包 .
Scala语言知识点
gaozhen666的博客
08-06 508
Scala语言知识点 1. Scala基础 1.1 标识符 Scala语言中的类名，方法名等标识符规则与Java一致，有如下关键字： 1.2 数据类型 Scala是一门完全面向对象的语言，因此Scala的数据类型都是对象，也就是说Scala中是没有基本数据类型的，具体见下图 特别注意： None是Option的两个子类之一，另一个是Some，用于安全的函数返回值，Scala推荐在可能返回空的方法是用Option[X]作为返回类型，如果有值就返回Some[X]，否则返回None def get(ke
scala编程基础
07-27
### Scala编程基础知识点详解 #### 一、课程目标与概述 **课程目标**： 1. **初级目标**：能够熟练地使用Scala编写Spark程序。这包括掌握Scala的基础语法以及如何结合Spark进行数据处理。 2. **中级目标**：能够...
Scala考试题1
08-08
下面将详细解释题目中涉及的Scala知识点： 1. **var、val 和 def 的区别**： - `var` 定义可变变量，可以多次赋值。 - `val` 定义不可变变量，一旦赋值后不能更改。 - `def` 用于定义函数，它不创建任何实例，只...
Scala基础教程
01-07
### Scala基础教程中的Spark知识点详解 #### 一、Spark概述 **Spark** 是一个高性能的分布式计算框架，它被设计用于大规模数据处理场景，并且以其高效性和灵活性著称。相较于传统的 **MapReduce** 计算模型，Spark...
Scala基础知识01
Cc_DaGe的博客
11-20 240
Scala基础 语法规范、运算符、数据类型、字符串
flink增量检查点启动恢复的时间是很久的，业务上不能接受，怎么处理
最新发布
goTsHgo的博客
09-11 629
针对增量检查点恢复时间长的问题，可以从多个方面进行优化，包括合并检查点、提升存储性能、优化 RocksDB 配置、并行化恢复过程等。同时，也可以考虑替代方案，如多活架构、预热恢复、降低状态依赖和改进状态管理策略。此外，在业务层面上，适当调整业务容忍度和提高用户透明度也是有效的应对措施。通过综合应用这些策略，可以有效地降低恢复时间并提高业务的连续性和可靠性。
HBase
赞的心路历程
09-09 517
安装包：链接:提取码: 5up7。
衡石分析平台使用手册-新手上路介绍
zandy1011的博客
09-06 1190
​以下概括阐述了产品基本理念，这些理念贯穿我们的整个产品开发和设计，并最终体现为产品的功能形态。我们希望衡石分析平台可以成为各个领域的行业人员进行业务分析的称手兵器，简单稳定，容易上手。
如何确定kafka与zookeeper版本的对应关系
别来沾边儿
09-09 635
真希望官方可以贴心的整理出所有版本和zookeeper的对应关系，从目前kafka发展的趋势来看，都已经移除zookeeper依赖了，这件事也是木戏，哈哈哈；从解压目录我们可以kafka的源码是基于gradle的，我们只需要去gradle的依赖中找找zookeeper依赖的版本即可；搜索zookeeper关键字，可以看到Kafka2.7.2对应的Zookeeper版本为3.5.9。大家可以额外思考一下，如果用更高版本的zookeeper，kafka运行会不会有问题？这嘎嘎一列版本对应关系，哪来的呢？
大数据Flink（一百一十四）：PyFlink的作业开发入门案例
Lansonli（蓝深李）的博客
09-07 1035
编写Flink程序，读取表中的数据，并根据表中的字段信息进行统计每个单词出现的数量。编写Flink程序，接收socket的单词数据，并以逗号进行单词拆分打印。注意：socketTextStream后的ip是云服务器ecs的公网ip。注意read_text_file后的地址要与实际地址对应。安装nc: yum install -y nc）（如果没有安装可以使用yum。开启netcat，监听。在ecs依次发送单词。
Scala泛型基础与实战
除了泛型，资料中还提到了Scala语言的其他基础知识点，如开发环境的搭建，包括Windows和Linux下的配置，以及IDEA的使用和Scala插件的安装。此外，还介绍了Scala的变量、注释、程序流程分析等内容，这些都是学习Scala...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值