scala学习笔记02-scala中的集合类型:Array、List、Map、tuple、Option

scala中Array:

Scala提供了一种数据结构叫作数组，数组是一种存储了相同类型元素的固定大小顺序集合。数组用于存储数据集合，但将数组视为相同类型变量的集合通常更为有用。

	//数组的声明
	var arr01:Array[Int] = new Array[Int](10);
    var arr02 = new Array[String](10)
	//遍历
	for (x <- 0 to arr03.length-1) println(arr03(x))
	arr03.foreach(v => println(v))	
	arr03.foreach(println(_))
	//mkstring函数
	//使用','为间隔符输出,以‘ <>’为左右输出
    println(arr03.mkString(",")) //1,2,3,4,5,6,7,8
    println(arr03.mkString("<",",",">")) //<1,2,3,4,5,6,7,8>
	//取出数组中的前3个 take()
    arr03.take(3).foreach(println(_))
	//将数据拼接 ****拼接之后产生一个新的数组****
    concat(arr01,arr03).foreach(println(_))
	// 产生一个1到100的有序数组，步长为3
	range(1,20).foreach(println(_))
    range(1,100,3).foreach(println(_))

scala中的ArrayBuffer：

Array数组与java中的数组一致，数组的长度是不可变的，但scala中提供了一个可变数组（ArrayBuffer），能够动态增加元素，也可以实现与Array的互转。

	//初始化可变列表arrayBuffer
    var arr01 = new ArrayBuffer[String]()
    var arr02 = ArrayBuffer("h1","h2","h3")
	//向arr02中添加值 **添加值的时候需要加()
    arr02 += ("h4","h5","h6","h7")
	//两个数组进行拼 将arr02中的数据追加到arr01中
    arr01++=arr02
	/**
      * insert 将值插入arr02中
      * ArrayBuffer(hello, h2, h3, h4, h5, h6, h7)
      * ArrayBuffer(hello, h2, h3, new_value, h4, h5, h6, h7)
      */
    println(arr02)
    arr02.insert(3,"new_value")
	//删除元素 -=的方式只会删除按顺序排列的第一个相同值的元素 remove()方法删除从某个下标开始的几个元素
    arr01-="d" //删除d元素
	arr01.remove(4,6) //删除从下标为4开始的6个元素
	//数组array类型和arrayBuffer类型互转
    val array = arr02.toArray //转为array类型
    val buffer = array.toBuffer //转为arrayBuffer类型
	//max min sum 求最大值 最小值 求和
    val arr03 = ArrayBuffer(23, 32, 56, 64, 86, 12, 33, 34)  //int类型的数组
    println(arr03.min) //最小值
    println(arr03.sum) //求和
	//数组排序sortwith
    println(arr03.sortWith(_>_).mkString("-"))
    //使用工具类排序quickSort 使用quickSort方法是需要切换成array类型
    println(quickSort(arr03.toArray))

scala中list:

Scala列表list类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是

	//定义：
	var list=List() //定义一个空的List     
	var list2=List("zs","ls") //定义一个带有初始值的List
	var list3=“aa”::(“bbb”::Nil)  //为list3列表定义aaa和bbb两个值    
    //注意：最后一个元素必须加上::Nil
	//LIST常用方法：
	list.head //返回LIST第一个元素
	list.tail //返回一个LIST，包含除了第一元素之外的其他元素
	list.isEmpty //LIST是否为空
	//多个LIST连接
	list1:::list2   或者 list.:::(list2) 或者 List.concat(list1,list2)
	//查看LIST中是否包含某个元素：list1. contains(“aaa”)
    //判断元素存在于list 返回true和false
    println(l5.contains("hello"))
	//查看LIST中满足条件的元素： list1.filter(x=>x%2==0)
    //判断元素是否存在
    println(l5.filter(d => d.eq("h1")))
    //判断元素按什么开头
    println(l5.filter(d => d.startsWith("m")))
	//通过 :+ 和 +: 给list 追加元素(本身的集合并没有变化)
	var list1 = List(1, 2, 3, "abc")
	//:+运算符表示在列表的最后增加数据
	val list2 = list1 :+ 4 // (1,2,3,"abc", 4)
	println(list1) //list1 没有变化(1, 2, 3, "abc"),说明list1 还是不可变
	println(list2) //新的列表结果是[1, 2, 3, "abc", 4]

scala中的可变链表-ListBuffer:

listbuffer的值和长度都可变,使用ListBuffer需要导入包scala.collection.mutable.ListBuffer

	//listbuffer定义
    var lb1=ListBuffer[String]("1","2","3")
    var lb2 = ListBuffer("a1","a2","a3")
    //向listbuffer中加值
    lb2+="a4"
    lb2.append("a5","a6")
    //两个list拼接 list可以为不可变list	
    println(lb1 ++= lb2)

scala中的Map：

是一组键/值对的对象。 任何值都可以根据键来进行检索。键在映射中是唯一的，但值不一定是唯一的。
映射也称为哈希表。映射有两种，不可变的和可变的。可变对象和不可变对象之间的区别在于，当对象不可变时，对象本身无法更改。

	  //map的定义
    var m1 = Map("黎明"->35,"流行l"->33)
    var m2 = Map[Int,String](1->"李四",2->"张三")
    var m3 = Map[String,Long](("小芳",55),("小明",66))
	  //向map中添加值
    m1+=("可可"->2)
    m1+=(("密码",33),("卡拉",53))
      //map不支持修改
      //取得map中不存在的值时，在java中会返回null，scala中会返回异常，影响程序执行
	//println(m1("黎明"))
    println(m1.get("lll")) //None
    println(m1.getOrElse("mmm",888)) //使用getOrElse如果没有值时会返回默认值
	  //map的遍历
    for((k,v) <- m2) println((k,v)) //可返回kv键值对
    for(k <- m2.keySet) println(k)  //返回key值
    for(v <- m2.values) println(v) //返回value值
scala中的HashMap：import scala.collection.mutable.HashMap
	//定义HashMap
    var hm1 = HashMap[String,Int](("丽丽",11),("明敏",22), ("黎明",33))
    //map修改值
    hm1("丽丽") = 88
    println(hm1("丽丽"))
    //map赋值
    hm1.put("尔尔",35)

scala中的元组-tuple

Scala元组将固定数量的项目组合在一起，以便它们可以作为一个整体传递。 与数组或列表不同，元组可以容纳不同类型的对象，但它们也是不可变的。

	 //定义 tuple
    var t1 = (1,"hello","ma","kk",235,2,5,3,4,4,5,5,5,5,6,3,452) //类型可变的数组类型
     //指定长度的tuple类型 1个tuple中最多22个元素
    var t2 = new Tuple2("woshi2","mmmm")
    println(t1) //打印t1
    println(t1._17) // 取指定下标的元素

scala中的Option：

是由给定类型的零或一个元素的一种容器。Option[T]可以是 Some [T]或None对象，它代表缺少的值。

	  //初始化option
    var find:Option[String] = op1(1)
    println(find) //Some(zx)
    println(find.get) //zx
    println(find.getOrElse("查无此人")) //如果返回值为none会报错，使用getOrElse可以使用默认值
      //定义option
	def op1(id:Int):Option[String]={
	  if (id == 1){
        Some("zx")
      }else{
        None
      }
    }