在idea下scala的基本操作

scala基础

此代码包含：val和var的区别与使用；list列表的使用；块表达式的使用。条件表达式if的使用，以及for循环的几种写法
注意：
代码并不是直接复制就能用的，这与python是由区别的
创建文件

选择Object类型。

创建后就生成如下界面

接下来我们有两种写法，使程序能够运行。（个人理解：相当于C语言里的main函数，不能不写，否则无法运行）
第一种：

object Hello extends App {
  
}

第二种：

object Hello{
  def main(args: Array[String]): Unit = {
    
  }
}

object Hello extends App {
  // 变量声明
  // val 与 var  ：val是定义的是常量，一旦初始化就不可修改，而var可以被多次赋值，多次修改
  val str:String = "hello scala"
  println("val str是不可修改的常量， str=", str)
  //Output: (val str是不可修改的常量， str=,hello scala)
  var str1:String = "hello python"
  println("var str1是可以修改的变量， str1=", str1)
  //Output: (var str1是可以修改的变量， str1=,hello python)
  // 定义一个List[Any]的变量list
  val list: List[Any] = List(
    "a string",
    23333,
    'a',
    true,
    () => "This is a function return string"
  )
  list.foreach(element => println(element))
  /*
  Output:a string
  23333
  a
  true
  Hello$$$Lambda$10/940060004@17550481
  */
  // 类型转化，只能由低精度朝高精度转化，且转换是单向的
  // Byte -> Short -> Int -> Long -> Float -> Double    Char -> Int
  // 条件表达式
  val num: Int = 100
  val res = {
    if (num > 100)
      100
    else
      "100"
  }
  // getClass.getSimpleName相当于python的type()
  println(res.getClass.getSimpleName, res)
  // Output: (String,100)
  // 或着可以用一行来表达, 这与python有一点不同
  val res1 = if (num > 100) 250 else "250"
  println(res1.getClass.getSimpleName, res1)
  // Output: (String,250)
  // 块表达式, 如果表达式没有执行结果，就返回一个Unit对象，类似Java中的void。
  val result = {
    val a = 10
    val b = 20
    a+b
  }
  println(result.getClass.getSimpleName, result)
  //Output: (int,30)
  // 循环：for 循环， while 循环， do while 循环
  // for 循环 格式：for (变量<-集合或者数组)
  // 1 to 5 遍历的范围[1, 5]
  for (i<- 1 to 5)
    print(i)
    // Output: 12345
  println()
  // 1 until 5 遍历范围[1, 5)
  for (i<- 1 until 5)
    print(i)
    // Output: 1234
  println()
  // 简化写法，可以python联动一下for i in str: print(i)
  for (i <- str)
    print(i)
    // Output: hello scala
  println()
  // 嵌套写法
  for (i<- 1 to 5; j<- 1 until 5 if i*2 == j)
    print(i, j)
    // Output: (1,2)(2,4)
  // while 循环和do while 循环与python的写法一样
}

Output:

(val str是不可修改的常量， str=,hello scala)
(var str1是可以修改的变量， str1=,hello python)
a string
23333
a
true
Hello$$$Lambda$10/940060004@17550481
(String,100)
(String,250)
(int,30)
12345
1234
hello scala
(1,2)(2,4)

scala 方法与函数

scala中有方法与函数。Scala方法是类或对象中定义的成员，而函数是一个对象，可以将函数赋值给一个变量。换句话说，方法是函数的特殊形式。

1. 方法
   Scala中的方法跟java的类似，方法是组成类的一部分
   Scala中方法的定义使用def关键字，语法如下

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

2. 函数
   函数的定义与方法不一样，语法如下：

(参数列表) => 函数体

3. 方法与函数的区别
   （1） 方法是类的一部分，而函数是一个对象并且可以赋值给一个变量
   （2） 函数可以作为参数传入方法中
   （3） 方法可以转换为函数，当把一个方法作为参数传递给其他的方法或者函数时，系统会自动将该方法转换为函数。
4. 个人理解
   本人平时学的是python，当时看到Scala的函数与方法，有点反应不过来。因为写python代码的时候，def定义的是函数。而在python面向对象的时候才会遇到方法。
   在python中，我认为大部分func() 表示的是函数，.meth() 表示的是方法。
   例如

def hello():
	print("Hello Python!")
class Person:
	def __init__(self, name):
		self.name = name
	def display(self):
		print("My name is ", self.name)
# hello()是函数
hello()
# 创建Person对象
student = Person("zhangsan")
# .display()是方法
student.display()

以上是个人拙见，要真正理解，还是查看官方文档。

---

创建名字为FuncMeth，类型为object的scala文件
代码

object FuncMeth extends App {
  /*
  方法的定义
  def 方法名 (参数列表)：返回类型 = {
    方法体
  }
   */
  // 有返回值的addNum
  def addNum(a: Int, b:Int): Int = {
    var sum = 0
    sum = a+b
    sum
  }
  println(addNum(1, 2))
  // 无返回值的addNum1
  def addNum1(a: Int, b: Int): Unit = {
    var sum = 0
    sum = a+b
    println(sum)
  }
  addNum1(3, 4)

  // 参数为可变长度的参数列表
  def addData(a:String, b:Int* ) = {
    var res = 0
    for (i <- b)
      res += i
    a+res
  }
  println(addData("good", 1,2,3,4,5))
  // addData(String, Int*) 不能在Int* 直接传入数组，否则会报错，除非进行如下操作
  val arr = Array(3, 4, 5)
  val list: List[Int] = List(1, 2, 3)
  // array:_* 的含义是将数组array的每一个元素分别当作参数，而不是将数组当作单一的参数传入
  println(addData("okk", arr:_*))
  println(addData("Master", list:_*))
  def addData1(a:String, arr:List[Int]) = {
    var sum = 0
    for (i <- arr)
      sum += i
    a+sum
  }
  // 数组与列表的区别
  //列表传入是正确的
  println(addData1("List", list))
  //数组传入是错误的
  //  println(addData1("Array", arr = arr))

  /*
  函数的定义
  (参数列表) => 函数体
   */
  // 带参数
  val f1 = (a:Int, b:Int) => {a+b}
  println(f1(1, 3))
  // 不带参数
  val f2 = () => {println("这是不带参数的函数f2()")}
  f2()
  /*
  方法与函数的区别
  （1） 方法是类的一部分，而函数是一个对象并且可以赋值给一个变量
  （2） 函数可以作为参数传入方法中
   */
  //  m1是一个方法，f是一个作为m1参数的函数
  def m1(f: (Int, Int) => Int): Int = {
    f(2, 6)
  }
  println(m1(f1))
  /*
  （3） 方法可以转换为函数
  当把一个方法作为参数传递给其他的方法或者函数时，系统会自动将该方法转换为函数。
   */
  def m2(x:Int, y:Int) = {x+y}
  println(m1(m2))

  // 除了系统自动转换外，也可以手动进行转换。在方法名称后加入一个空格和一个下划线，即可将方法转换为函数。
  // 方法转函数
  val f3 = m2 _
  println(m1(f3))
}

Output:

3
7
good15
okk12
Master6
List6
4
这是不带参数的函数f2()
8
8
8

scala 集合的使用

scala集合分为可变集合和不可变集合。可变集合可以对其中的元素进行修改、添加、移除；而不可变集合永远不会改变，但是仍然可以模拟添加、移除和更新操作。这些操作都会返回一个新的集合，原集合的内容不发生改变。

数组

定长数组

val arr = Array(1, 2, 3)	//自动推断数组类型
val arr = Array[Int](1, 2, 3)	//手动指定数组类型

也可以先定义数组长度和类型，再添加数据

val arr = new Array[Int](3)
arr(0) = 1
arr(1) = 2
arr(2) = 3

使用for循环遍历数组

val arr = Array(1, 2, 3)
for (i <- arr){
  print(i)
}

scala 对数组提供的常用方法

val arr = Array(2, 1, 3)
// 求数组中所有数值的和
val arrSum = arr.sum
// 求数组中的最大值
val arrMax = arr.max
// 求数组中的最小值
val arrMin = arr.min
// 对数组进行升序排序
val arrSorted = arr.sorted
// 对数组进行降序排序
val arrReverse = arr.sorted.reverse

变长数组

变长数组使用类scala.collection.mutable.ArrayBuffer进行定义

import scala.collection.mutable.ArrayBuffer
// 定义一个变长Int类型数组
val arr = new ArrayBuffer[Int]()
// 添加3个元素
arr += 1
arr += 2
arr += 3
println(arr)

使用-=符号对变长数组的元素进行删除。例如

arr -= 3

去掉数组arr中值为3的元素，若数组中有多个值为3的元素，则从前往后删除第一个匹配的值。

码字不易，未完待续