Scala里面的集合操作练习

++

合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。类型返回已左侧为准

val a = Array(1,2,3)
val b = Array(5,6,7)
val c = a ++ b
println(c.toList)
//List(1, 2, 3, 5, 6, 7)

++:

合并集合，右面操纵数的类型决定着返回结果的类型

val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass.getName)
println(c)
//scala.collection.mutable.LinkedList
//LinkedList(1, 2, 3, 4)

+：和 :+

在数组集合的前后添加元素，并返回新的集合对象

val a = List(1,2)
    val c = 0 +: a
    println(c)
    // List(0, 1, 2)
    val b = c :+ 0
    println(b)
    // List(0, 1, 2, 0)

addString() 和 StringBuilder()

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b)            //将数组中的元素逐个添加到 b 可变的字符串中
println(c)
// 1234

val d = a.addString(b,"%")          //每个元素用分隔符(sep)分开
println(d)
// 1%2%3%4

val e = a.addString(b,"{","%","}")  //在首尾各加一个字符串，并指定元素间分隔符(sep)
println(e)
// {1%2%3%4}

mkString

将所有元素组合成一个字符串

val a = List(1,2,3,"hei","ha")
    println(a.mkString)
    println(a.mkString(","))     //将所有元素组合成一个字符串，设定元素间的分隔符（sep）
    println(a.mkString("{","@","}"))  //将所有元素组合成一个字符串，设置元素的开头、结尾、元素间的分隔符
    //123heiha
    //1,2,3,hei,ha
    //{1@2@3@hei@ha}

aggregate

聚合计算，aggregate是柯里化函数
参数是两个方法，为了方便理解，把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来

代码举例：

 def seqnum(m:Int,n:Int):Int={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
 def combine(m:Int,n:Int): Int ={
    val s = "com_exp = %d + %d"
    println(s.format(m,n))
    return m+n
  }
  
 val a = List(1,2,3,4,5)
 val c = a.aggregate(5)(seqnum,combine)      //5为初始值，只会调用seqnum方法
 val b = a.fold(5)(seqnum) 				//效果相同
 println(c)
 //输出结果:
	// seq_exp=5+1
	// seq_exp=6+2
	// seq_exp=8+3
	// seq_exp=11+4
	// seq_exp=15+5
	// 20
 val d = a.par.aggregate(5)(seqnum,combine)  //两个方法都会调用，先做完seqnum方法结束后，再调用combine操作
 println(d)
 //输出结果(没有顺序)：
 	seq_exp=5+4
	seq_exp=5+1
	seq_exp=5+5
	seq_exp=5+3
	seq_exp=5+2
	com_exp = 9 + 10
	com_exp = 6 + 7
	com_exp = 8 + 19
	com_exp = 13 + 27
	40

上述代码可直接简写为：

val c = a.aggregate(5)(_+_,_+_)
val d = a.par.aggregate(5)(_+_,_+_)
println(c)
println(d)

//输出结果:
20
40

canEqual

def canEqual(that: Any): Boolean判断两个对象是否可以进行比较

charAt

def charAt(index: Int): Char 获取索引处字符
方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生

val chars = Array('a','b','c')
    println("c:"+chars.charAt(0))  
//结果 a

clone

def clone(): Array[T] 创建一个副本

val chars = Array('a','b','c')
    val newchars = chars.clone()

collect

def collect[B](pf: PartialFunction[A, B]): Array[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象，举例：

val chars = Array('a','b','c','x')
    val newchars = chars.collect(fun)
    println(newchars.toList)
//List(A, b, c, x)

val fun:PartialFunction[Char,Char]={
    case 'a' => 'A'						//a 转换为 A
    case x => x
  }

collectFirst

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

val arr = Array('a',"b",2)
    val value = arr.collectFirst(fun)
    println("value:" + value)
    //value:Some(200)

//定义偏函数, 要求当被执行对象为Int类型时，进行乘100的操作
val fun:PartialFunction[Any,Int] = {
    case x:Int => x*100
  }

val arr = Array('a',"b",2)
val value1 = arr.collectFirst({case x:Int => x*100})
    println("value:"+ value1)
    //value:Some(200)

combinations

def combinations(n: Int): collection.Iterator[Array[T]]
排列组合，这个排列组合会选出所有包含字符不一样的组合，参数n表示序列长度，就是几个字符为一组
例如：

 val arr1 = List("a","b","c")
    val newarr1 = arr1.combinations(2)
    newarr1.foreach((item) => println(item.mkString(",")))
// a,b
   a,c
   b,c

contains

def contains[A1 >: A](elem: A1): Boolean 序列中是否包含指定对象

containsSlice

def containsSlice[B](that: GenSeq[B]): Boolean 判断当前序列中是否包含另一个序列

 val a = List(1,2,3,4)
  	val b = List(2,3)
  	println(a.containsSlice(b))
 // true

copyToArray

def copyToArray(xs: Array[A]): Unit 复制一个数组中的元素到另一个数组中
另外两种方法：
copyToArray(xs: Array[A], start: Int): Unit
copyToArray(xs: Array[A], start: Int, len: Int): Unit

val a = Array('a', 'b', 'c')
   val b : Array[Char] = new Array(5)
   a.copyToArray(b)   	 	/**b中元素 ['a','b','c',0,0]*/
   a.copyToArray(b,1)  		/**b中元素 [0,'a',0,0,0]*/
   a.copyToArray(b,1,2)     /**b中元素 [0,'a','b',0,0]*/

copyToBuffer

def copyToBuffer[B >: A](dest: Buffer[B]): Unit 将数组中的内容拷贝到Buffer中

import scala.collection.mutable.ArrayBuffer
   val a = Array('a', 'b', 'c')
   val b:ArrayBuffer[Char]  = ArrayBuffer()
   a.copyToBuffer(b)
   println(b)
// ArrayBuffer(a, b, c)

corresponds

def corresponds[B](that: GenSeq[B])(p: (T, B) => Boolean): Boolean
判断两个序列长度以及对应位置元素是否符合某个条件。
如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

//检查 a 和 b长度是否相等，并且a中元素是否小于b中对应位置的元素
val a = Array(1, 2, 3)
  	val b = Array(4, 5, 6)
 	println(a.corresponds(b)(_<_)) 
 //true

count

def count(p: (T) => Boolean): Int 统计符合条件的元素个数

    val a = Array(1, 2, 3)
	    println(a.count({x:Int => x > 2})) 
	// count = 1

diff

def diff(that: collection.Seq[T]): Array[T]
计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

val a = Array(1, 2, 3, 4)
    val b = Array(4, 5, 6, 7)
    val c = a.diff(b)
    println(c.mkString) 
	// 1,2,3

distinct

def distinct: Array[T] 去除当前集合中重复的元素，只保留一个

val a = Array(1, 2, 3,4,4,5,6,6)
 	val c = a.distinct
 	println(c.mkString(","))   
// 1,2,3,4,5,6

drop

def drop(n: Int): Array[T] 将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1, 2, 3, 4)
   val c = a.drop(2)
   println(c.mkString(","))  
   // 3,4

dropRight

def dropRight(n: Int): Array[T] 功能同 drop，去掉尾部的 n 个元素

dropLeft

def dropWhile(p: (T) => Boolean): Array[T] 去除当前数组中符合条件的元素
前提条件：从当前数组的第一个元素起，就要满足条件，
直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

 val a = Array(3, 2, 3,4)
	 val c = a.dropWhile( {x:Int => x > 2} )
	 println(c.mkString(","))
	 // 2,3,4
val a = Array(1, 2, 3,4)
	val c = a.dropWhile( {x:Int => x > 2} )
	println(c.mkString(","))
	//第一个元素就不满足，所以返回整个数组 1,2,3,4

endsWith

def endsWith[B](that: GenSeq[B]): Boolean 判断是否以某个序列结尾

val a = Array(3, 2, 3, 4)
	    val b = Array(3,4)
	    println(a.endsWith(b))  
	    //true

exists

def exists(p: (T) => Boolean): Boolean 判断当前数组是否包含符合条件的元素

val a = Array(3, 2, 3,4)
	     println(a.exists( {x:Int => x==3} ))
	     // true
	     println(a.exists( {x:Int => x==20} ))
	     // false

map

def map[B](f: (A) => B): Array[B] 对序列中的元素进行 f 操作

  val a = Array(1, 2, 3, 4, 5)
	    val b = a.map( {x:Int => x*10})
	    println(b.mkString(","))    
	    // 10,20,30,40,50

groupBy

def groupBy[K](f: (T) => K): Map[K, Array[T]]
按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列
把小于3的数字放到一组，大于3的放到一组，返回Map[String,Array[Int]]

    val a = Array(1, 2, 3,4)
	    val b = a.groupBy( x => x match {
	      case x if (x < 3) => "small"
	      case _ => "big"
	    })

flatMap

def flatMap[B](f: (A) => GenTraversableOnce[B]): Array[B]
对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

val a = Array(1, 2, 3,4)
	    val b = a.flatMap(x=>1 to x)
	    println(b.mkString(","))
	 /**
		1,1,2,1,2,3,1,2,3,4
		从1开始，分别于集合a的每个元素生成一个递增序列，过程如下
		1
		1,2
		1,2,3
		1,2,3,4
	 */

reduce

def reduce[A1 >: A](op: (A1, A1) => A1): A1 同 fold，不需要初始值

val a = Array(1,2,3,4,5)
	  val b = a.reduce(seqno)
	  println(b)    // 15
	  /**
	    seq_exp=1+2
	    seq_exp=3+3
	    seq_exp=6+4
	    seq_exp=10+5
	  */

（30）求单词个数

val words = List("hello world","ni hao" ,"how are you ni hao")
    val wc = words.map(x=> x.split(" ")).flatMap(x=>x).map(x=>(x,1))
      .groupBy(x=>x._1).map(x=>(x._1,x._2.map(x=>x._2).reduce(_+_)))
    println(wc)
// Map(are -> 1, world -> 1, you -> 1, ni -> 2, how -> 1, hao -> 2, hello -> 1)