scala的基础知识

scala的基础语法

object HelloWorld {
	def main(args: Array[String]): Unit = {
	//第一种变量的声明可以指定类型
	var a:Int=1;
	//改变值可以改变为同一类型不能改变为不同的类型
	a=2;
    println(a);
    //可以自动推断出你所定义的数据类型
    var b="hello"
    println(b);
    //val修饰的为常量不能随意改变
    val aa="helloWorld";
    println(aa)
    //lazy修饰的变量为延迟加载定义的时候并没有创建只有在使用的时候才会加载
    lazy val bb=1;
    println(bb);
  }
}

• scala的变量定义中推荐使用val不推荐使用var

• 不强制加分号独立的代码应该另起一行。

• {}是有返回值的，返回值就是最后一句代码的值。

• scala任何一段代码都有返回值

    var x=2;
    var y=3;
    var result:Int={if(x>y)println(x)else println(y);x-y};
    println(result);//3，-1
    println("------------------------------------");
    var result1={if(x>y) println(x) else println(y)}
    println(result1);//3，（）
  

• for循环的练习scala中不支持++，–

    object Demo_for {
    	def main(args: Array[String]): Unit = {
    			//1到10的数包含10
    			var a=1 to 10;
    			for(i<-a){
  				print(i)
    			}
    			println()
    			//1到10的数不包含10
    			var b=1 until 10;
    			for(ii<-b){
    			print(ii)
    			}
    			println()
    			var array:Array[Int]=Array(1,2,3,4,5,6,7,8,9);
    			for(a <- array){
  				print(a);
    			}
    			println()
    			//每次跨两步
    			for(c <- 0 until (array.length,2)){
    			print(c,array(c))
    			}
    		}
    	}
  

• 函数和方法的可以互相转换

    object Demo_method {
      def main(args: Array[String]): Unit = {
        val result:Int = sum(2)
        println(result)
        var result1=sum2(1,3)
        println(result1)
        //方法转换为函数
        var sum3=sum _
        println(sum3(1))
        var sum1=(x:Int)=>{x+1}
        print(sum1(4))
      }
    	//函数可以定义在main方法内
      def sum(x:Int):Int=x+1
      def sum2(x:Int,y:Int):Int=x+y
    
    }
  

• scala集合

  • 数组（Array）

    • 分成两大类定长数组和缓冲数组ArrayBuffer

    • 定长数组定义的时候带有new则表示申请一个固定长度的数组

    • 如果没有使用new其实也是在构造数组，只不过调用的是Array.apply方法

    • 变长数组转为定长数组ab.toArray

    • map函数：不停的从数组中取出循环出来一个元素x，交给参数函数作为输入，参数函数执行完成之后得到一个新的结果y，map方法的执行逻辑还会初始化一个新的同类型的定长数组作为新的数组返回容器。

    • 参数函数的接受的类型必须和array数据的类型相同，而且必须只能是一个参数不能传多个参数，参数函数返回的值得类型没有限制。

        import scala.collection.mutable.ArrayBuffer	
        object Demo_list {
          def main(args: Array[String]): Unit = {
            val array=Array(1,2,3,4)
            println(array.toBuffer)
        	//定长数组转为变长数组
            val ab=array.toBuffer
            //追加一个元素
            ab+=1
            //追加多个元素
            ab+=(1,5,4,7)
            //追加一个定长数组
            ab++=Array(4,7,8,9)
            //追加一个可变数组
            ab++=ArrayBuffer(4,8,9)
            print(ab)
        	val a = ArrayBuffer[Int](2,3,5,6,7)
            a += 1
            a.insert(0, 5)
            println(a)
            a.remove(0, 1)
            println(a)
            println(a.min)
            println(a.max)
            println(a.sum)
            val str: String = a.mkString("-")
            print(str+"\n")
            val str1: String = a.mkString("<","-",">")
            print(str1)	
        	val result = a.map((x:Int)=>x+1).mkString(",")
        	 print(result+"\n")
        	//通过reduce求这个数组的最大值
        	val result1 = a.reduce((x:Int,y:Int)=>if(x>y) x else y)
        	print(result1)		
          }		
        } 
      

    • reduce的方法用来做聚合方法参数的要求

      • 所以这个参数必定是接受多个参数，返回较少的值，一般来说就是接受两个参数返回一个值。
      • 参数函数得类型依然要和数组中的数值类型一值。
      • 返回值类型必须和输入的参数类型的返回值一致。

    • 集合（Seq序列，Set集合，Map映射）

      • val list1=List(1,2,3)

        • 可变和不可变：可变表示这个集合的元素可以被改变。

        • 不可改变则表示这个集合中的元素不可被改变。

        • 四种常用的集合List Set Map Tuple +Array

        • Lis任何一个list都是有一个头元素和尾列表组成

            object Demo_List {
              def main(args: Array[String]): Unit = {
                //头元素和尾列表
                var list=3::Nil
                println(list)
                list=4::3::Nil
                println(list)
                //把元素放前面
                val list2=1::list
                println(list2)
                //所加的元素放在后面
                val list3=list2:+4
                println(list3)
            	val empty = list3.isEmpty
            	println(empty)
            	//取集合的除了最后一个元素的其他元素
            	println(list3.init)
            	//取出集合的头元素
            	println(list3.head)
            	//取出集合的尾队列
            	println(list3.tail)
            	//取出集合的最后一个元素
            	println(list3.last)
            	//丢弃一个元素
            	println(list3.drop(1))
            	//取前面两个元素
            	println(list3.take(2))
             	val list4=List("a","b","c")
                //生成元组Tuple
                val list5: List[(Int, String)] = list3 zip(list4)
                println(list5)
                //生成map
                val map = list5.toMap
                println(map)
                println(map(1))
             	//集合转换成数组
                val array = list3.toArray
                println(array)
              }
            }
          

      • fold的用法

          package cn.tedu.scala.day02
          
          object Fold_Test {
            def main(args: Array[String]): Unit = {
              var array:Array[Int]=Array(1,2,3,4,5,6,7,8,9)
              //第一个括号z是初始值 第二个括号是聚合逻辑
              val result1: Int = array.fold(z = 0)(op=(x:Int, y:Int)=>x+y)
              val result2: Int = array.foldLeft(z = 0)(op=(x:Int, y:Int)=>{println(x,y);x+y})
              println("-----------------------")
              val result3: Int = array.foldRight(z = 0)(op=(x:Int, y:Int)=>{println(x,y);x+y})
              println(result1)
              println(result2)
              println(result3)
            }
          }
        

      • set集合最大的做用去重，求交集并集差集

          import scala.collection.immutable.HashSet
          import scala.collection.mutable
          
          object Demo_Set {
            def main(args: Array[String]): Unit = {
              val set0=new HashSet[Int]()
              println(set0)
              val set1=set0+4
              println(set0,set1)
              val set3=set1++Set(5,6,7)
              println(set3)
              val set4=Set(1,2,3,4)++set3
              println(set4)
              val set5=Set(1,2,3,4,5)
              val set6=Set(3,4,5,6,7)
              //交集
              println(set5.intersect(set6))
              //并集
              println(set5.union(set6))
              //差集只在set5中
              println(set5.diff(set6))
              val set7=new mutable.HashSet[Int]()
              val set8=set7+1
              println(set7,set8)
              set7+=1
              println(set7)
          
            }
          }
        

      • map的相关练习

      • Option父类 Some子类表示有值 None子类表示无值

      • key的值一般推荐使用不可变得元素
        import scala.collection.mutable

          /**
            * map的相关练习
            */
          object Demo_Map {
            def main(args: Array[String]): Unit = {
              val map0=mutable.HashMap("a"->1,"b"->2,"c"->3)
              println(map0("a"))
              //避免抛出异常
              println(map0.get("a"))
              //避免抛出异常做了if else判断当key不存在返回默认值
              println(map0.getOrElse("c",2))
              map0+=(("c",3),("d",4))
              println(map0)
              map0-="a"
              println(map0)
            }
          }
        

      • 元组Tuple里面的数据可以随机指定必须要小括号指定，多个元素形成一个元组

      • 经过定义之后不可变

          /**
            * 元组的相关练习
            */
          object Demo_Tuple {
            def main(args: Array[String]): Unit = {
              val t,(a,b,c,d,e)=("aa",1,5.0,true,false)
              println(t)
              //取第一个元素
              println(a)
              println(t._1)
              for (a<- 1 to 9){
                for(b<- 1 to a){
                  print(a+"*"+b+"="+a*b+"\t")
                }
                println()
              }
            }
          }