1. 高级操作

//map 是对 List 中每一个元素执行指定操作
// var list = List(3,6,8)
// var result = list.map(_+10)
// println(result)   //List(13, 16, 18)

//flatMap flatMap 与 map 类似，但如果 List 中的元素还是 List，则会对其进行 flatten 操作

//foreach 要求右侧的操作是一个返回值为 Unit 的函数，你也可以简单理解为执行一段没有返回值代码

// var sum = 0
// List(1, 2, 3, 4, 5) foreach (sum += _)
// println(sum)  //15

//列表过滤
//filter filter 用于筛选满足条件元素，返回新的 List

// var result = List(1, 2, 3, 4, 5) filter (_ % 2 == 0)
// println(result)  //(2,4)

//partition 会按照筛选条件对元素进行分组，返回类型是 tuple(元组)
// var result = List(1, 2, 3, 4, 5) partition (_ % 2 == 0)
// println(result)  //(List(2, 4),List(1, 3, 5))

//find find 查找第一个满足条件的值，由于可能并不存在这样的值，所以返回类型是 Option，可以通过 getOrElse 在不存在满足条件值的情况下返回默认值
// var result = List(1, 2, 3, 4, 5) find (_ % 2 == 0)
// println(result)  //Sum(2)
// var result = List(1,3,5) find (_ % 2 == 0)
// println(result.getOrElse(10))  //10

//takeWhile 遍历元素，直到遇到第一个不符合条件的值则结束遍历，返回所有遍历到的值

// val result = List(1, 2, 3, -4, 5) takeWhile (_ > 0)
// println(result)  //List(1, 2, 3)

// dropWhile 遍历元素，直到遇到第一个不符合条件的值则结束遍历，返回所有未遍历到的值
// List(1, 2, 3, -4, 5) dropWhile (_ < 3)
//span 遍历元素，直到遇到第一个不符合条件的值则结束遍历，将遍历到的值和未遍历到的值分别放入两个 List 中返回，返回类型是 tuple(元组)。
// List(1, 2, 3, -4, 5) span (_ > 0)


//列表检查

//forall 检查 List 中所有元素，如果所有元素都满足条件，则返回 true。
// List(1, 2, 3, -4, 5) forall ( _ > 0 )  //false
// exists 检查 List 中的元素，如果某个元素已经满足条件，则返回 true
//List(1, 2, 3, -4, 5) exists (_ > 0 )  //true


//列表排序
// sortWith 对 List 中所有元素按照指定规则进行排序，由于 List 是不可变的，所以排序返回一个新的 List。

//List(1, -3, 4, 2, 6) sortWith (_ < _)
// val list = List( "vilay","zz","p")
// println(list.sortWith(_.length<_.length))   //List(p, zz, vilay)

2. List对象的方法

2.1 List.range

List.range 可以产生指定的前闭后开区间内的值组成的 List，它有三个可选参数: start(开始值)，end(结束值，不包含)，step(步长)。

List.range(1, 5)  //List(1, 2, 3, 4)

2.2 List.fill

List.fill 使用指定值填充 List

List.fill(3)("hello")  //List(hello, hello, hello)

2.3 List.concat

List.concat 用于拼接多个 List。

List.concat(List('a', 'b'), List('c'))  //List(a, b, c)

3. 处理多个LIst

当多个 List 被放入同一个 tuple 中时候，可以通过 zipped 对多个 List 进行关联处理

// 两个 List 对应位置的元素相乘
(List(10, 20), List(3, 4, 5)).zipped.map(_ * _)  //List(30, 80)

//// 三个 List 的操作也是一样的
(List(10, 20), List(3, 4, 5), List(100, 200)).zipped.map(_ * _ + _) //List(130, 280)

//// 判断第一个 List 中元素的长度与第二个 List 中元素的值是否相等
(List("abc", "de"), List(3, 2)).zipped.forall(_.length == _)

4. 缓冲列表ListBuffer

List，由于其底层实现是链表，这意味着能快速访问 List 头部元素，但对尾部元素的访问则比较低效，这时候可以采用 ListBuffer，ListBuffer 提供了在常量时间内往头部和尾部追加元素

import scala.collection.mutable.ListBuffer

object ScalaApp extends App {

	val buffer = new ListBuffer[Int]
	// 1.在尾部追加元素
	buffer += 1
	buffer += 2
	// 2.在头部追加元素
	3 +=: buffer
	// 3. ListBuffer 转 List
	val list: List[Int] = buffer.toList
	println(list)
}