Scala（一）基础

OOP 面向对象编程 AOP 面向切面编程 FP 函数式编程 编程语言都要定义变量，一些代码是用来注释的，变量和变量之间有一些关系，要做一些运算，运算离不开流程控制，进行运算的数据往往来自数据结构，最基本的是数组。

所有编程语言的需要：

  • 变量
  • 注释
  • 运算符
  • 流程控制
  • 数组

编码规范：命名、换行、缩进、分号 变量

在java中定义变量，必须要使用数据类型来声明。Scala中不用，只需要使用两个关键字来声明即可，var、val。

scala> var a = 1
a: Int = 1

scala> var b ="1"
b: String = 1

scala> var c = 2.0
c: Double = 2.0

重要结论1：Scala在定义变量的时候，可以不用指定数据类型，当然也可以指定，如果不指定，编译器会自动推断。 不确定数据类型，不要指定数据类型，类型不匹配会报错

重要结论2：如果已经定义好的变量，就算定义时没有指定类型也一定已经确定了，这个使用var修饰的变量可以被改成相同类型的其他值，但是不能改成其他类型的值。

重要结论3：如果已经有一个变量 a:Int = 3，那么使用var a = "huangbo"这是可以执行的。var的作用就是告诉编译器，正在定义一个新的变量。

重要结论4：一个变量被val修饰，这个变量等同于java中的常量，就是使用final修饰的变量。

重要结论5：如果一个变量被lazy修饰，延迟初始化，在定义的时候没有初始化，在使用的时候才被初始化。

重要结论6：在scala中，推荐使用val，不推荐使用var 为了类型和数据安全 scala是纯面向对象，任何东西都是对象，方法、函数都是对象 在java中，int a = 1 a是一个基本类型，但有封箱操作 数据类型 Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型，再加上String类型。

Any是所有类的父类，Nothing是所有类的子类 值类型：Double、Float、Long、Int、Short、Byte、Unit、Boolean、Char

Unit是特殊的类型，有且只有一个实例对象，就是个小括号 Unti: ()，相当于Java中的void， 没有任何实质意义 因此，Scala中所有的方法都有返回值 Int:1 2 3....

上图各类型之间的虚线，从上到下可以进行转换，隐式转换，Scala编译器自动进行 引用类型：父类是AnyRef，等同于Java中的object

String是引用类型的一个特例

List Seq Iterable ScalaObject 所有Java类型都是AnyRef的子类

所有引用类型都有子类Null，即Null是所有引用类型的子类 Null也只有一个实例，是null，相当于Java中的null，能赋值给任何引用类型变量，不能赋值给值类型变量 基本类型操作

编码规范

1.不强制在代码末尾使用分号，但是如果有多句代码写在同一行，必须使用分号隔开

2.注释方式和Java一样

3.关键字 4.命名和Java一样

流程控制-if 分支控制

new没有scala class，Libraries添加

scala> var result = {2; 3}
<console>:11: warning: a pure expression does nothing in statement position; multiline expressions might require enclosing parentheses
       var result = {2; 3}
                     ^
result: Int = 3

scala> var x =1; var y =2
x: Int = 1
y: Int = 2

scala> var result = {if(x > y) println(x) else println(y); 4}
2
result: Int = 4
大括号是有返回值的，里面的代码块最后一句是返回值，赋值给了result
scala> var result = {if(x > y) println(x) else println(y); 4}
2
result: Int = 4

scala> var result = {if(x > y) println(x) else println(y)}
2
result: Unit = ()

scala> var result = {if(x > y) x else y}
result: Int = 2

在Scala中任何一句代码的执行都是有返回值的，下面代码返回的是Unit，这相当于Java里的无返回值

scala> var result = {if(x > y) println(x) else println(y)}

2

result: Unit = ()

代码的逻辑块： 函数 val sum = (x:Int , y:Int) => {x + y} 方法 def sum(x:Int, y:Int) = {x + y} 代码段/代码块{}

函数和方法都会变成代码块的执行结果，接收的都是最后一句的值

如果大括号只有一句代码，这一句代码的值就是{}的返回值

if(x > y) x else y 是有返回值的，因此可以进行赋值

var result = if(x > y) x else y

即var result = {if(x > y) x else y}

Scala中任何一句能正常执行的代码都有返回值

如果要返回的是一段代码的结果，那么请把这一段代码放置在{}中，那么{}中最后一句话的结果就是{}的返回值

scala> var a = 2
a: Int = 2

scala> var b = "h"
b: String = h

scala> var result = if(a > 0) a else b
result: Any = 2

返回的类型是父类Any

scala> var a = 2
a: Int = 2

scala> var b = 1.0
b: Double = 1.0

scala> var result = if(a > 0) a else b
result: Double = 2.0

隐式转换，Int会转为Double，因此最终是Double类型

scala> var abc = if(a > 0) "abc"
abc: Any = abc

a>0返回abc，否则返回Unit，因此最终是共同父类Any

流程控制-for

遍历/迭代

scala> var aa = 1 to 10
aa: scala.collection.immutable.Range.Inclusive = Range 1 to 10

scala> var bb = 1 until 10
bb: scala.collection.immutable.Range = Range 1 until 10


数组
scala> var array = Array(1, 3, 5, 7, 9)
array: Array[Int] = Array(1, 3, 5, 7, 9)

scala> var array = Array(1, 3, 5, 7, "A")
array: Array[Any] = Array(1, 3, 5, 7, A)
for遍历数组
val array = Array(1, 2, 3, 4, 5, "hello")
for (a <- array){
  println(a)
}

Java和Scala对比 可以利用to来取数组，Scala中用下标取数组用小括号

val array = Array(1, 2, 3, 4, 5, "hello")
for (i <- 0 to array.length - 1){
  println(i, array(i))
}

(0,1)

(1,2)

(2,3)

(3,4)

(4,5)

(5,hello) 或

val array = Array(1, 2, 3, 4, 5, "hello")
for (i <- 0 until array.length - 1){
  println(i, array(i))
}

打印偶数位置上的元素

val array = Array(1, 2, 3, 4, 5, "hello")
for (i <- 0 until array.length) {
  if (i % 2 == 0) {
  println(i, array(i))
  }
}

相当于

val array = Array(1, 2, 3, 4, 5, "hello")
for (i <- 0 until (array.length, 2)) {
    println(i, array(i))
}

步长为2，隔一个打印一次

scala> var abc = Array(1, 2, 3, 4, 5)
abc: Array[Int] = Array(1, 2, 3, 4, 5)

scala> for(a <- 0 until abc.length) yield abc(a) * 2
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10)

上面将所有循环的结果组合在一起，成为一个新的结果

scala> for(x <- 0 until a.length; y <- 0 until b.length if x != y)println(a(x), b(y))
(1,b)
(1,c)
(2,a)
(2,c)
(3,a)
(3,b)

双重循环 if 守卫

相当于Java中的 总结： 1、在Scala中没有运算符，所有的符号其实都是方法。 1+2 1.+(2)

2、在Scala中没有++、--的用法

3、for(i <- 表达式/数组/集合)

4、在for循环里面可以添加if表达式

5、有两个特殊表达式要了解： To Until

6、如果在使用for循环的时候，需要获取，yeild关键字 while 循环 和Java是一样的

方法和函数

scala> def sum(x:Int, y:Int):Int = {x + y}
sum: (x: Int, y: Int)Int

def 方法名(参数列表):返回值类型 = {方法体}

代码块里只有一句可以省掉大括号 定义方法 函数的定义

val sum = (x:Int, y:Int) => {x + y}
val multiple = (x:Int, y:Int) => {x*y}
println(sum(2, 3))
println(multiple(2, 3))

val 函数名 = (参数列表) => {代码块}

函数相当于变量，方法也相当于变量

=>可以理解为“转化为/变为” 上下对比 f 相当于变量名

Int => Int相当于类型

<function> 相当于值

下面方法第二个参数是一个函数 f: Int => Int 接收Int类型返回Int类型

def m1(x:Int, f: Int => Int)= f(x)
val ff1 = (x: Int) => x + 1
val ff2 = (x: Int) => x * 2
println(m1(1, ff1), ff1(1))
println(m1(1, ff2), ff2(1))

(2,2)

(2,2)

方法可以做为方法的参数

方法可以做为函数的参数

函数可以做为方法的参数

函数可以做为函数的参数

集合相关

  • 数组（Array）
  • 集合（Seq序列/列表, Set集合, Map映射）

很多其他的数据结构：Tuple， Stack，Queue，List

数组Array 分成两大类 1.定长数组和变长数组

  • 定长数组：Array（insert，delete是没有的，只有修改操作），当然还能模拟出插入和删除操作
  • 不定长数组：ArrayBuffer 缓冲数组，没有指定数组长度，可以无限增加元素

scala> val array1 = Array(1, 2, 3)

array1: Array[Int] = Array(1, 2, 3)

scala> array1(1)

res3: Int = 2

scala> array1(2)

res4: Int = 3 // 转为变长数组

scala> val ab = array1.toBuffer

ab: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3) // 追加一个元素

scala> ab += 1 res5: ab.type = ArrayBuffer(1, 2, 3, 1) // 追加多个元素

scala> ab += (2, 3, 4, 5)

res6: ab.type = ArrayBuffer(1, 2, 3, 1, 2, 3, 4, 5) // 追加一个数组

scala> ab ++= Array(6, 7)

res8: ab.type = ArrayBuffer(1, 2, 3, 1, 2, 3, 4, 5, 6, 7) // 在数组某个位置插入元素用insert

scala> ab.insert(0, -1, 0) // 删除数组某个位置的元素用remove

scala> ab.remove(8, 2) //追加一个数组缓冲

scala> ab ++= ArrayBuffer(9, 10)

res15: ab.type = ArrayBuffer(-1, 0, 1, 2, 3, 1, 2, 3, 6, 7, 9, 10)

+= 表示追加一个元素或多个元素
++= 表示追加一个Array或者ArrayBuffer或者其他的Seq类型的实现类的对象
ab.insert(0, -1, 0) 在第0位置上插入-1和0
ab.remove(0, 2) 从第0位置开始删除两个元素

scala> val arr1 = Array(1, 2, 3)
arr1: Array[Int] = Array(1, 2, 3)
// 用new，开辟空间，数组元素全为0
scala> val arr2 = new Array[Int](3)
arr2: Array[Int] = Array(0, 0, 0)
// 没用new，数组中有一个元素为3
scala> val arr3 = Array[Int](3)
arr3: Array[Int] = Array(3)

scala> val arr4 = Array.apply(3)
arr4: Array[Int] = Array(3)
要点：如果在构造数组的时候带了new，表示申请一个固定长度的数组
如果没有使用new，其实也在构造数组，只不过调用的是Array.apply()

定长数组和不定长数组的转换

val aa = Array(1, 2, 3)
val bb = new ArrayBuffer[Int]()
定长数组   aa.toBuffer   变长数组
变长数组   bb.toArray    定长数组

数组的常用操作
scala> ab.max
res16: Int = 10

scala> ab.min
res17: Int = -1

scala> ab.sum
res18: Int = 43

scala> ab.toArray
res19: Array[Int] = Array(-1, 0, 1, 2, 3, 1, 2, 3, 6, 7, 9, 10)

scala> ab.mkString("_")
res20: String = -1_0_1_2_3_1_2_3_6_7_9_10

scala> ab.mkString("<", "-", ">")
res21: String = <-1-0-1-2-3-1-2-3-6-7-9-10>

map

scala> ab.map((x:Int) => x + 1)
res22: scala.collection.mutable.Buffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 2, 3, 4, 7, 8, 10, 11)
参数是个匿名函数
map：不停的从数组中循环出来一个元素，交给参数函数做为输入，参数函数执行完毕后得到一个新的结果：map方法的执行逻辑还会初始化一个新的同类型的定长数组做为新的元素的返回容器
scala> val func1 = (x: Int) => x * x
func1: Int => Int = $$Lambda$1314/1216947434@704f5049

scala> ab.map(func1)
res23: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 0, 1, 4, 9, 1, 4, 9, 36, 49, 81, 100)

scala> val func2 = (x:Double) => x * x
func2: Double => Double = $$Lambda$1315/2024365811@6f04b51b

scala> ab.map(func2)
<console>:15: error: type mismatch;
 found   : Double => Double
 required: Int => ?
       ab.map(func2)


1)ab数组中的类型为Int类型，因此传入的参数函数的传入参数类型也必须是Int类型，其他不行
2)由于是map逻辑，所以这个参数的函数，只能定义一个参数，不能定义两个参数或多个参数
3)函数返回值类型没有限制

reduce
用来聚合
scala> val aa = Array(3, 4, 5, 6, 7, 66, 77, 11, 22)
aa: Array[Int] = Array(3, 4, 5, 6, 7, 66, 77, 11, 22)

scala> aa.max
res25: Int = 77

scala> aa.min
res26: Int = 3

scala> aa.reduce((x:Int, y:Int) => {if(x > y) x else y})
res27: Int = 77

scala> aa.reduce((x:Int, y:Int) => {if(x < y) x else y})
res28: Int = 3
// 相当于aa.sum
scala> aa.reduce((x:Int, y:Int) => {x + y})
res29: Int = 201
reduce方法的逻辑：
给定一个初始变量（初始变量的类型是否可以推断？）
从aa中每次拿出一个元素和这个初始值进行聚合（是怎样的逻辑就由参数函数的实现体来决定）
聚合完成之后得到元素就重新赋值给这个临时变量
然后重复执行聚合直到最后得到一个元素
reduce方法的参数有要求：
1)既然是聚合，所以这个参数，必定是接收多个参数，返回较少的值，一般来说，就是接收两个参数，返回一个值
2)参数函数的类型依然要和aa中的元素一致
3)参数函数的返回值类型，必须和参数函数的输入参数的类型一致，因为返回值会在聚合中成为输入参数

count
scala> aa.map((x:Int) => 1).reduce((x:Int, y:Int) => x + y)
res30: Int = 9
将元素变为1然后相加

flatMap fold avg

作业：
求均值
用Java模拟map操作
用Java模拟reduce操作

aa.filter((x:Int) => if (x % 2 != 0) true else false)

数组的遍历

for(a <- aa) println(a) for(i <- 0 until aa.length) println(aa(i))

集合

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展字Iterable特质，在Scala中集合有可变（mutable）和不可不（immutable）

两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）

可变和不可变

可变：当前这个集合的元素可以改变

不可变：当前这个集合中的元素不可更改 var和val 1)scala推崇使用val而不推荐使用var：为了安全 2)var表示可变，val表示不可变 （val == final）

他们修饰的变量是：

基本类型：值不可以改

引用类型：引用不可以改

final int a = 2

a不能改为其他值

final Student s = new Student("xiaoming", 22)

s的年龄可以改为其他值

val list = scala.collection.immutable.List(1, 2, 3) 也可以模拟一些修改操作，但是返回的都不是原来的集合，都是一个新的集合

https://blog.csdn.net/zhongqi2513/article/details/82956813 Scala集合的mutable和immutable解释

四种常用的集合类：List Set Map Tuple + Array

序列-List

任何一个List都是由 头元素 和 尾列表 组成

空列表：Nil 避免空指针的异常

：：操作符将给定的头和尾创建一个新的列表，是右结合的

scala> val list2 = 3 :: Nil
list2: List[Int] = List(3)
头元素::尾列表
scala> val list3 = 4 :: 3 :: Nil
list3: List[Int] = List(4, 3)
先是3和空的尾列表Nil结合，再是4和尾列表List(3)结合
scala> val list1 = List(1, 3, 4)
list1: List[Int] = List(1, 3, 4)

scala> val list2 = 2 :: list1
list2: List[Int] = List(2, 1, 3, 4)

scala> val list3 = list1 :: 2
<console>:13: error: value :: is not a member of Int
       val list3 = list1 :: 2
                         ^

scala> val list3 = list1 :+ 2
list3: List[Int] = List(1, 3, 4, 2)

scala> val list4 = 2 +: list1
list4: List[Int] = List(2, 1, 3, 4)
// 相当于2 +: list1
scala> val list5 = list1.+:(2)
list5: List[Int] = List(2, 1, 3, 4)
// 相当于list1 :+ 2
scala> val list5 = list1.:+(2)
list5: List[Int] = List(1, 3, 4, 2)

scala> val list3 = list1 +: List(2)
list3: List[Any] = List(List(1, 3, 4), 2)

scala> val list3 =  List(2) :+ list1
list3: List[Any] = List(2, List(1, 3, 4))
:+和+: 两者的区别在于:+方法用于在尾部追加元素，+:方法用于在头部追加元素，和::很类似，但是::可以用于pattern match ，而+:则不行. 关于+:和:+,只要记住冒号永远靠近集合类型就OK了。
比如 2 :+ list1 会出错，因为2不是集合类型，写成List(2) :+ list1就不报错了
// 两个list合并成一个新的list
scala> val list4 = list1 ++ list2
list4: List[Int] = List(1, 3, 4, 2, 1, 3, 4)
// list2插入到list1前面生成一个新的集合
scala> val list6 = list1.:::(list2)
list6: List[Int] = List(2, 1, 3, 4, 1, 3, 4)
scala> val nums = 1::2::3::4::Nil
nums: List[Int] = List(1, 2, 3, 4)
// 判断List是否为空
scala> nums.isEmpty
res34: Boolean = false
// 头部元素
scala> nums.head
res36: Int = 1
// 尾列表
scala> nums.tail
res37: List[Int] = List(2, 3, 4)
// 第二个元素
scala> nums.tail.head
res38: Int = 2
// 头部列表
scala> nums.init
res39: List[Int] = List(1, 2, 3)
// 最后一个元素
scala> nums.last
res40: Int = 4
//
scala> val nums2 = nums.init :+ nums.last
nums2: List[Int] = List(1, 2, 3, 4)
// 倒数第二个元素
scala> nums.init.last
res41: Int = 3
// 反转列表
scala> nums.reverse
res42: List[Int] = List(4, 3, 2, 1)
// 第二个元素
scala> nums.init.reverse.tail.init
res43: List[Int] = List(2)
// 舍掉第一个元素
scala> nums.drop(1)
res44: List[Int] = List(2, 3, 4)
// 舍掉前两个个元素
scala> nums.drop(2)
res45: List[Int] = List(3, 4)
// 取前两个元素
scala> nums take 2
res47: List[Int] = List(1, 2)
// 分割列表
scala> nums.splitAt(2)
res48: (List[Int], List[Int]) = (List(1, 2),List(3, 4))
// 分割列表，返回的是元组
scala> nums.splitAt(3)
res49: (List[Int], List[Int]) = (List(1, 2, 3),List(4))
// 取元组的第一个元素
scala> res49._1
res50: List[Int] = List(1, 2, 3)
// 取元组的第二个元素
scala> res49._2
res51: List[Int] = List(4)

scala> val chars = List("a", "b", "c", "d")
chars: List[String] = List(a, b, c, d)
// zip，返回元组的列表
scala> nums zip chars
res52: List[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))
// 转为映射
scala> res52.toMap
res53: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)
// 转为字符串
scala> nums.toString
res54: String = List(1, 2, 3, 4)
// 转为数组
scala> res52.toArray
res55: Array[(Int, String)] = Array((1,a), (2,b), (3,c), (4,d))

Set

集合：最大的作用是，去重，求交集并集差集
package com.jiehui.test

import scala.collection.immutable.HashSet
import scala.collection.mutable

object Demo_If {
  def main(args: Array[String]): Unit = {
    // 不可变set
    val set1 = new HashSet[Int]()
    println(set1)  // Set()
    // set1不会变
    val set2 = set1 + 4
    println(set1, set2)  // (Set(),Set(4))
    // ++ 两个集合合并，元素顺序不一定，hash值决定
    val set3 = set2 ++ Set(5, 6, 7)
    val set4 = Set(1, 3, 2) ++ set2
    println(set3, set4)  // (Set(5, 6, 7, 4),Set(1, 3, 2, 4))

    val set5 = Set(1, 2, 3, 4, 5)
    val set6 = Set(3, 4, 5, 6, 7)
    // 交
    println(set5.intersect(set6))  // Set(5, 3, 4)
    // 并
    println(set5.union(set6))  // Set(5, 1, 6, 2, 7, 3, 4)
    // 差
    println(set5.diff(set6))  // Set(1, 2)
    // 可变set
    val set7 = new mutable.HashSet[Int]()
    val set8 = set7 + 1
    println(set8, set7)  // (Set(1),Set())
    set7 += 1
    println(set7)  // Set(1)
    set7 ++= Set(2, 3, 5)
    println(set7)  // Set(1, 5, 2, 3)
    set7 -= 5
    println(set7)  // Set(1, 2, 3)
    set7.remove(1)
    println(set7)  //Set(2, 3)
  }
}
两大类：
1、构建，增加，删除
2、求交集，并集，差集

Map

两大类：
1、创建map，put(k, v)，get(k)
2、其他常用操作
scala> val map = Map("a" -> 1, "b" -> 2)
map: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)

scala> map
res56: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)

scala> map("a")
res57: Int = 1

scala> map.get("a")
res58: Option[Int] = Some(1)
有三种需要注意的类型：
Option  父类
两个子类：
Some 表示有值
None 表示无值
scala> map("c")
java.util.NoSuchElementException: key not found: c
  at scala.collection.immutable.Map$Map2.apply(Map.scala:138)
  ... 28 elided

scala> map.get("c")
res60: Option[Int] = None
用get不会报错，避免了key不存在抛出异常的情况
scala> map.getOrElse("c", 2)
res61: Int = 2
可变的map
scala> val map1 = new scala.collection.mutable.HashMap[String, Int]()
map1: scala.collection.mutable.HashMap[String,Int] = Map()

scala> map1("c") = 3

scala> map1("a") = 1

scala> map1("b") = 2

scala> map1
res65: scala.collection.mutable.HashMap[String,Int] = Map(b -> 2, a -> 1, c -> 3)

scala> map1("c") = 5

scala> map1
res67: scala.collection.mutable.HashMap[String,Int] = Map(b -> 2, a -> 1, c -> 5)
scala> val map1 = new scala.collection.mutable.HashMap[String, Int]()
map1: scala.collection.mutable.HashMap[String,Int] = Map()

scala> map1("c") = 3

scala> map1("a") = 1

scala> map1("b") = 2

scala> map1
res65: scala.collection.mutable.HashMap[String,Int] = Map(b -> 2, a -> 1, c -> 3)

scala> map1("c") = 5

scala> map1
res67: scala.collection.mutable.HashMap[String,Int] = Map(b -> 2, a -> 1, c -> 5)

scala> map1 += (("c", 5), ("d", 5))
res68: map1.type = Map(b -> 2, d -> 5, a -> 1, c -> 5)

scala> map1 -= "c"
res69: map1.type = Map(b -> 2, d -> 5, a -> 1)

scala> map1.remove("a")
res70: Option[Int] = Some(1)
key一般倾向使用不可变的类型 final String

Tuple

list set 定义了之后，能放进去的类型就确定了
tuple
能组合多个不同类型的值到一起，形成一个不可变的一个数据整体
访问的时候通过顺序编号值 . _x
scala> val t = ("shu", 2, false, 4.4)
t: (String, Int, Boolean, Double) = (shu,2,false,4.4)

scala> t._1
res71: String = shu

scala> t._2
res72: Int = 2

// 只有一个元素时，不是元组，是一个值
scala> val tt = (1)
tt: Int = 1

scala> val (a, b, c, d) = ("shu", 2, false, 4.4)
a: String = shu
b: Int = 2
c: Boolean = false
d: Double = 4.4

scala> val t,(a, b, c, d) = ("shu", 2, false, 4.4)
t: (String, Int, Boolean, Double) = (shu,2,false,4.4)
a: String = shu
b: Int = 2
c: Boolean = false
d: Double = 4.4
为什么元组是四种类型最常用的呢？




元组的拉链操作


仅限于二元组

元组中的元素的个数只有两个，就可以看作是二元组，用途 转key-value



原文地址：https://www.cnblogs.com/aidata/p/11494408.html
				


				
时间： 2024-10-21 16:10:37 

		


		


	

	
	

		


		
Scala（一）基础的相关文章


						

		

			

                新书：Scala语言基础与开发实战
			

		

		

									

				大数据科学丛书系列的最新一本<Scala语言基础与开发实战>即将面市,预计月底上架.内容还是不错的,文笔简介,内容实用,值得学.用. 大数据资深培训师王家林新作. 详细介绍大数据开发语言Scala及其在分布式框架Akka和Kafka中的应用. 秉承"实战"类图书特点,解析大量代码的编写操作,具有较强的可操作性,便于读者学习和理解. 算上再过几个月出版的<Spark内核解析及性能调优>,一年时间,大数据科学丛书系列之Spark的小套系基本形成了:从学习Spark的			

		

	

				

		

			

                scala的基础数据类型&amp;if条件表达式&amp;for循环
			

		

		

									

				scala的基础数据类型有7种:(无引用类型) Byte Char Short Int Long Float Double 两种变量类型定义:val(常量)var(变量) 使用val定义的常量,指引用的不可再改变,而用var变量引用的是可以进行改变,如下示: 注:scala语言可以不用定义变量的数据类型,变量的数据类型会根据输入的内容自动识别变量所引用的值的类型,也可以不用在语句后加分号,系统默认一行是一条语句. if条件表达式: for循环: 数组定义及for循环使用: 原文地址:https:			

		

	

				

		

			

                Scala学习——基础篇
			

		

		

									

				一.基础 1.变量val 标志符: 声明常量: 如,val answer = 1var 标志符:声明变量: 类型推断:变量的类型由scala根据初始化变量的表达式推断而来: 鼓励使用val: 注:声明变量时不做初始化会报错. 明确类型: scala的变量或函数的类型总是写在变量或函数的后面. 1 val a:Int = 1 2 val str:String = 2 2.常用类型 Scala支持7种数值类型和1种Boolean类型. Byte/Char/Short/Int/Long/Float/D			

		

	

				

		

			

                Scala学习 - 基础类型
			

		

		

									

				Scala中的类型相对于Java来说,与.net的想法更为接近,所有的类型都是基于一个基础类型,包括值类型也是继承自该类型: Java中值类型是语言直接提供的,这点上有点不同: 类型关系图如下: 其中所有类型的基类与Any Any之后分为两个AnyVal与AnyRef 其中AnyVal是所有值类型的父类型 AnyRef是所有引用类型的父类型 与其他语言稍微有点不同的是,Scala还定义了底类型 其中Null类型是所有引用类型的底类型,及所有AnyRef的类型的空值都是Null 而Nothing是			

		

	

				

		

			

                scala的基础部分
			

		

		

									

				最近接触到spark,spark又是scala编写的,所以需要学习一下scala. scala是面向对象的,一切皆为对象, 数值,函数都是对象. println("Welcome to the Scala")  /就这样进入scala学习模式了.... 1.变量 val x=10;自动转换类型为Int.val y:Int=10;自定义变量y的类型.lazy val c=a+b ;当变量c第一次被使用的时候才会被计算值. 2.scala类型体系基类:AnyAny下面是AnyVal和Any			

		

	

				

		

			

                scala系列--基础语法
			

		

		

									

				Scala 与 Java 的最大区别是:Scala 语句末尾的分号 ; 是可选的. 区分大小写 -  Scala是大小写敏感的,这意味着标识Hello 和 hello在Scala中会有不同的含义. 类名 - 对于所有的类名的第一个字母要大写. 方法名称 - 所有的方法名称的第一个字母用小写. 程序文件名 - 程序文件的名称应该与对象名称完全匹配. import语句可以出现在任何地方,而不是只能在文件顶部.import的效果从开始延伸到语句块的结束. 如果想要引入包中的几个成员,可以使用selec			

		

	

				

		

			

                scala的基础概念
			

		

		

									

				scala方法的定义:def methed(参数:类型..) :返回类型 = {}:非递归返回类型可以省略返回类型:返回类型是Unit时,可以省略=:函数的定义:val f:类型=>类型 = {参数=>返回}:val f = (参数列表) => {实现}:函数可以作为方法的参数:方法(利用了_转换成函数了)也可以作为方法的参数: 数组:Array[数组类型](数据)Array(Apply):new定长数组.变长数组ArrayBuffer:访问:+=.++=.-=.insert(位置,数据			

		

	

				

		

			

                scala言语基础学习四
			

		

		

									

				伴生对象 object方法构造函数只会执行一次.伴生对象和对象之间private对象可以互相访问 让object继承抽象类 apply方法 可以不new就构造对象 类似于var s = ArrayBuffer[Int]; scala main方法可以通过def main(args:Array[String])作为函数入口或者继承app方法 scalac + filename.scala 编译文件 然后通过scala class文件名字进行执行 利用拓扑			

		

	

				

		

			

                scala言语基础学习九
			

		

		

									

				模式匹配 case _ =>不能放在函数的中间必须放在最后,否则scala会编译不通过 在case 里面使用if守卫 在模式匹配中获取输入的数据(在匹配不到的情况下) 对类型进行匹配			

		

	

				

		

			

                Scala编程基础
			

		

		

									

				Scala与Java的关系... 1 安装Scala. 1 Scala解释器的使用... 2 声明变量... 2 数据类型与操作符... 2 函数调用与apply()函数... 3 if表达式... 3 语句终结符.块表达式... 4 输入和输出... 4 循环... 4 高级for循环... 5 函数的定义与调用... 5 在代码块中定义包含多行语句的函数体... 5 递归函数与返回类型... 6 默认参数... 6 函数调用时带名参数... 6 变长参数... 6 序列作为变长参数... 6