scala数据结构(一)

一、概述

1，特点

)Scala同时支持不可变集合和可变集合

)两个主要的包：

    不可变集合：scala.collection.immutable

    可变集合：  scala.collection.mutable

)Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(immutable)的版本

)Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型。

2，不可变集合继承一览图

3，可变集合继承一览图

二、数组

1，可变和不可变:

　　Array ===> ArrayBuffer

2，定义不可变数据数组方式

//定义数组：方式一

val arr = new Array[Int]()

//定义数组：方式二

val arr = Array(,,"scala") //调用apply方法

arr()= //赋值，索引1的值为8

//添加，生成一个新的数组

arr.+:()

//删除，删除值为1的元素（并且只刪除第一个）

val array: Array[Any] = arr.drop()

//改，修改索引1的值为6

arr.update(,)

arr()=

3，定义变长数组

//定义变长数组

val ints = new ArrayBuffer[Int]()

val ints = ArrayBuffer[Int](, , )

//添加，同一个数组

ints.append()

//删除，删除索引为2之后的2个元素

ints.remove(,)

//改，同定长数组

ints()=

ints.update(,)

4，定长数组与变长数组转换

)arr1.toBuffer  //定长数组转可变数组

)arr2.toArray  //可变数组转定长数组

5，多维数组

//定义 arr 是一个二维数组:有三个元素[一维数组]，每个一维数组存放4个值

val arr = Array.ofDim[Double](,)

//赋值

arr()() = 11.11

6，Scala数组与Java的List互转

// Scala集合转成Java集合

val arr = ArrayBuffer("", "", "")

import scala.collection.JavaConverters._  //隐式转换

val javaList: util.List[String] = arr.asJava

println(javaList)    //[1, 2, 3]

//java的List转成scala的ArrayBuffer

val arrList = new util.ArrayList[String]()

arrList.add("test")

//隐式转换

import scala.collection.JavaConversions.asScalaBuffer

import scala.collection.mutable

val scalaArr: mutable.Buffer[String] = arrList

三、元组

1，简介

　　元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。

　　说的简单点，就是将多个无关的数据封装为一个整体，称为元组, 最大的特点灵活,对数据没有过多的约束。 //需求-> 高效率

2，创建

//1. tuple 的类型是 Tuple3

//2. 根据元素个数不同，对应的类型是 Tuple1----Tuple22

//3. Tuple是一个整体，使用迭代器进行遍历

//4. 访问Tuple的元素的方式是 tuple._1 .... tuple._3

//5. 元组是scala推荐使用，在java没有

val tuple = (, , "scala")

四、集合

1，定义:

　　Scala的List可以直接存放数据，就是一个object，默认情况下Scala的List是不可变的，List属于序列Seq。

　　不可变、可变: List ===> ListBuffer

2，创建:

　　val ints:List[Int] = List(1,2,3) //创建

　　List默认采用不可变方式在immutable包下不用引包，List中可以放任何类型数据List[Any]，空集合可以直接使用Nil对象

3，List常用操作

val ints = List(,,,)

//添加

val ints1 = ints :+     //ints集合后面追加

val ints2 =  +: ints    //ints集合前面添加

val ints3 =  :: ints      //将1作为元素往ints中添加

val ints3 = ints1 :: ints //将ints1中的元素与ints中元素合并为一个集合，:::两边都是集合

//修改，会生成一个新的集合

val intsUpdate = ints .updated(,)

//删除，截取原集合指定索引以及后面的所有元素生成一个新的集合

val intsDrop = ints.drop() //List(4, 5)

4，ListBuffer常用操作

val buffer = ListBuffer(,,)

//添加

buffer.append()

//修改

buffer.update(,)

//删除

buffer.remove()

println(buffer.mkString(","))  //6,1,10

五、Map

1，定义

　　Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map是有序的，可变的Map是无序的。

　　不可变、可变: scala.collection.immutable.Map ===> scala.collection.mutable.Map

2，不可变immutable.Map

//创建

//方式一:底层为元组Tuple2类型，输出顺序与声明顺序一致

val map1 = Map("A" -> , "B" -> , "C" -> )

//方式二:对偶元组

val map2 = Map( ("A", ), ("B", ), ("C", ),("D", ) )

3，可变mutable.Map

//创建: 输出顺序与声明顺序不一致

val map1 = scala.collection.mutable.Map("A" -> , "B" -> , "C" -> )

//添加

//添加并创建一个新的map

val map2 = map1 + ("FFF"->)

//添加，追加到原有mao中

map1 += ("FFF"->)

//删除指定key

map1 -= ("B","C")

//修改指定key的值,如果没有改key就为添加

map1.update("A",)

4，Map取值

//key不存在抛异常NoSuchElementException

map(key)

//map.get(key)得到Option对象，要么是Some要么是None

map.get(key).get

//key存在返回值，不存在返回默认值

map.getOrElse(key,default)

六、Set

1，可变不可变

　　immutable.Set ===> mutable.Set

2，可变set集合操作

//创建可变set集合

val mutableSet = mutable.Set(,,)

//添加元素的两种方式

mutableSet.add()

mutableSet +=

//删除元素的两种方式

mutableSet -=

mutableSet.remove()

巴特西