第13章 java集合汇总

最新推荐文章于 2024-09-19 10:55:22 发布

kanbuqinghuanyizhang

最新推荐文章于 2024-09-19 10:55:22 发布

阅读量278

点赞数

分类专栏：快学scala阅读笔记文章标签： scala 快学scala scala集合

本文链接：https://blog.csdn.net/kanbuqinghuanyizhang/article/details/52319276

版权

快学scala阅读笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文详细介绍了Scala中的集合框架，包括Seq、Set和Map的不可变与可变实现，如List、Array、ArrayBuffer、Set、Map及其操作。此外，还对比了Array、List、Tuple的特性，并展示了常用操作和函数，如yield、map、sum、max、sorted等。

摘要由CSDN通过智能技术生成

###结构关系###

这里写图片描述

Seq是个有先后次序的值的序列，比如数组和链表。
　　不可变=> List、Array、Stream、Stack、Queue、Vector、Range
　　可变=>ListBuffer、ArrayBuffer、Stack、Queue、LinkedList、Double LinkedList
Set没有先后次序的值。
　　不可变=>Set
　　　可变=>Set
SortedSet可以被顺序访问
　　不可变=>SortedSet
　　　可变=>SortedSet
Map
　　不可变=>Map
　　　可变=>Map
SortedMap按照键排序访问
　不可变=>SortedMap
　　可变=>SortedMap

默认都是不可变的(import scala.collection.mutable._)，如果需要使用可变的集合，需要导入import scala.collection.mutable._

###一些比较###
#####Array、List、Tuple的区别####

在Scala 2.7中，Array、List都不能混合类型，只有Tuple可以；而在Scala以上版本中，3者的元素都可以混合不同的类型（转化为Any类型），只不过是当使用混合类型时，Array和List会将元素类型转化为Any类型,而Tuple则保留每一个元素的初始类型；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UR4m1cYR-1588843929780)(https://img-blog.csdn.net/20160825221652499)]
3. List有很多特殊的方法和属性，如方法tail 、head、：：，Nil属性等。

#####Array、ArrayBuff的比较####

Array只能可以修改里面的值，但是不能改变长度
ArrayBuff可以修改值，也可以改变长度
###使用举例###
####不可变List####

构建

1、val lst = List(1,2,3) 

//Nil是一个空的List，定义为List[Nothing]，根据List的定义List[+A]，所有Nil是所有List[T]的子类
//:: 操作符是右结合的，列表从末端开始构建，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
2、var nil = 1::2::Nil  => List(1, 2)

取值、遍历


lst(0) => 1

//head第一个元素
lst.head => 1

//tail除第一个元素外的所有元素
lst.tail =>List(2,3)

//遍历
def sum1(lst: List[Int]): Int = {
  if (lst == Nil) 0
  else lst.head + sum1(lst.tail)
}

def sum2(lst: List[Int]): Int = lst match {
  case Nil => 0
  case h :: t => h + sum2(t)
}

List(9, 4, 2).sum

操作

//将单个元素插入到lst1的前面生成一个新的List
val lst1 = 0 :: lst (或则lst1.::(0),又或者0 +: lst或则lst.+:(0))     => List(0,1,2,3)

//将单个元素添加到lst1的后面产生一个新的集合
val lst2 = lst :+ 4         => List(1,2,3,4)

val lst0 = List(4,5,6)

//将2个list合并成一个新的List
val lst3 = lst ++ lst0(或则 lst ++: lst0)   =>List(1,2,3,4,5,6)

//将lst0插入到llst后面生成一个新的集合
val lst4 = lst ::: lst0

####可变ListBuffer####

构建

import scala.collection.mutable._

//构建一个可变列表，初始有3个元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)

//创建一个空的可变列表
val lst1 = new ListBuffer[Int]

//创建一个tuple类型的可变列表
val reloation = new ListBuffer[(String, String)]

操作

//向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)

//将lst1中的元素追加到到lst0中， 注意：没有生成新的集合
lst0 ++= lst1

//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
val lst2= lst0 ++ lst1

//将元素追加到lst0的后面生成一个新的集合
val lst3 = lst0 :+ 5

//从尾部删除两个元素
buff.trimEnd(2)

//转换成数组 自己不变，产生新的数组
var _a = buff.toArray

//根据下标删除
remove(0)

####不可变Array####

构建

//初始化一个长度为8的定长数组，其所有元素均为0
val arr1 = new Array[Int](8)

//注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
//初始化一个长度为1的定长数组，值为10
val arr2 = Array[Int](10)
println(arr2.toBuffer)

//定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")

取值、遍历

//初始化一个数组
val arr = Array(1,2,3,4,5,6,7,8)

//使用()来访问元素
println(arr3(2))

//增强for循环
for(i <- arr)
  println(i)

//好用的until会生成一个Range
//reverse是将前面生成的Range反转
for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }

操作

//修改元素的值
arr(0) = 100

//通过下面方法生成新的Array，自己不变
//:+尾部追加元素
var arr2 = arr1 :+ 3

####不可变ArrayBuffer####

构建

import scala.collection.mutable.ArrayBuffer

val ab = ArrayBuffer[Int]()

操作

 //向数组缓冲的尾部追加一个元素
//+=尾部追加元素
ab += 1

//追加多个元素
ab += (2, 3, 4, 5)

//追加一个数组++=
ab ++= Array(6, 7)

//追加一个数组缓冲
ab ++= ArrayBuffer(8,9)

//在数组某个位置插入元素用insert
ab.insert(0, -1, 0) //在位置0插入-1和0两个元素

//删除数组某个位置的元素用remove
ab.remove(8, 2)//从下标8中删除2个元素

//转换成数组 自己不变，产生新的数组
var _a = buff.toArray

####Set####

构建

//不可变
val set = Set(1, 2, 3, 1, 5)

//可变
val m_set = scala.collection.mutable.Set[Int]()

val ab = ArrayBuffer[Int]()

可变操作

set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)

//删除一个元素
set1 -= 5
set1.remove(2)

####Map####

构建

//可变、不可变
// 空哈希表，键为字符串，值为整型 
var A:Map[Char,Int]=Map()

val map = Map("CHII"->11, "PLR"->12)

val map = Map(("CHII", 11), ("PLR", 12))

取值、遍历

//没有对应的key会报错
map("CHII") 

//返回Option类型
map.get("CHII") 

//为None时返回默认值
map.getOrElse("HH", 18) 

map.keys

map.values

valm = Map(("a", 1), ("b", 2))

m.map{case (k, v) => k}

m.map(t=>(t._1, t._2))

for ((k, v) <- mutmap) {
    println("key:" + k + "val:" + v)
}

//只遍历key
for ((k, _) <- mutmap) {
    println("key:" + k)
}

//只遍历val
for ((_, v) <- mutmap) {
    println("val:" + v)
}

操作

//+操作原来的map不变，只是产生新的Map
val newmap = mutmap + ("LILY"->11)

//修改值
mutmap("CHII") = 10

//+=
mutmap += ("MINE"->123)
mutmap += (("MINER", 123))//注意：两个括号

//从map中移除元素
map1 -= "CHII"
map1.remove("LILY")

//val代表引用不可变，但值能变，所以还是能操作map("CHII") = 10
val map = Map("CHII"->11, "PLR"->12)

####常用函数####

yield map

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-emX92GUI-1588843929788)(https://img-blog.csdn.net/20160825225535963)]

sum max sorted head tail
head：取第一个元素
tail：取除第一个元素外的所有元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bUNb7Py8-1588843929789)(https://img-blog.csdn.net/20160825225825087)]

sorted多种使用方式

//数据
var arr = Array(1,4,6,3,2,9,4,10)

//sorted
//默认按升序排序
arr.sorted => Array(1, 2, 3, 4, 4, 6, 9, 10)

//没有arr.sorted(True|Fasle)这种写法--那么加上reverse就行了
arr.sorted.reverse => Array(10, 9, 6, 4, 4, 3, 2, 1)

//sortWith
arr.sortWith(_>_) => Array(10, 9, 6, 4, 4, 3, 2, 1)
arr.sortWith(_<_) => Array(1, 2, 3, 4, 4, 6, 9, 10)


arr.sortWith((x, y) => x < y) => Array(1, 2, 3, 4, 4, 6, 9, 10)
arr.sortWith((x, y) => x > y) => Array(1, 2, 3, 4, 4, 6, 9, 10)

//Ordering sortBy  不能带参数True|False来指定顺序还是倒序，排完序后可以使用reverse运转一次
import scala.math.Ordering
import scala.util.Sorting

/**
  * Describe:   
  * Author:  JerryChii.
  * Date:    2016/4/10
  */

case class OrderPerson(name:String, age:Int)
object AgeOrdering extends Ordering[OrderPerson] {
  def compare(a:OrderPerson, b:OrderPerson) = a.age compare b.age
}

object OrderingTest extends App{
  //自定义类字段排序
  val people = Array(OrderPerson("bob", 30), OrderPerson("ann", 32), OrderPerson("carl", 19))
  Sorting.quickSort(people)(AgeOrdering)
  println(people.toBuffer)

  /**************sortBy***************/
  //def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = sorted(ord on f)
  val arr = Array((1, 3), (2, 3))
  //ArrayBuffer(OrderPerson(carl,19), OrderPerson(bob,30), OrderPerson(ann,32))
  arr.sortBy(_._2)


  //def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = sorted(ord on f)
  val words = "The quick brown fox jumped over the lazy dog".split(' ')
  // this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
  var word = words.sortBy(x => (x.length, x.head))
  println(word.toBuffer)
  //res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

###操作总结###
####添加或去除的操作####
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HgvNSqo0-1588843929796)(https://img-blog.csdn.net/20160825225052122)]
####Iterable特质的重要方法：这里没有具体分哪些子类（Seq（List、Array等）、Set）等的方法，在使用中总结吧####
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QDEKnnNT-1588843929797)(https://img-blog.csdn.net/20160825225133733)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7R5EOXPL-1588843929799)(https://img-blog.csdn.net/20160825225202634)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7WBSFUg5-1588843929804)(https://img-blog.csdn.net/20160825225229187)]
####Seq特质的重要方法####
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3KdvH23L-1588843929805)(https://img-blog.csdn.net/20160825225314244)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HdCx7ZXa-1588843929808)(https://img-blog.csdn.net/20160825225330322)]
###参考链接###
[1]http://my.oschina.net/u/1034176/blog/512314