2021-06-01

Scala中的常用集合

1.set： 无序 不可重复

不可变：

	//创建一个不可变的set  无序 不可重复的
    //val set = new Set[Int]() 不可用

    //默认使用的就是hashset，只是在元素比较少的情况下，有对应 多特殊对象
    val hashSet = HashSet(1,23,3,3,3,3,4,5,6,9)
    println(hashSet)

    //set默认是不可变的集合，数据无序

可变：

//创建可变集合mutable.set
    val hashSet1: mutable.Set[Int] = mutable.HashSet()

    //插入数据
    hashSet1.add(1)
    hashSet1.add(1)
    hashSet1.add(1)
    hashSet1.add(6)
    hashSet1.add(5)

    //打印可变集合set
    println(hashSet1)

2.map：无序 不可重复

不可变：

	//1.创建不可变集合map
    val map = Map("hello" -> 1,"world" -> 2,"scala" -> 3)
    val map1 = Map(("xue",6),("xi",7),("hao",8))
    println(map)
    println(map1)

可变：

 	//创建可变的map
    val map2: mutable.Map[String, Int] = mutable.Map()

    //向集合中增加元素
    map2.put("key",1)
    map2.put("key",1)
    map2.put("key",1)
    map2.put("k2",9)
    println(map2.put("k3", 18))
    println(map2)

3.array：数组 有下标 检索快

不可变：

	//不可变数组
    //创建一个数组对象，填写的是泛型类型和数组的长度  默认里面的元素都是默认值

    //动态创建
    val array1 = new Array[Int](10)

    //静态创建
    val array2 = Array(1,2,3,4,5,6,7,8,9,0)

可变：

	//可变数组
    //创建一个可变数组对象
    val arrayBuffer1 = new ArrayBuffer[Int]()

    val arrayBuffer2 = ArrayBuffer(1,2,3,4,5,6)

    //可变数组的打印
    println(arrayBuffer2)

4.list：链表 有序 不可重复

不可变：

	//list默认是一个不可变的集合
    //创建一个list     数据按照添加的顺序，元素可重复

    val list: immutable.Seq[Int] = List(1,2,3,4,5,5,5,5)

	println(list)

可变：

	//创建一个可变的list
    //静态
    val listBuffer: ListBuffer[Int] = ListBuffer(1,3,5,9)
    //动态
    val listBuffer1 = new ListBuffer[Int]()

    println(listBuffer)

5.元组

	//声明元组的方式
    val tuple = new Tuple2[String,Int]("hello",18)
    val tuple2: (String, Int,Double) = ("world",1,3.0)

6.遍历方法的选择：

val list: immutable.Seq[Int] = List(1,2,3,4,5,5,5,5)
    println(list)
    //内置函数
    list.foreach(print)
    println()
  
    //增强for循环
    for (elem <- list) {
      print(elem + " ")
    }
    println()
    
    //经典的迭代器循环
    val iterator = list.iterator
    while (iterator.hasNext){
      println(iterator.next())
    }

7.排序

	val list = List(1,2,3,4,5,6,7,88)

	//只有list能排序，集合本身有序 可重复
    //默认排序
    val sorted = list.sorted

    //如何倒序 先排序再reverse
    println(sorted.reverse)

    //采用sorted
    println(list.sorted(Ordering.Int.reverse))

    //sortWith  最终按照传入的两个参数 左右位置来排序
	//最常用的方法，处理场景多
    println(list.sortWith((left: Int, right: Int) => left < right))

    //化简一下
    println(list.sortWith(_ < _))

    //sortby  实例  以什么什么为排序   简化的sortwith
    val tuples = List(("hello", 12), ("world", 31), ("hihi", 213), ("haha", 1))

    //按照元组的字符串字典序来排序
    println(tuples.sortBy((elem: (String, Int)) => elem._1))
    println(tuples.sortBy((elem: (String, Int)) => elem._2))

    //化简
    println(tuples.sortBy(_._2))

8.filter过滤

 	val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //过滤
    //遍历一个集合从中获取满足条件的元素组成一个新集合
    //求出list中所有的偶数
    val list1 = list.filter((x: Int) => x % 2 ==0)
    println(list1)

    //化简
    val list2 = list.filter( _ % 2 == 0)

9.map映射/一对一的输入和输出

	//转化/映射（map）
    //将集合中的每一个元素映射到某一个函数  不是转换到map集合
    //需求  将list中元素都*2

	val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
	
	list.map((x: Int) => x * 2)
    val list1: List[Int] = list.map(_ * 2)
    
 

    //需求将list转换为 元素 （"我是："，1）
    list.map((x:Int) => println("我是：" + x))
    println(list.map("我是：" + _))

10.扁平化

	val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
	
	//针对的情况只有这一种，格式要对应上
	val flatten = nestedList.flatten

    println(flatten)
	List(1, 2, 3, 4, 5, 6, 7, 8, 9)

11.map+扁平化 = flatmap

	//扁平化+映射 注：flatmap相当于先进行map操作，在进行flatten操作
    //集合中的每个元素的子元素映射到某个函数并返回新集合
    val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")

    val stringses = wordList.map((x:String) => x.split(" ").toList)
    println(stringses)

    val flatten1 = stringses.flatten
    println(flatten1)

    //两部合一步，直接使用flatmap
    println(wordList.flatMap(_.split(" ")))

12.分组

	//分组
    //按照指定的规则对集合进行分组
    //以什么分组  最终的结果  就是（分组元素，list（同组元素））
	val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //将1-9以奇偶来分组
    println(list.groupBy(_ % 2 == 0))

    //以对3的模的值进行分组
    println(list.groupBy(_ % 3))

13，reduce归约

	//简化（归约）
    //reduce默认使用第一个元素作为结果，之后和后面的每一个元素挨个进行归约
    //它的元素和结果是相同类型的

    //需求  归约list，最终结果是（"我是：" sum）

    val tuples = list.map(("我是：" ,_))
    println(tuples)

    //使用reduce
    val tuple = tuples.reduce((res:(String,Int),exc:(String,Int)) => (res._1,res._2 + exc._2))
    println(tuple)


  //演示左右归约  (_ + _)就是sum
    println(list.reduce(_ + _))

    println(list.reduceRight(_ + _))

    println(list.reduceLeft(_ + _))

14.带初始值的foldleft归约

val lst = List(20,30,60,90)
    //0为初始值，b表示返回结果对象（迭代值），a表示lst集合中的每个值
    val rs = lst.foldLeft(0)((b,a)=>{
      b+a
    })

	//折叠       参数带初始值的归约
    //需求  归约list，最终的结果是（"我是："，sum值）

	val list: List[Int] = List(1, 2, 3, 4, 5)
    val tuple1: (String, Int) = list.foldLeft(("我是:", 0))((res: (String, Int), elem: Int) => {
      (res._1, res._2 + elem)
    })

    println(tuple1)

    //fold和 foldleft 和foldright
    //fold在底层调用的是foldleft，但是泛型上有一点小问题，fold只支持最终的结果类型和元素类型一致
    println(list.fold(100)(_ + _))

    //foldleft在逻辑上和fold一致，都是拿一个初始值从左边开始进行归约
    println(list.foldLeft(100)(_ + _))

    //foldright逻辑比较混乱，不建议用
    println(list.foldRight(100)(_ + _))

总结：集合的运用和使用在scala中很常见，要多练习掌握