上一节，我们讲了scala的安装的即一些初步方法，今天，我们来介绍一下scala里面的一些基本操作

　　1.对于map的的编写，这个是广泛用于Array里面的

　　　　val arr = Array(1,2,3,4,5)

　　　　arr.map(_*2),则arr的数组中的每一项都*2

　　2.对于从0-9找出偶数

　　　　val arr = Array(1,2,3,4,5,6,7,8,9)

　　　　第一种:arr.filter(x=>x%2==0)

　　　　第二种:arr.filter(_%2==0)

　　　　第三种:arr.filter(_%2==0).map(_*10)：支持链式计算

　　3.在scala中，数组并不是只有一维的，也可能会有类似于Array[(String,Int)]

　　　　val arr = Array(("a",1),("b",2))

　　4.对于List来说，如果我们是加上一个元素，则可以是+=,

　　　　如果要是加上一个集合，则是++=

　　　　val list1 = List(1,2,3)

　　　　list1 += 4

　　　　val list2 = List(5,6,7,8)

　　　　list1 ++= list2

　　5.在scala中，对于import scala.collection.immutable,不可变序列，

　　　　对于import scala.collection.mutable._，可变序列

　　6.wordsCount的练习

　　　　第一步:val words = List("Hello tom hello jerry",

　　　　"Hello tom kitty","Hello")

　　　　第二步:words.map(_.split(" ")) 

　　　　　　List[Array[String]] =

　　　　　　List(Array(Hello,tom,hello,jerry),

　　　　　　Array(Hello,tom,kitty),Array(Hello))

　　　　第三步:words.map(_.split(" ")).flatten

　　　　　　List[String] = List(Hello,tom,hello,

　　　　　　jerry,Hello,tom,kitty,Hello)

　　　　或者我们可以这样想:

　　　　　　val words1 = words.flatMap(_.split(" "))

　　　　　　List[String] = List(Hello,tom,

　　　　　　hello,jerry,Hello,tom,kitty,Hello)

　　　　第四步:val wordsAndOne = words1.map((_,1))

　　　　　　wordsAndOne:List[(String,Int)]

　　　　　　=List((Hello,1),(tom,1),(Hello,1),

　　　　　　(jerry,1),(Hello,1,(tom,1),

　　　　　　(kitty,1),(Hello,1))

　　　　第五步:val grouped = wordsAndOne.groupBy(_._1)

　　　　　　grouped: scala.collection.immutable.

　　　　　　Map[String,List[(String, Int)]] =

　　　　　　Map(kitty -> List((kitty,1)),

　　　　　　tom -> List((tom,1), (tom,1)),

　　　　　　Hello -> List((Hello,1), (Hello,1), (Hello,1)),

　　　　　   hello -> List((hello,1)), jerry -> List((jerry,1)))

　　　　第六步:由于上一步的里面装的map里面是一个元组，

　　　　　　val result = grouped.map(t=>(t._1,t._2.size))

　　　　　　result：scala.collection.immutable.Map[String,Int]

　　　　　　= Map(Kitty->1,tom->2,Hello ->3,hello -> 1, jerry ->1)

　　　　第7步:对其进行排序操作(从高到低)

　　　　　　val finalResult = result.toList.sortBy(_._2).

　　　　　　reverse(因为map不支持_的操作，所以我们把它变为List)

　　　　　　finalResult：List[(String,Int)] = List((Hello,3),(tom,2),

　　　　　　(jerry,1),(hello,1),(kitty,1))

　　　　关于wordCount计数的简便写法:

　　　　　　val lines = List("hello tom hello jerry", "hello jerry",

　　　　　　"hello kitty")

　　　　　　第一种方法:lines.flatMap(_.split(" ")).map((_, 1)).

　　　　　　groupBy(_._1).

　　　　　　mapValues(_.foldLeft(0)(_+_._2))

　　　　　　第二种方法:lines.flatMap(_.split(" ")).map((_, 1)).

　　　　　　groupBy(_._1).

　　　　　　map(t=>(t._1, t._2.size)).toList.sortBy(_._2).reverse

　　7.只有List的情况下我们才可以使用_的操作，mapValues是对value的操作

　　8.foldLeft的可以进行一次相加

　　　　对于group: scala.collection.immutable.

　　　　Map[String,List[(String, Int)]]

　　　　= Map(kitty -> List((kitty,1)), tom -> List((tom,1), (tom,1)),

　　　　Hello -> List((Hello,1), (Hello,1), (Hello,1)),

　　　  hello -> List((hello,1)), jerry -> List((jerry,1)))

　　　　命令:group.mapValues(_.foldLeft(0)(_+_._2))

　　　　则之后的结果是:res34: scala.collection.immutable.

　　　　Map[String,Int]

　　　　=Map(kitty -> 1, tom -> 2, Hello -> 3, hello -> 1, jerry -> 1)

　　　　综上所述:foldLeft(0),初始值是0，从左到右一次相加

　　9.如果一个类是用private修饰，则只能在伴生对象里面访问

　　　（就是两个类的名称要一样），如果是private[this],

　　　  则这个只能在类里面使用，

　　　 就像java一样，private[test],这个是说在test以及test的

　　　子包下可以访问

　　10.scala中的构造函数也是独特

　　　　class People(val id:String,var name:String){},

　　　　此时这个就是一个构造函数

　　11.其实scala中的object是单例模式，如果是 

　　　　val d1 = Dog(), val d2 = Dog(),val d3

　　　　= new Dog(),val d4 = new Dog(),

　　　　则d1!=d2,d3!=d4.d1与d2会调用apply的方法，

　　　　其实也是相当于new了一个类，　　            

　　　　但是对于val d5= Dao，val d6= Dog,那么d5与d6就会相同，

　　　　应为默认object Dog是单例模式

scala初体验-02