Scala系列——Scala入门篇

最新推荐文章于 2023-03-19 17:50:32 发布
最新推荐文章于 2023-03-19 17:50:32 发布
阅读量496 收藏 2
点赞数 1
分类专栏： Scala系列 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22172133/article/details/81566520
版权

一、基本语法

1、声明变量

object VariableDemo {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    var s = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    //Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
    val str: String = "hello scala"
  }
}

 

2、条件表达式

        Scala的的条件表达式比较简洁，例如：

object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

    //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)

    //if和else if
    val k = if (x>90) "优秀" else if (x<90 && x>60) "及格" else "不及格"
    println(k)
  }
}

3、块表达式

object BlockExpressionDemo {
  def main(args: Array[String]) {
    val x = 0
    //在scala中{}中课包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
      if (x < 0){
        -1
      } else if(x >= 1) {
        1
      } else {
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result)
  }
}

4、循环

        在scala中有for循环和while循环，用for循环比较多，for循环语法结构：for (i <- 表达式/数组/集合)

object ForDemo {
  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      println(i)

    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()

    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)

  }

}

5、运算符

        Scala中的+ - * / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有一点特别的：这些操作符实际上是方法。例如：

a + b

是如下方法调用的简写：

a.+(b)

a 方法 b可以写成 a.方法(b)

二、定义方法和函数

1、定义方法

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

2、定义函数

3、方法和函数的区别

        在函数式编程语言中，它可以像任何其他数据类型一样被传递和操作，函数就是一个实例，这是和方法的区别。案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面。

 

object MethodAndFunctionDemo {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int) : Int = {
    f(2, 6)
  }

  //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n
  //再定义一个函数f3,这个这里没用
  val f3:(Int,Double) =>(Double,Int)={
      (a,b)=>(b,a)
  }

  //main方法
  def main(args: Array[String]) {

    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println(r1)

    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

4、将方法转换成函数

三、数组、映射、元组、集合

1、数组

1.定长数组和变长数组

object ArrayDemo {
  def main(args: Array[String]) {

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

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

    //定义一个长度为3的定长数组
    val arr3 = Array("It", "is", "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)//在0的位置依次插入-1，0
    //删除数组某个位置的元素用remove
    ab.remove(8, 2)//在8的位置向后删除两个
    println(ab)
  }
}

 

2.遍历数组

object ForArrayDemo {

  def main(args: Array[String]) {
    //初始化一个数组
    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))
  }
}

 

3.数组转换

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

object ArrayYieldDemo {
  def main(args: Array[String]) {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)

    //更高级的写法
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)

  }
}

说明：map和flatMap的区别，flatMap会先map然后再将数据压平。

我们下面以统计单词个数为例：

或者：

4.数组常用算法

        在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

2、映射

        在Scala中，把哈希表这种数据结构叫做映射

1.构建映射

2.获取和修改映射中的值

我们也可以使用getOrElse来给其赋初始值，下面suke的值即为0了

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

注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型

3、元组

        映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

1.创建元组

2.获取元组中的值

3.将对偶的集合转换成映射

4.拉链操作

zip命令可以将多个值绑定在一起

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

4、集合

        在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）。Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质

1.序列

        不可变的序列 import scala.collection.immutable._ 。在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2)    :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

object ImmutListDemo {

  def main(args: Array[String]) {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    val lst3 = lst1.::(0)
    val lst4 = 0 +: lst1
    val lst5 = lst1.+:(0)

    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3

    val lst0 = List(4,5,6)
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst1插入到lst0前面生成一个新的集合
    val lst8 = lst1 ++: lst0

    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)

    println(lst9)
  }
}

        可变的序列 import scala.collection.mutable._

object MutListDemo extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)

  //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合，即lst0和lst1不变，++生成新的；+合并
  val lst2= lst0 ++ lst1

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5
}

 

2.Set

不可变的Set

import scala.collection.immutable.HashSet
object MutListDemo extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)

  //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合，即lst0和lst1不变，++生成新的；+合并
  val lst2= lst0 ++ lst1

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5
}

 

可变的Set

import scala.collection.mutable
object MutSetDemo extends App{
  //创建一个可变的HashSet
  val set1 = new mutable.HashSet[Int]()
  //向HashSet中添加元素
  set1 += 2
  //add等价于+=
  set1.add(4)
  set1 ++= Set(1,3,5)
  println(set1)
  //删除一个元素
  set1 -= 5
  set1.remove(2)
  println(set1)
}

3.Map

import scala.collection.mutable
object MutMapDemo extends App{
  val map1 = new mutable.HashMap[String, Int]()
  //向map中添加数据
  map1("spark") = 1
  map1 += (("hadoop", 2))
  map1.put("storm", 3)
  println(map1)

  //从map中移除元素
  map1 -= "spark"
  map1.remove("hadoop")
  println(map1)
}

 

四、类、对象、继承、特质

1、类

1.类的定义

//在Scala中，类并不用声明为public。
//Scala源文件中可以包含多个类，所有这些类都具有公有可见性。
class Person {
  //用val修饰的变量是只读属性，有getter但没有setter
  //（相当与Java中用final修饰的变量）
  val id = "9527"

  //用var修饰的变量既有getter又有setter
  var age: Int = 18

  //类私有字段,只能在类的内部和伴生对象使用
  private var name: String = "唐伯虎"

  //对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段
  private[this] val pet = "迪迦"
}
//这就是伴生对象
object Person{
    def main(args: Array[String]) {
        var person=new Person
        person.name="涂山雅雅"
  }
        
}

2.构造器

注意：主构造器会执行类定义中的所有语句

/**
  *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
  */
class Student(val name: String, val age: Int){
  //主构造器会执行类定义中的所有语句
  println("执行主构造器")

  try {
    println("读取文件")
    Source.fromFile("D:/opt/AFIN/data.text").mkString
    throw new IOException("io exception")
  } catch {
    case e: NullPointerException => println("打印异常Exception : " + e)
    case e: IOException => println("打印异常Exception : " + e)
  } finally {
    println("执行finally部分")
  }

  private var gender = "male"

  //用this关键字定义辅助构造器
  def this(name: String, age: Int, gender: String){
    //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
    this(name, age)//这里就是调用主构造器
    println("执行辅助构造器")
    this.gender = gender
  }
}
object Student{
  def main(args: Array[String]): Unit = {
    var student1=new Student("张三",27)//这里只执行主构造函数
    var student2=new Student("张三",27,"ss")//这里即执行主构造函数，又执行辅构造函数
  }
}

私有构造器

/**
  *构造器参数可以不带val或var，如果不带val或var的参数至少被一个方法所使用，
  *那么它将会被提升为字段
  */
//在类名后面加private就变成了私有的
class Queen private(val name: String, prop: Array[String], private var age: Int = 18){
  
  println(prop.size)

  //prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop
  //如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数
  def description = name + " is " + age + " years old with " + prop.toBuffer
}

object Queen{
  def main(args: Array[String]) {
    //私有的构造器，只有在其伴生对象中使用
    val q = new Queen("hat", Array("蜡烛", "飞娥"), 20)
    println(q.description())
  }
}

2、对象

1.单例对象

        在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

  • 存放工具方法和常量
  • 高效共享单个不可变的实例
  • 单例模式
object SingletonDemo {
  def main(args: Array[String]) {
    //单例对象，不需要new，用【类名.方法】调用对象中的方法
    val session = SessionFactory.getSession()
    println(session)
  }
}

object SessionFactory{
  //该部分相当于java中的静态块
  var counts = 5
  val sessions = new ArrayBuffer[Session]()
  while(counts > 0){
    sessions += new Session
    counts -= 1
  }

  //在object中的方法相当于java中的静态方法
  def getSession(): Session ={
    sessions.remove(0)
  }
}

class Session{

}

2.伴生对象

        在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性

class Dog {
  val id = 1
  private var name = "小狗"

  def printName(): Unit ={
    //在Dog类中可以访问伴生对象Dog的私有属性
    println(Dog.CONSTANT + name )
  }
}

/**
  * 伴生对象
  */
object Dog {

  //伴生对象中的私有属性
  private val CONSTANT = "汪汪汪 : "

  def main(args: Array[String]) {
    val p = new Dog
    //访问私有的字段name
    p.name = "123"
    p.printName()
  }
}

3.应用程序对象

        Scala程序都必须从一个对象的main方法开始，可以通过扩展App特质，不写main方法。

object AppObjectDemo extends App{
  //不用写main方法
  println("I love you Scala")
}

3、继承

1.扩展类

        在Scala中扩展类的方式和Java一样都是使用extends关键字

2.重写方法

        在Scala中重写一个非抽象的方法必须使用override修饰符

3.类型检查和转换

Scala

Java

obj.isInstanceOf[C]

obj instanceof C

obj.asInstanceOf[C]

(C)obj

classOf[C]

C.class

4.超类的构造

object ClazzDemo {
  def main(args: Array[String]) {
    //val h = new Human
    //println(h.fight)
  }
}
//trait : 等同于java中的interface，且比java的接口要更强大。相当于java8的接口
trait Flyable{
  def fly(): Unit ={
    println("I can fly")
  }

  def fight(): String
}

abstract class Animal {
  def run(): Int
  val name: String
}

class Human extends Animal with Flyable{

  val name = "abc"

  //打印几次"ABC"?
  val t1,t2,(a, b, c) = {
    println("ABC")
    (1,2,3)
  }

  println(a)
  println(t1._1)

  //在Scala中重写一个非抽象方法必须用override修饰
  override def fight(): String = {
    "棒子 老虎 鸡"
  }
  //在子类中重写超类的抽象方法时，不需要使用override关键字，写了也可以
  def run(): Int = {
    1
  }
}

五、模式匹配和样例类

        Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配。

1、匹配字符串

object CaseDemo01 extends App{
  val arr = Array("飞天", "遁地", "下海")
  val name = arr(Random.nextInt(arr.length))
  name match {
    case "飞天" => println("飞天...")
    case "遁地" => println("遁地...")
    case _ => println("真不知道你们在说什么...")
  }
}

2、匹配类型

object CaseDemo01 extends App{
  //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
  val arr = Array("hello", 1, 2.0, CaseDemo)
  val v = arr(Random.nextInt(4))
  println(v)
  v match {
    case x: Int => println("Int " + x)
    case y: Double if(y >= 0) => println("Double "+ y)
    case z: String => println("String " + z)
    case _ => throw new Exception("not match exception")
  }
}

注意：case y: Double if(y >= 0) => ... ，模式匹配的时候还可以添加守卫条件。如不符合守卫条件，将掉入case _中

3、匹配数组、元组

object CaseDemo03 extends App{

  val arr = Array(1, 3, 5)
  arr match {
    case Array(1, x, y) => println(x + " " + y)
    case Array(0) => println("only 0")
    case Array(0, _*) => println("0 ...")
    case _ => println("something else")
  }

  val lst = List(3, -1)
  lst match {
    case 0 :: Nil => println("only 0")
    case x :: y :: Nil => println(s"x: $x y: $y")//和el表达式一样，前面加s，取值用$
    case 0 :: tail => println("0 ...")
    case _ => println("something else")
  }

  val tup = (2, 3, 7)
  tup match {
    case (1, x, y) => println(s"1, $x , $y")
    case (_, z, 5) => println(z)
    case _ => println("else")
  }
}

注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表。:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

4、样例类

        在Scala中样例类是一中特殊的类，可用于模式匹配。case class是多例的，后面要跟构造参数，case object是单例的

case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask

object CaseDemo04 extends App{
  val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001"))

  arr(Random.nextInt(arr.length)) match {
    case SubmitTask(id, name) => {
      println(s"$id, $name")//前面需要加上s, $id直接取id的值
    }
    case HeartBeat(time) => {
      println(time)
    }
    case CheckTimeOutTask => {
      println("check")
    }
  }
}

5、Option类型

        在Scala中Option类型样例类用来表示可能存在或也可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值

object OptionDemo {
  def main(args: Array[String]) {
    val map = Map("a" -> 1, "b" -> 2)
    val v = map.get("b") match {
      case Some(i) => i
      case None => 0
    }
    println(v)
    //更好的方式
    val v1 = map.getOrElse("c", 0)
    println(v1)
  }
}

6、偏函数

        被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配

object PartialFuncDemo {

  def func1: PartialFunction[String, Int] = {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def func2(num: String) : Int = num match {
    case "one" => 1
    case "two" => 2
    case _ => -1
  }

  def main(args: Array[String]) {
    println(func1("one"))
    println(func2("one"))
  }
}
 

 

盡盡
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Scala—— 3.函数
01-07
在Scala中，方法和函数几乎可以等同(比如它们的定义、使用、运行机制都是一样的)，只是函数的使用方式更加的灵活多样。函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当作一等公民，...
Scala之数组
这是要成为全栈的节奏么
11-16 162
Scala数组数组是最常用的收集一系类元素的结构，其中定长数组我们使用Array，变长数组我们使用ArrayBuffer1.创建定长数组         定长数组的声明： val a =new Array[Int](10)     数组在声明的时候若对数组不给定值，    我们也可以在声明的时候给定值（值的类型要相同），Scala可以自动的进行类型和长度的判断。    例如：   ...
Scala中的数组
CatherineHuangTT的博客
11-09 426
1.定长数组和变长数组 import scala.collection.mutable.ArrayBuffer object ArrayTest { def main(args: Array[String]) { //初始化一个长度为8的定长数组，其所有元素均为0 val arr1 = new Array[Int](8) //直接打印定长数组，内容为数组的ha
Scala入门3之【条件表达式、循环】
weixin_45666566的博客
12-26 404
条件表达式、循环1、条件表达式1.1 if 语句1.2 if...else 语句1.3 if...else if...else 语句1.4 if...else 嵌套语句 1、条件表达式 \quad \quad条件表达式就是if表达式，if表达式可以根据给定的条件是否满足，根据条件的结果（真或假）决定执行相应的操作 1.1 if 语句 \quad \quadif 语句有布尔表达式及之后的语句块组成。 语法： if(布尔表达式) { // 如果布尔表达式为 true 则执行该语句块 } 例子： scal
scala语法 基础3
mllhxn的专栏
12-23 384
/** * 高阶函数 */object Study7 extends App{//函数定义 def add(a:Int ,b:Int) = { a + b } // var c = add(1,2) // println(c) //var func1 = add _ //把一个函数的实现传递给另外一个函数 //println(func1(
Scala基础语法入门（五）Scala循环控制第一篇
春和的博客
05-08 1185
Scala中的For循环1、范围数据循环（to）2、范围for循环 （range）3、范围for循环 （until）4、循环步长5、循环守卫6、循环嵌套7、引入变量8、循环返回值9、for循环练 一层循环打印出九层妖塔
Scala入门基础
Anchor
08-30 2630
Scala是一门多范式的编程语言。是一种纯面向对象的语言，每个值都是对象。同时也是一种函数式语言，其函数也能当成值来使用。由于Scala整合了面向对象和函数式编程的特性，因此Scala相对于Java、C#、C++等其它语言更简洁。本文章将通过简单的案例教会大家如何简单的使用Scala编程，大家也可以模仿案例动手实践有助于自己入门学习 Scala也是运行在JVM上的语言，所以必须确认环境中安装了Java Windows安装直接在官网下载后，在本地高级系统设置中添加bin目录地址环境即可............
Scala语言基础
黄连福的博客
05-27 708
1.Scala基础知识 1.1 基本数据类型和变量   基本数据类型包括Byte、Short、Int、Long、Char、Float、Double、String、Boolean。   Scala变量 从变量声明角度看，只有两种类型，val和var，对于val声明的变量，在声明时就必须初始化，并且不可变。对于var声明的变量，是可变的。声明变量的语法如下： val 变量名[:数据类型] = 初始值 var 变量名[:数据类型] = 初始值   Scala提供了一种类型推断机制（Type Inference
Scala—— 1.变量
01-07
Scala是一门以Java虚拟机（JVM）为运行环境并***将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言***。Scala源代码（.scala）会被编译成Java字节码（.class），然后运行在JVM上，并可以调用现有的Java...
Scala—— 2. 流程控制
01-20
1.表达式： A.条件表达式 val x = 3 val y = if(x > 1) 1 else -1 B....支持返回多种类型（前提是在不确定类型的情况下，val y:String或val y:Int这样都不行）。 val y = if(x > 1) 1 else hello ...
Scala—— 12.隐式转换
01-07
1.隐式转换函数 隐式转换函数是以implicit关键字声明的带有单个参数的函数，这种函数将会自动应用，将值从一种类型转换为另一种类型。 object boke_demo01 { def main(args: Array[String]): Unit = { ...
Scala编程语言从入门到精通
07-22
资源名称：Scala编程语言从入门到精通资源目录：【】DesignOfScala【】ExcitedScala_7(1)【】lift-lift_23_sbt-cf313e1【】ScalaTutorial-zh_CN【】Scala_2.7.6_API【】Scala向导(前13章)【】Scala向导（前15章）-p...
Scala基础01-数据类型与控制语句
小小鱼
12-17 180
Scala一、scala特点二、常量与变量三、数据类型四、scala字符串差值(拼接)五、程序控制 一、scala特点 1．静态类型:变量声明后不允许改变类型；变量和表达式的类型在编译时就已经完全确定 2．强类型:不经过强转，数据类型不会被改变，不允许隐式类型转换。方式为(对象名.asinstanceOf[XXX]，对象名.toXXX方法，隐式转换(implicit关键字)) 3．多范式编程: （1）面向对象:一切值都是对象；无static关键字使用伴生对象模拟类对象；无接口概念，用特质概念替代 （2）函数
Scala基础知识(个人总结)
hellosrc的博客
11-15 1491
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
scala入门
sun_0128的博客
07-18 429
文章目录一.Scala概述1.特性2.Scala变量与常量二.Scala流程控制语句1.if2.Scala循环控制三.Scala数组,元组,集合1.Scala数组2.Scala元组3.Scala集合4.Scala Stream & Vector 一.Scala概述 1.特性 面向对象特性 每个值都是对象 对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述 利用特征实现混入式多重继承 函数式编程 每个函数都是一个值 支持高阶函数、柯里化(currying)、
大数据开发语言Scala（一）——scala入门
热门推荐
five小点心的博客
03-19 1万+
package： 包，等同于java中的packageobject：关键字，声明一个单例对象（伴生对象）main方法：从外部可以直接调用执行的方法def 方法名称( 参数名称 : 参数类型 ) : 返回值类型 = { 方法体 }Scala 完全面向对象，故scala去掉了Java中非面向对象的元素，如static关键字，void类型1) staticscala无static关键字,由object实现类似静态方法的功能(类名.方法名)
大数据技术——Scala语言基础
qq_53142796的博客
03-02 572
for推导式: for结构可以在每次执行的时候创造一个值，然后将包含了所有产生值的集合作为for循环表达式的结果返回，集合的类型由生成器中的集合类型确定。·Scala提供了一套丰富的容器(collection）库，包括序列( Sequence）、集合(Set)、映射（Map）等。scala.collection封装了可变容器和不可变容器的超类或特质，定义了可变容器和不可变容器的一些通用操作。不同于Java的java.util.List，scala的List一旦被定义，其值就不能改变，
大数据-scala（六）
海恋北斗星
04-27 245
大数据-scala（六） 函数式编程 排序 - sort sorted默认排序 //定义一个List集合 scala> val list=List(5,1,2,4,3) list: List[Int] = List(5, 1, 2, 4, 3) //默认就是升序 scala> list.sorted res30...
Scala系列——Akka并发编程
随笔记
11-29 2881
一、Akka简介 1、基本介绍 Akka基于Actor模型，提供了一个用于构建可扩展的（Scalable）、弹性的（Resilient）、快速响应的（Responsive）应用程序的平台。 Actor模型：在计算机科学领域，Actor模型是一个并行计算（Concurrent Computation）模型，它把actor作为并行计算的基本元素来对待：为响应...
spark 读写hbase(scala)——2.批量操作
最新发布
06-28
```scala val conf = HBaseConfiguration.create() val connection = ConnectionFactory.createConnection(conf) val table = connection.getTable(TableName.valueOf("table_name")) val puts = new ListBuffer...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

盡盡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值