Scala简介、基本语法、变量、函数定义、Array和List

Scala简介、安装

1. Scala语言是面向对象的、面向函数的基于静态类型的编程语言
2. 安装即解压Scala的相对应版本的安装包，或者选择Scala的 .msi文件来安装，我的版本 [2.11.8]
   注意：
   1）安装目录不能有空格出现，否则可能会抛出主类找不到的异常
   2）必须安装jdk1.8.X以上，因为Scala的很多底层类型、语法都是调用Java的 。   .scala文件会像.java文件一样去编译成.class文件运行
3. 在IDAE中创建Scala工程
   1）首先安装Scala插件
   【File】–>【Settings】–>【plugins】–> 【搜索选择scala插件】–>【点击安装】
   2）创建scala工程项目
   【File】–>【New–>project】 -->选择scala选项，并指定【IDEA】–>【next】–>
   【设定工程名】–>【指定jdk版本】–>【scala版本】–>【finish】

基本语法

1. scala中有两种变量：val 和 var
   val 类似于 Java 里的 final 变量。一旦初始化了 val 就不能再赋值了。
   var 像 Java 里面的非 final 变量。var 可以在它生命周期中被多次赋值

   //例如:分别定义val和var并输出
   scala> val msg = "Hello, world!"
   msg: java.lang.String = Hello, world! 
   //在Scala中字符串类型就是:java.lang.String,也可简写为 String
   //:冒号后接表达式的类型 Int、String等
   scala> val msg2: java.lang.String = "Hello again, world!"
   msg2: java.lang.String = Hello again, world! 
   

2. 函数的定义
   函数定义 def 格式: def 函数名(参数列表[arg*:type]...):返回值类型 = {函数体，表达式}
   如果无返回值，采用Unit
   例如：

   scala> def max(x: Int, y: Int): Int = {      
   		if (x > y) x 
   		else y
   		} 
   
   注意:每个函数参数后面必须带前缀冒号的类型标注,因为Scala编译器没办法推断函数参数类型;但是可以进行结果类型的推断
   
   其它方式定义:
     scala>def max(x:Int,y:Int)={if(x>y)x else y}
     scala>def max(x:Int,y:Int)=if(x>y) x else y
     scala>def max(x:Int,y:Int)={println(x);println(y);if(x>y)x else y
   

3. 用 while 循环，if 判断
   Java 的++i 和 i++在 Scala 里不起作用，在 Scala 里自增，必须写成要么 i = i + 1，或者 i += 1

   //举例:
   var i = 0; 
   while (i < args.length) {  
   	if (i != 0) { 
   	  	print(" "); 
   	}  
   	print(args(i)); 
   	i += 1;
   }
   println(); 
   

4. 使用 foreach 遍历和 for 枚举
   定义一个集合list1： val list1 = List(1,2,3,4,5,6)

   用foreach遍历数组有三种方式:
       list1.foreach(x=>println(x))
       list1.foreach(println(_))
       list1.foreach(println)
   用for枚举:
       for(list <- list1) println(list)
   

5. 带类型的参数化数组
   Scala 里可以使用 new 实例化对象或类实例。在实例化对象时，可以使用值和类型把它参数化(parameterize)
   在创建实例时，通过把加在括号里的对象传递给实例的构造器的方式来用值参数化实例

   例如 ：demo1 是类型 Array[String]（字串数组）的值，并被第一行代码里的值 3 参数化，使其初始长度为3

   val demo1 = new Array[String](3) 
   //val demo1: Array[String] = new Array[String](3) 
   demo1(0) = "Hello"
   demo1(1) = ", "
   demo1(2) = "world!\n"
   for (i <- 0 to 2)
       print(demo1(i))
     	
   //输出结果：Hello, world!
   

   1）数组和 Scala 里其他的类一样只是类的实现。当你在一个或多个值 或变量外使用括号时，Scala 会把它转换成对名为 apply的方法调用。
   2）当对带有括号并包括一到若干参数的变量赋值.，编译器将把它转化为对带有括号里参数和等号右边的对象的 update 方法的调用.

   所以上面例子又可以写成：

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

   最简便的定义数组方式：

   val demo3= Array("hello,","world","!")
   demo3.foreach(print)
   print(demo3.toList)
   //输出结果:
   //hello,world!
   //List(hello, world, !)
   

6. 使用 List
   List(类似java中的LinkedList)基于链表实现，插入元素比较快，随机访问速度稍慢。
   1）创建实例：val oneTwoThree = List(1, 2, 3)

   // :::是实现叠加功能的方法
   val oneTwo = List(1, 2)
   val threeFour = List(3, 4)
   val oneTwoThreeFour = oneTwo ::: threeFour
   println(oneTwo + " and " + threeFour )
   println(oneTwoThreeFour)
   
   //输出结果
   List(1, 2) and List(3, 4)
   List(1, 2, 3, 4)
   
   // :: 将新元素组合到已有list最前端的方法,等同于twoThree.::(oneTwo)和 twoThree.::(1)
   //右操作数的方法，返回结果类型以右侧为准
   val _list = oneTwo :: twoThree
   println(_list)
   val twoThree = List(2, 3)
   val oneTwoThree = 1 :: twoThree
   println(oneTwoThree)
   
   //输出结果
   List(List(1, 2), 2, 3)
   List(1, 2, 3)
   

   2）定义一个空类Nil,再初始化一个新的List

   val oneTwoThree = 1 :: 2 :: 3 :: Nil
   println(oneTwoThree) 
   //输出结果: List(1, 2, 3)
   

   3）其他案例实现：

   val list = List[Int]()	//构造一个空元素的集合，元素类型为Int
   val list = List(1,2,3,4) //构造一个集合，初始化其内容，可以根据初始化的类型判断其类型，所以无需写泛型
   list.head					//list中的第一个元素
   list.length					//获取链表的长度
   list(3)						//按下标访问，获取第4个元素，但越往后越慢
   println(list.drop(2))		//删除左边的2个元素
   println(list.dropRight(2))	//删除右边的2个元素
   

    val listdemo5 = List(1,2,3,4)
    println(listdemo5)
    val listdemo6 = listdemo5.:+(7) //集合后加 7
    println(listdemo6)
    val listdemo7=listdemo6.+:(0) //集合前加 0
    println(listdemo7)
    val listdemo8=3 +:listdemo7 //集合前加 3 （第二种方式）
    println(listdemo8)
    
    // take(2)取listdemo8集合的前2个，takeRight(2)取listdemo8集合的后两个元素
    println(listdemo8.take(2) ::: List(6) ::: listdemo8.takeRight(2))
    
    //更新第三个元素为30。其实它是创建了一个新的数组，而不是真正更新
    println(listdemo8.updated(2,30))	
   
    //输出结果
    List(1, 2, 3, 4)
    List(1, 2, 3, 4, 7)
    List(0, 1, 2, 3, 4, 7)
    List(3, 0, 1, 2, 3, 4, 7)
    List(3, 0, 6, 4, 7)
    List(3, 0, 30, 2, 3, 4, 7)
   

   注意：
   定义的List集合的内容是不可变的，只读的
   List(1,2,3,4,5)它在堆内存中，除了基本变量和局部变量都是在堆内存中。
   如main方法中的局部变量使用的是栈内存。val也好，var也好这个变量的引用都在它都在栈内存。
   变量在堆内存中，只是说这个变量的引用指向堆内存。
   var只是说这个引用的地址可以改变，val是引用的地址不能发生变更

7. ArrayBuffer可变数组
   ArrayBuffer需要手动导入包，mutable可变，immutable不可变
   import scala.collection.mutable.ArrayBuffer
   举例：

   val buffer = ArrayBuffer(1,2,3,4,5)
         buffer(0)=10  //修改第一个数组元素值为 10
         buffer += 6   //在数组后添加一个元素 6
         println(buffer)
   输出结果:
   	  ArrayBuffer(10, 2, 3, 4, 5, 6)
   

8. Array和List的区别
   1）Array是连续存储结构，所以初始化时必须设定初始值，List是不连续的存储结构，所以可以不初始化。当不确定数组大小时，使用List替代Array；
   2）当需要大量查找操作时使用Array替代List， 当需要进行频繁的插入和删除时使用List代替Array。List相对比Array占用更多空间。
   3）查询某个值而言hashtable更快。当然它们结构完全不同，没有可比性。毕竟数组是节约空间，而hash表是散列的，牺牲空间来换取速度。
   注意：
   Array和List都不可变，最大的好处就是用在高并发的地方。
   因为在高并发时，如果多个线程都访问一个公用的变量，那这个变量就要加共享锁。
   这里也是最容易出错的地方，不光影响性能的问题。scala就换了个思路来解决多线程时并发的问题，它就是让这个共享变量不可变。
   那这个集合只能读，不能写，就自然不会存在并发访问问题。所以这两个类要比java中的性能高。
   当然scala也提供了可变版本，ArrayBuffer 对应 java中的可变对象 Array，ListBuffer对应 java 中的可变对象 List