scala基础学习（1）

在路径 usr/local/src/scala 目录下创建一个 mycode 目录
在 usr/local/src/scala/mycode 目录下创建一个 test.scala 文档

使用 vim 或者 gedit 编辑，其中 gedit 比较好用
打开终端：
命令如下：

gedit test.scala 打开文档
scala test.scala 编译

变量：

1.val变量：定义变量
2.var变量：在初始化以后还要不断修改的使用var定义

val i=123 //123是int型，
//同理: val i="123" =>>i=true(布尔型)
也可以：
val x=6
val a=if(x>0) 1 else -1
println(a)// ==>1

操作符：

//scala没有++，--操作 
a 方法 b <<==>>a.方法(b)   a+b  ==>>a.+(b) 
有 > , < , <= , >= 操作

创建一个数值序列：

1 to 5    从1到5的序列
1 to 5 by 2  从1到5步长为2的序列
//写入文本文件：
java.io.PrintWriter

print使用：

1. print：字符串输出方式==>print(“123”)
2. printf：格式化输出==>printf(“i 等于%d”,i)
3. printfln：普通输出方式==>println(i+j)

scala 循环：

var i = 9//这里不能用val,val的值是不变的，var的变
while(i>0){
	i-=1
	printf("i is %d\n",i)
}

for语句:
for(变量  <- 表达式) 语句块

 1. for(i <- 1 to 5)
 2. for(i <- 1 to 5 by 2)
 3. for(i <- 1 to 5 if i%2==0)
 4. for(i <- 1 to 5;j <- 1 to 3) println(i*j)
 5. for(i <- 1 to 5 if i%2==0;j <- 1 to 3 if j!=i) println(i*j)

从命令行输入语句总结：

read+类型

1.从命令行读取一行： 
val n=Console.readLine() 
val n=readLine() 

2.从命令行读取一个Int：
val x=Console.readInt()
val x=readInt()

同理操作：readInt，readDouble, readByte, readShort，readLong，readreadFloat，readBoolean或者readChar

定义数组：

• 定长数组

val a=new Arrag[Int](3)
a(0)=12
print(a(0))//==>12

Array[Int]  整数型数组
Array[String]  字符串型数组

val a=Array(12,34,56)
val a=Array("ab","cd","ef")

• 变长数组

对于那种长度按需要变化的数组，Java有ArrayList，C++有vector。Scala中的等效数据结构为ArrayBuffer

import scala.collection.mutable.ArrayBuffer 
val b=ArrayBuffer[lnt]() // 或者new ArrayBuffer [int]，一个空的数组缓冲，准备存放整数
b+=1 // ArrayBuffer (1)，用+=在尾端添加元素
b+=(1，2，3，5) // ArrayBuffer(1,1,2,3,5)，在尾端添加多个元素，以括号包起来
b++= Array(8, 13, 21) // ArrayBuffer(1, 1, 2, 3, 5, 8,13, 21) //用++=操作符追加任何集合
b.trimEnd(5) // ArrayBuffer(1, 1, 2)，移除最后5个元素

• 遍历一维

object test {
   def main(args: Array[String]) {
      var myList = Array(3, 5, 5, 7)
      // 输出所有数组元素
      for ( x <- myList ) {
         println( x )
      }
      // 计算数组所有元素的总和
      var total = 0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("总和为 " + total)
      // 查找数组中的最大元素
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("最大值为 " + max);
   }
}

• 遍历二维

import Array._
object test {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      // 创建矩阵
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      // 打印二维阵列
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

列表：

- 不可变列表

性质：

• 可以保存重复的值
• 有先后顺序

在scala中，也有两种列表，一种是不可变列表、另一种是可变列表

//使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表，语法格式：
val/var 变量名 = List(元素1, 元素2, 元素3...)

//使用Nil创建一个不可变的空列表
val/var 变量名 = Nil

//使用::方法创建一个不可变列表
val/var 变量名 = 元素1 :: 元素2 :: Nil

- 可变列表

可变列表就是列表的元素、长度都是可变的。
要使用可变列表，先要导入import scala.collection.mutable.ListBuffer

//使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
val/var 变量名 = ListBuffer[Int]()

//使用ListBuffer(元素1, 元素2, 元素3…)创建可变列表，语法结构：
val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

操作

1. 获取元素（使用括号访问(索引值)）
2. 添加元素（+=）
3. 追加一个列表（++=）
4. 更改元素（使用括号获取元素，然后进行赋值）
5. 删除元素（-=）
6. 转换为List（toList）
7. 转换为Array（toArray）

// 导入不可变列表
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

// 创建不可变列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

// 获取第一个元素
scala> a(0)
res19: Int = 1

// 追加一个元素
scala> a += 10
res20: a.type = ListBuffer(1, 2, 3, 10)

// 追加一个列表
scala> a ++= List(11,12,13)
res21: a.type = ListBuffer(1, 2, 3, 10, 11, 12, 13)

// 删除元素
scala> a -= 13
res22: a.type = ListBuffer(1, 2, 3, 10, 11, 12)

// 转换为不可变列表
scala> a.toList
res23: List[Int] = List(1, 2, 3, 10, 11, 12)

// 转换为数组
scala> a.toArray
res24: Array[Int] = Array(1, 2, 3, 10, 11, 12)