tuple
package learn04
object demo15 {
def main(args: Array[String]): Unit = {
val tuple=(1,"xwk",30)
println(tuple._1)
println(tuple._2)
println(tuple._3)
val iterator:Iterator[Any]=tuple.productIterator
println(tuple.productElement(0))
val kv:(String,Int)=("a",1)
val kv1:(String,Int)="a"->1
println(kv eq kv1)
}
}
1
xwk
30
1
false
queue
package learn04
import scala.collection.mutable
object demo16 {
def main(args: Array[String]): Unit = {
val que=new mutable.Queue[String]()
que.enqueue("a","b","c")
val que1:mutable.Queue[String]=que+="d"
println("que:"+que.mkString(","))
println("que1:"+que1.mkString(","))
println(que eq que1)
println(que.dequeue())
println(que.dequeue())
println(que.dequeue())
}
}
que:a,b,c,d
que1:a,b,c,d
true
a
b
c
parallel
package learn04
object demo17 {
def main(args: Array[String]): Unit = {
val result1=(0 to 100).map{
x=>Thread.currentThread.getName}
val result2=(0 to 100).par.map{
x=>Thread.currentThread.getName}
println(result1)
println(result2)
}
}
common method
common method
package learn04
object demo18 {
def main(args: Array[String]): Unit = {
val list=List(1,2,3,4)
println("size=>"+list.size)
println("length=>"+list.length)
println("isEmpty=>"+list.isEmpty)
println("iterator=>"+list.iterator)
list.foreach(print)
println("mkString=>"+list.mkString(","))
println("contains=>"+list.contains(2))
println("take=>"+list.take(2))
println("takeRight=>"+list.takeRight(2))
println("find=>"+list.find(x=>x%2==0))
println("drop=>"+list.drop(2))
println("dropRight=>"+list.dropRight(2))
println("reverse=>"+list.reverse)
println("distinct=>"+list.distinct)
}
}
size=>4
length=>4
isEmpty=>false
iterator=><iterator>
1234mkString=>1,2,3,4
contains=>true
take=>List(1, 2)
takeRight=>List(3, 4)
find=>Some(2)
drop=>List(3, 4)
dropRight=>List(1, 2)
reverse=>List(4, 3, 2, 1)
distinct=>List(1, 2, 3, 4)
derived collection
package learn04
object demo19 {
def main(args: Array[String]): Unit = {
val list=List(1,2,3,4)
val list1=List(1,2,3,4)
val list2=List(3,4,5,6)
println("head=>"+list.head)
println("tail=>"+list.tail)
println("tails=>"+list.tails)
println("init=>"+list.init)
println("inits=>"+list.inits)
println("last=>"+list.last)
println("union=>"+list.union(list1))
println("intersect=>"+list.intersect(list1))
println("diff=>"+list.diff(list1))
println("splitAt=>"+list.splitAt(2))
println("sliding=>"+list.sliding(2))
println("sliding=>"+list.sliding(2,2))
println("zip=>"+list.zip(list1))
println("zipWithIndex=>"+list.zipWithIndex)
}
}
head=>1
tail=>List(2, 3, 4)
tails=><iterator>
init=>List(1, 2, 3)
inits=><iterator>
last=>4
union=>List(1, 2, 3, 4, 1, 2, 3, 4)
intersect=>List(1, 2, 3, 4)
diff=>List()
splitAt=>(List(1, 2),List(3, 4))
sliding=><iterator>
sliding=><iterator>
zip=>List((1,1), (2,2), (3,3), (4,4))
zipWithIndex=>List((1,0), (2,1), (3,2), (4,3))
calculation function
package learn04
object demo20 {
def main(args: Array[String]): Unit = {
val list=List(1,2,3,4)
val list1=List(3,4,5,6)
println("min=>"+list.min)
println("max=>"+list.max)
println("sum=>"+list.sum)
println("product=>"+list.product)
println("reduce=>"+list.reduce((x:Int,y:Int)=>{
x+y}))
println("reduce=>"+list.reduce((x,y)=>{
x+y}))
println("reduce=>"+list.reduce((x,y)=>x+y))
println("reduce=>"+list.reduce(_+_))
println("reduceLeft=>"+list.reduceLeft(_+_))
println("reduceRight=>"+list.reduceRight(_+_))
println("fold=>"+list.fold(0)(_+_))
println("foldLeft=>"+list.foldLeft(0)(_+_))
println("foldRight=>"+list.foldRight(0)(_+_))
println("scan=>"+list.scan(0)(_+_))
println("scanLeft=>"+list.scanLeft(0)(_+_))
println("scanRight=>"+list.scanRight(0)(_+_))
}
}
min=>1
max=>4
sum=>10
product=>24
reduce=>10
reduce=>10
reduce=>10
reduce=>10
reduceLeft=>10
reduceRight=>10
fold=>10
foldLeft=>10
foldRight=>10
scan=>List(0, 1, 3, 6, 10)
scanLeft=>List(0, 1, 3, 6, 10)
scanRight=>List(10, 9, 7, 4, 0)
function
package learn04
object demo21 {
def main(args: Array[String]): Unit = {
val list=List(1,2,3,4)
println("map=>"+list.map(x=>{
x*2}))
println("map=>"+list.map(x=>x*2))
println("map=>"+list.map(_*2))
val list1=List(
List(1,2),
List(3,4)
)
println("flatten=>"+list1.flatten)
println("flatMap=>"+list1.flatMap(list=>list))
println("filter=>"+list.filter(_%2==0))
println("groupBy=>"+list.groupBy(_%2))
println("sortBy=>"+list.sortBy(num=>num)(Ordering.Int.reverse))
println("sortWith=>"+list.sortWith((left,right)=>{
left<right}))
}
}
map=>List(2, 4, 6, 8)
map=>List(2, 4, 6, 8)
map=>List(2, 4, 6, 8)
flatten=>List(1, 2, 3, 4)
flatMap=>List(1, 2, 3, 4)
filter=>List(2, 4)
groupBy=>Map(1 -> List(1, 3), 0 -> List(2, 4))
sortBy=>List(4, 3, 2, 1)
sortWith=>List(1, 2, 3, 4)
Case Implementation - WordCount TopN
words.txt
Hello Scala
Hello Spark
Hello Hadoop
package learn04
import scala.io.Source
object demo22 {
def main(args: Array[String]): Unit = {
val list:List[String]=Source.fromFile("./src/learn04/words.txt").getLines().toList
val wordList:List[String]=list.flatMap(_.split(" "))
val word2OneList:List[(String,Int)]=wordList.map((_,1))
val word2ListMap:Map[String,List[(String,Int)]]=word2OneList.groupBy(_._1)
val word2CountMap: Map[String, Int] = word2ListMap.map(
kv => {
(kv._1, kv._2.size)
}
)
println(word2CountMap)
}
}
Map(Hadoop -> 1, Hello -> 3, Spark -> 1, Scala -> 1)