HelloWorld

实验用的是实验楼的环境进行学习
第一步是在终端上跑Hellowrld

scala> object Helloworld {
     | def main(args:Array[String]){
     | println("Hello,world")
     | }
     | }

要学习的东西如下

交互式 Scala 解释器的使用方法
变量、函数的定义
变量定义：
两种变量，val和var, val相当于final，初始化之后不能重新赋值， va初始化后可以任意赋值。

scala> val msg = "this is a message"

在进行赋值时可以发现，并未声明字符类型，这在 Scala 语言中称为“ type inference ”（类型推断）。当然也可以自己声明类型，但这样就不Scala了

scala> val msg:String = "this is a message"

另外Scala也不需要使用分号结尾，如果需要多行输入会在新行面前显示 | 。

函数定义:

scala> def max(x:Int,y:Int) : Int ={
     | if (x >y) x
     | else
     | y
     | }
max: (x: Int, y: Int)Int

函数用def进行定义，在Scala中变量类型在参数和变量的后面，好处是有利于参数推断。
此外每个 Scala 表达式都有返回结果（这一点和 Java，C# 等语言不同），比如 Scala 的 if else 语句也是有返回值的，因此函数返回结果无需使用 return 语句。实际上在Scala代码中应当尽量避免使用 return 语句。函数的最后一个表达式的值就可以作为函数的结果进行返回。同样的Scala可以对返回结果的类型进行推断，
如果是如下的无返回值的，会返回Unit,类似于Void

scala> def greet() = println("hello,world")
greet: ()Unit

循环、迭代的实现
利用循环索引访问结果:简单不多说

val args = Array("I","like","scala")
var i=0
while (i < args.length) {
  println (args(i))
  i+=1
}

利用foreach访问:调用的是foreach方法，传入一个参数，参数实际也是一个匿名函数，

args.foreach(arg => println(arg))

利用for访问：arg为args里的value的遍历

for (arg <-args)
  println(arg)

数组的参数化

val greetStrings = new Array[String](3)
greetStrings(0)= "Hello"
greetStrings(1)= ","
greetStrings(2)= "world!\n"
for(i <- 0 to 2)
  print(greetStrings(i))

使用[]为数组指明类型化参数，使用[]来指明数组的索引
0 to 2这个表达式演示了 Scala 的一个基本规则，如果一个方法只有一个参数，你可以不用括号和 . 来调用这个方法。0 to 2实际为（0）. to （2）。Scala中的所有基本数据类型也是对象，因此，0可以有方法。
这里也说明为什么 Scala 中使用 () 来访问数组元素，在 Scala 中，数组和其它普遍的类定义一样，没有什么特别之处，当你在某个值后面使用 () 时，Scala 将其翻译成对应对象的 apply 方法。因此本例中 greetStrings(1) 其实是调用 greetString.apply(1) 方法。这种表达方法不仅仅只限于数组，对于任何对象，如果在其后面使用 () ，都将调用该对象的 apply 方法。

List、元组、Set 和 Map 的使用
Array是可以修改的，List是不可修改的，为了适应函数式编程
这里也说明为什么 Scala 中使用 () 来访问数组元素，在 Scala 中，数组和其它普遍的类定义一样，没有什么特别之处，当你在某个值后面使用 () 时，Scala 将其翻译成对应对象的 apply 方法。因此本例中 greetStrings(1) 其实是调用 greetString.apply(1) 方法。这种表达方法不仅仅只限于数组，对于任何对象，如果在其后面使用 () ，都将调用该对象的 apply 方法。

val oneTwo = List(1,2)
val threeFour = List(3,4)
val oneTwoThreeFour=oneTwo ::: threeFour
println (oneTwo + " and " + threeFour + " were not mutated.")
println ("Thus, " + oneTwoThreeFour + " is a new list")

定义了两个 List 对象 oneTwo 和 threeFour ，然后通过 ::: 操作符（其实为 ::: 方法）将两个列表连接起来。实际上由于 List 的不可修改特性，Scala 创建了一个新的 List 对象 oneTwoThreeFour 来保存两个列表连接后的值。

val oneTwoThree = 1 :: 2 ::3 :: Nil
println(oneTwoThree)

::是右操作符，也就是：：右面的对象调用.::方法，Nil为一个空列表对象，上式等同于

val oneTwoThree =  Nil.::(3).::(2).::(1)

元组

val pair=(99,"Luftballons")
println(pair._1)
println(pair._2)

元组可以有多种数据类型
元组通过._索引访问
下标从1开始

Set

var jetSet = Set ("Boeing","Airbus")
jetSet +="Lear"
println(jetSet.contains("Cessna"))

估计不会怎么用，
Map

val romanNumeral = Map ( 1 -> "I" , 2 -> "II",
  3 -> "III", 4 -> "IV", 5 -> "V")
println (romanNumeral(4))

key/value 结构。提供了可修改和不可修改的Map类型

识别函数编程风格
一个简单的原则，如果代码中含有 var 类型的变量，这段代码就是传统的指令式编程，如果代码只有 val 变量，这段代码就很有可能是函数式代码，因此学会函数式编程关键是不使用 vars 来编写代码。
读取文件

import scala.io.Source

var args=Source.fromFile("/home/hadoop/test.txt") #记得在对应目录创建test.txt 文件，并写入一些内容

for( line <- args.getLines)
    println(line.length + "" + line)

可以看到 Scala 引入包的方式和 Java 类似，也是通过 import 语句。文件相关的类定义在 scala.io 包中。如果需要引入多个类， Scala 使用 _ 而非 *。

HelloWorld

你可能感兴趣的:(HelloWorld)