|--com
     |--xzj
          |--process
               |--Main.scala
               |--NAStatsCounter.scala

首先，确保安装了Java 8 JDK。
要检查，请打开终端并键入：
java -version（确保您拥有1.8版本。）
（如果您没有安装它，请在此处下载Java。）

然后，安装Scala：
通过安装诸如IntelliJ的IDE或sbt，Scala的构建工具。

如果您熟悉命令行，则最好；下载SBT
在命令行上使用Scala和sbt入门
在命令行上使用sbt和ScalaTest测试Scala

1. Scala的安装

   1.环境变量
   1.官网下载scala：https://www.scala-lang.org/download/all.html
   2.解压zip或双击msi包
   查看版本号scala -version

2.开发环境
方法一：
       1.下载scala插件（对应eclipse版本）：http://scala-ide.org/download/prev-stable.html
       2.解压zip，将features和plugins文件夹拷贝到eclipse安装目录下的dropins/scala。若没有该目录，自行创建
       
   方法二：
       西在Scala IDE：http://scala-ide.org/download/sdk.html
   方法三：
       1.安装IDEA
       2.打开IDEA，点击Configure->Plugins，搜索Scala，点击Install安装
       3.设置JDK，点击Configure->Project Defaults->Project Structure
       4.创建Scala项目，点击Create New Project->Scala->Scala。
   5.更改SDK版本号，点击Browse，选择本地安装的Scala目录，选择System
   

/**
 * 变量：用var定义，可修改
 * 常量：用val定义，不可修改
 * /
var age = 10
val name = "zhangsan"

class Person{
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    "my name is "+ name
  }

object Lesson_Class {
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.sayName())
  }
}

伴生类和伴生对象

class Person(xname :String , xage :Int){
  var name = Person.name
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
  def sayName() = {
    "my name is "+ name
  }
}
object Person {
  val name = "zhangsanfeng"
  def main(args: Array[String]): Unit = {
    val person = new Person("wagnwu",10,"f")
    println(person.age);
    println(person.sayName())
    println(person.gender)
  }
}

val age =18 
if (age < 18 ){
	println("no allow")
}else if (18<=age&&age<=20){
	println("允许与其他")
}else{
	println("允许自我")
	}

/**
 * 1 to 10 返回1到10的Range数组，包含10
 * 1 until 10 返回1到10 Range数组 ，不包含10
 */

println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
res10: scala集合不可变范围包含= Range 1 to 10
res10: scala.collection.immutable.Range.Inclusive 


println(1.to(10))//与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9
println(1.to(10, 2)) 

println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
println(1.until(10))//与上面等价
println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

/**
 * for 循环
 * scala中 不能写count++ count-- 只能写count+
 */
for( i <- 1 to 10 ){
  println(i)
}
/**
* 多层for循环
 * 可以分号隔开，写入多个list赋值的变量，构成多层for循环
 * /
//例子： 打印小九九
for(i <- 1 until 10 ;j <- 1 until 10){
  if(i>=j){
	  print(i +" * " + j + " = "+ i*j+"	")
  }
  if(i==j ){
    println()
  }
}
 /**
 * 可以在for循环中加入条件判断
 * /
for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
  println(i)
}
/**
 * 将for中的符合条件的元素通过yield关键字返回成一个集合
 */
 val list = for(i <- 1 to 10  ; if(i > 5 )) yield i

/**
 * while 循环
 */
var index = 0 
while(index < 100 ){
	println("第"+index+"次while 循环")
  index += 1 
}
index = 0 
do{
	index +=1 
	println("第"+index+"次do while 循环")
}while(index <100 )

/**
 * Scala函数的定义
 */
def fun (a: Int , b: Int ) : Unit = {
   println(a+b)
 }
fun(1,1)
    
def fun1 (a : Int , b : Int)= a+b
    println(fun1(1,2))  

   /**
     * 包含默认参数值的函数
     */
    def fun3(a :Int = 10,b:Int) = {
      println(a+b)
    }
    fun3(b=2)

    /**
     * 匿名函数
     * 注意：
     * 可以将匿名函数返回给定义的一个变量
     */
    //有参数匿名函数
    val value1 = (a : Int) => {
      println(a)
    }
    value1(1)
    //无参数匿名函数
    val value2 = ()=>{
      println("我爱Angelababy")
    }
    value2()
    //有返回值的匿名函数
    val value3 = (a:Int,b:Int) =>{
      a+b
    }
    println(value3(4,4)) 

    /**
     * 嵌套函数
     * 例如：嵌套函数求5的阶乘
     */
    def fun5(num:Int)={
      def fun6(a:Int,b:Int):Int={
        if(a == 1){
          b
        }else{
          fun6(a-1,a*b)
        }
      }
      fun6(num,1)
    }
    println(fun5(5))

    /**
     * 偏应用函数
     */
    def log(date :Date, s :String)= {
      println("date is "+ date +",log is "+ s)
    }
    
    val date = new Date()
    log(date ,"log1")
    log(date ,"log2")
    log(date ,"log3")
    
    //想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
    val logWithDate = log(date,_:String)
    logWithDate("log11")
    logWithDate("log22")
    logWithDate("log33")

/**
 * 高阶函数
 */
//函数的参数是函数
def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
  f(a,100)
}
def f(v1 :Int,v2: Int):Int  = {
  v1+v2
}
println(hightFun(f, 1))
//函数的返回是函数
//1，2,3,4相加
def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
  def f2 (v1: Int,v2:Int) :Int = {
    v1+v2+a+b
  }
  f2
}
println(hightFun2(1,2)(3,4))
//函数的参数是函数，函数的返回是函数
def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
  f
} 
println(hightFun3(f)(100,200))
println(hightFun3((a,b) =>{a+b})(200,200))
//以上这句话还可以写成这样
//如果函数的参数在方法体中只使用了一次 那么可以写成_表示
println(hightFun3(_+_)(200,200))

   /**
     * 柯里化函数
     */
    def fun7(a :Int,b:Int)(c:Int,d:Int) = {
      a+b+c+d
    }
    println(fun7(1,2)(3,4))

    /**
     * String && StringBuilder
     */
    val str = "abcd"
    val str1 = "ABCD"
    
    println(str.indexOf(97))
    println(str.indexOf("b"))

    println(str==str1)
    /**
     * compareToIgnoreCase
     * 
     * 如果参数字符串等于此字符串，则返回值 0；
     * 如果此字符串小于字符串参数，则返回一个小于 0 的值；
     * 如果此字符串大于字符串参数，则返回一个大于 0 的值。
     * 
     */
    println(str.compareToIgnoreCase(str1))
    
    val strBuilder = new StringBuilder
    strBuilder.append("abc")
//    strBuilder.+('d')
    strBuilder+ 'd'
//    strBuilder.++=("efg")
    strBuilder++= "efg" 
//    strBuilder.+=('h')
    strBuilder+= 'h' 
    strBuilder.append(1.0)
    strBuilder.append(18f)
    println(strBuilder)

    /**
     * 遍历两种方式
     */
    for(i <- arr1){
    	  println(i)
    }
    arr1.foreach(i => {
      println(i)
    })
    for(s <- arr2){
      println(s)
    }
    arr2.foreach { 
      x => println(x) 
    }

/**
 * 创建二维数组和遍历
 */
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i <- 0 until arr3.length){
  for(j <- 0 until arr3(i).length){
    print(arr3(i)(j)+"	")
  }
  println()
}

var count = 0
for(arr <- arr3 ;i <- arr){
  if(count%3 == 0){
    println()
  }
  print(i+"	")
  count +=1 
}

arr3.foreach { arr  => {
  arr.foreach { println }
}}

val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {
  arr.foreach(i => {
    println(i)
  })
}}
println("-------")
for(arr <- arr4;i <- arr){
  println(i)
} **2.List**

    //创建
    val list = List(1,2,3,4,5)
    
    //遍历
    list.foreach { x => println(x)}
//    list.foreach { println}
	/**
	 * list方法
	 */
    //filter
    val list1  = list.filter { x => x>3 }
    list1.foreach { println}
    
    //count
    val value = list1.count { x => x>3 }
    println(value)
    
    //map
    val nameList = List(
    		"hello bjsxt",
    		"hello xasxt",
    		"hello shsxt"
        )
    val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
    mapResult.foreach{println}    
    
    //flatmap
    val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
    flatMapResult.foreach { println }

//创建 
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍历
//注意：set会自动去重
set1.foreach { println}
   for(s <- set1){
      println(s)
    }
    println("*******")

   /**
    * Set方法举例
    */    
   //交集
   val set3 = set1.intersect(set2)
   set3.foreach{println}
   val set4 = set1.&(set2)
   set4.foreach{println}
   println("*******")
   //差集
   set1.diff(set2).foreach { println }
   set1.&~(set2).foreach { println }
   //子集
   set1.subsetOf(set2)
   //最大值
   println(set1.max)
   //最小值
   println(set1.min)
   println("****")
   //转成数组，list
   set1.toArray.foreach{println}
   println("****")
   set1.toList.foreach{println}
   //mkString
   println(set1.mkString)
   println(set1.mkString("\t"))

val map = Map(
  "1" -> "bjsxt",
  2 -> "shsxt",
  (3,"xasxt")
)

println(map.get("1").get)
// getOrElse：如果map中没有对应项，赋值为getOrElse传的值
val result = map.get(8).getOrElse("no value")
println(result)

//遍历key
val keyIterable = map.keys
keyIterable.foreach { key => {
  println("key:"+key+", value:"+map.get(key).get)
} }
println("---------")

//遍历key
val keyIterable = map.keys
keyIterable.foreach { key => {
  println("key:"+key+", value:"+map.get(key).get)
} }
println("---------")

//遍历value
val valueIterable = map.values
valueIterable.foreach { value => {
  println("value: "+ value)
} }

/**
 * 合并map
 * ++   例：map1.++(map2)     map1中加入map2
 * ++:  例：map1.++:(map2)    map2中加入map1
 */
val map1 = Map(
  (1,"a"),    
  (2,"b"),    
  (3,"c")    
)
val map2 = Map(
  (1,"aa"),
  (2,"bb"),
  (2,90),
  (4,22),
  (4,"dd")
)
map1.++:(map2).foreach(println)     

//count
val countResult  = map.count(p => {
  p._2.equals("shsxt")
})
println(countResult)
//filter
map.filter(_._2.equals("shsxt")).foreach(println)
//contains：map中是否包含某个key
println(map.contains(2))
//exist：符合条件的记录存在不存在
println(map.exists(f =>{
  f._2.equals("Angelababy")
}))

/**
 * 创建，最多支持22个
 * 可以使用new，可以不适用new
 */
val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

//使用
//取值用"._XX"可以获取元组中的值
println(tuple2._1 + "\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
println(t._1._2)

//遍历
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
  println(tupleIterator.next())
}

//翻转，只针对二元组
println(tuple2.swap)
//toString
println(tuple3.toString())

object Lesson_Match {
  def main(args: Array[String]): Unit = {
    val tuple = Tuple6(1,2,3f,4,"abc",55d)
    val tupleIterator = tuple.productIterator
    while(tupleIterator.hasNext){
      matchTest(tupleIterator.next())
    }
  }
  def matchTest(x:Any) ={
    x match {
      case x:Int=> println("type is Int")
      case 1 => println("result is 1")
      case 2 => println("result is 2")
      case 3=> println("result is 3")
      case 4 => println("result is 4")
      case x:String => println("type is String")
//      case x :Double => println("type is Double")
      case _ => println("no match")
    }
  }
}

case class Person1(name:String,age:Int)

object Lesson_CaseClass {
  def main(args: Array[String]): Unit = {
    val p1 = new Person1("zhangsan",10)
    val p2 = Person1("lisi",20)
    val p3 = Person1("wangwu",30)
    
    val list = List(p1,p2,p3)
    list.foreach { x => {
      x match {
        case Person1("zhangsan",10) => println("zhangsan")
        case Person1("lisi",20) => println("lisi")
        case _ => println("no match")
      }
    } }
  }
}

 //========================隐式值==============================
def sayName(implicit name:String) = {
  println("say love to " + name)
}

implicit val name = "fanbingbing"
/**
 * not enough arguments for method sayName: (implicit name: String)Unit. Unspecified value parameter name.
 */

/**
 * ambiguous implicit values: both value a of type String and value name of type String match expected type String
 * 隐式转换必须满足无歧义规则
 * 在同一个作用域禁止声明两个类型一致的变量，防止在搜索的时候会犹豫不决
 * 声明隐式参数的类型最好是自定义的数据类型，不要使用Int,String这些常用类型，防止碰巧冲突
 */
//    implicit val a = "hhh"
sayName
/**
 * 将name变量声明为implicit，编译器在执行sayName方法时发现缺少一个String类型的参数，此时会搜索作用域内类型为String的隐式值
		 并且将搜索到的隐式值作为sayName的参数值
 */

官网
http://www.scala-lang.org/download/
Scala学习笔记
https://www.jianshu.com/p/c16e0fae6ea2