Scala光速入门之Scala的基本语法、Array、Map、Tuple等

首先很高兴能成为王老师3000门徒之一,在新年第一天第一课《Scala光速入门》就长达三个小时,在这三个小时的时间里面,整体上感觉难度不是很大,但由于前期没有准备Scala环境,仅仅听导致效率很低,导致中间大半个小时基本上收获比较低,今天上午我把Scala环境搭建完毕,也把spark源码下载下来,后面紧跟着王老师的脚步,提高上课效率,课后及时复习;

第一课主要讲的内容总结如下:

1,scale基于JVM,scale可以调用java所有方法和接口

2,scale是完全面向对象(一切皆对象,一切对象都有方法),

3,scale实现代码量是java的五分之一或者十分之一;

4,王老师推荐使用Scale 2.10.4版本;

5,Val 至关重要,不希望数据改变,就是用val,初步达到目标

scala> val rsult = 2+10
rsult: Int = 12
scala> rsult = 13
:12: error: reassignment to val
       rsult = 13
             ^

6,Scala支持的基本数据类型,如果你是个Java程序员,你会发现Java支持的基本数据类型,Scala都有对应的支持,不过Scala的数据类型都是对象(比如整数),这些基本类型都可以通过隐式自动转换的形式支持比Java基本数据类型更多的方法

scala> 1+2
res13: Int = 3
scala> 1.5+2
res14: Double = 3.5

7,TAB快捷键的作用,输入一部分内容,按Tab键可以快捷查询

scala> res14.is
isInfinite     isNaN           isValidByte   isValidShort
isInfinity     isNegInfinity   isValidChar   isWhole
isInstanceOf   isPosInfinity   isValidInt


8,_用法

scala中与_相关的用法还是挺多的:
1 import导入包的所有成员,相当于java的*,而*在scala中可以作为合法的identifier。比java方便的一点是它可以导入某个类下的所有静态成员,java则需要import static。
2 占位符:这个用法比较多,表示某一个参数。比如对collection或sequence调用方法map、filter、sortWith、foreach等等表示对每一个元素进行处理,甚至可以使用 _.XXX 方式;还有参数推导时f(250*_),假设已知f的参数类型是Int=>Int的函数类型时,可以在匿名函数中250*_使用_表示Int 参数,还比如val f = 250 * (_: Int);在模式匹配中根据unapply来初始化变量或集合时,如果不关心变量的某个具体属性或集合的某些元素则使用_来忽略,比如val Array(first, second, _*) = arr,只将arr的前2个值分别赋给first和second,这在match case class中用得比较多。
3 对变量进行默认初始化,比如var i:Int=_
4 访问tuple变量的某个元素时通过索引_n来取得第n个元素
5 向函数或方法传入可变参数时不能直接传入Range或集合或数组对象,需要使用:_*转换才可传入
6 类的setter方法,比如类A中定义了var f,则相当于定义了setter方法f_=,当然你可以自己定义f_=方法来完成更多的事情,比如设置前作一些判断或预处理之类的操作
7 用于将方法转换成函数,比如val f=sqrt _,以后直接调用f(250)就能求平方根了

scala> min(20,4) :12: error: not found: value min min(20,4) ^                                   

scala> import scala.math._
import scala.math._

scala> min(20,4)
res16: Int = 4

9,数组,访问使用(),而不像Java中的[]

scala> Array(1,2,3,4)
res17: Array[Int] = Array(1, 2, 3, 4)

scala> val array = Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

scala> array
res18: Array[Int] = Array(1, 2, 3, 4)

scala> Array(1,2,3,4)
res17: Array[Int] = Array(1, 2, 3, 4)

scala> val array = Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

scala> array
res18: Array[Int] = Array(1, 2, 3, 4)

scala> res18.apply(0)
res19: Int = 1

scala> res18.apply(0,1,2)
:17: error: too many arguments for method apply: (i: Int)Int in cla
rray
       res18.apply(0,1,2)
                  ^
scala> var array = Array.apply(0,1,2)
array: Array[Int] = Array(0, 1, 2)

scala> val arr = new Array[Int](5)
arr: Array[Int] = Array(0, 0, 0, 0, 0)

scala> arr(3)
res21: Int = 0

scala> arr(2)=8

scala> arr
res23: Array[Int] = Array(0, 0, 8, 0, 0)

scala> arr.apply(2)
res24: Int = 8


10,ArrayBuffer

scala> val arrBuffer = ArrayBuffer[int]()
:14: error: not found: value ArrayBuffer
       val arrBuffer = ArrayBuffer[int]()
                       ^
:14: error: not found: type int
       val arrBuffer = ArrayBuffer[int]()
                                   ^

scala> import scala.collection.mutable.Array
ArrayBuffer    ArrayLike   ArraySeq
ArrayBuilder   ArrayOps    ArrayStack

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val arrBuffer = ArrayBuffer[Int]()
arrBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> arrBuffer +=(11,1,3,4,5)
res25: arrBuffer.type = ArrayBuffer(11, 1, 3, 4, 5)

scala> arrBuffer
res26: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(11, 1, 3, 4, 5)

scala> arrBuffer.trim
trimEnd   trimStart

scala> arrBuffer.trimEnd(3)

scala> arrBuffer
res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(11, 1)


11,移除一个数组中第一个负数以后的负数

 

    val array = ArrayBuffer[Int]()
    array +=(8,3,4,5,-15,8,-2,-100)
    var firstNegative = false
    var length = array.length
    var indexed = 0
    while(indexed < length)
    {
      if (array(indexed) >=0) {
        indexed +=1
      } else{
        if (!firstNegative) 
        {
          firstNegative = true;
          indexed +=1
         } else {
           array.remove(indexed);
           length -=1
         }
          
      }
      
      println(array)
    }
    
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -2, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8, -100)
ArrayBuffer(8, 3, 4, 5, -15, 8)

12,

    val n =10
    def f1:Any = {
      for(i<-1 to 10)
      {
        if(i == n)
          return i
        println(i)
      }
    }
    f1
结果:

1
2
3
4
5
6
7
8
9



补充(转自 http://www.cppblog.com/abilitytao/archive/2014/10/04/208489.aspx)

scala中的数组比java的数组强大很多   
    1、定长数组:长度不变的数组Array,如:声明一个长度为10的整形数组,val arr = Array[Int](10);声明并初始化一个字符串数组: val arrStr = Array(“wo”,”cha”,”yo”)。访问数组方式:访问arrStr第一个元素,arrStr(1)即可
    2、变长数组(即数组缓冲):java中有ArrayList和scala中的ArrayBuffer等效;但是ArrayBuffer更加强大,通过下面的事列来熟悉ArrayBuffer:
import collection.mutable.ArrayBuffer
    val arrbuff1 = ArrayBuffer[Int]()
    val arrBuff2 = ArrayBuffer(1,3,4,-1,-4)
    arrbuff1 += 23    //用+=在尾端添加元素
    arrbuff1 += (2,3,4,32) //同时在尾端添加多个元素
    arrbuff1 ++= arrBuff2 //可以用 ++=操作符追加任何集合
    arrbuff1 ++= Array(2,43,88,66)
    arrbuff1.trimEnd(2) //移除最后的2个元素
    arrbuff1.remove(2)  //移除arr(2+1)个元素
    arrbuff1.remove(2,4) //从第三个元素开始移除4个元素
    val arr = arrbuff1.toArray //将数组缓冲转换为Array
    val arrbuff2 = arr.toBuffer //将Array转换为数组缓冲
    3、遍历数组和数组缓冲:在java中数组和数组列表/向量上语法有些不同。scala则更加统一,通常情况,我们可以用相同的代码处理这两种数据结构,for(…) yield 循环创建一个类型和原集合类型相同的新集合。for循环中还可以带守卫:在for中用if来实现。
    for(i <- 0 until arrbuff1.length) yield arrbuff1(i) * 2 //将得到ArrayBuffer(2,6,4,-2,-4)
    for(i <- 0 until (arrbuff1.length,2)) yield arrbuff1(i) * 2 //将得到ArrayBuffer(12,-4)
    for(elem <-0 arrbuff1) print(elem) //如果不需要使用下标,用这种方式最简单了
    for(i <- arrbuff1 if arrbuff1 > 0) print i //打印出arrbuff1中为整数的值
    arrbuff1.filter( _ > 0).map{ 2 * _} //生成arrbuff1中的正数的两倍的新集合
    arrbuff1.filter {_ > 0} map {2 * _} //另一种写法
    4、常用算法:scala有很多便捷内建函数,如
    arrbuff1.sum //对arrbuff1元素求和
    Array("asd","sdf","ss").max //求最大元素
    arrbuff1.sorted(_ < _)  //将arrbuff1元素从小到大排序
    arrbuff1.sorted(_ > _)  //从大到小排序
    util.Sorting.quickSort(Array) //针对数组排序,单不能对数组缓冲排序
    val arr = Array(1,23,4,2,45)
    arr.mkString(",") //指定分割符
    arr.mkString("(",",",")") //指定前缀、分隔符、后缀
更多函数参见Scaladoc
    5、多维数组:
val matrix = Array.ofDim[Int](5,4) //三行四列的二维数组
matrix(2)(3) //访问第二行、第三个元素
    6、scala数组和java互操作:由于scala数组是用java数组实现的,所以可以在java和scala之间来回传递,引入scala.collectin.JavaConversion ,可以在代码中使用scala缓冲,在调用java方法时,这些对象会被自动包装成java列表。反过来讲,引入scala.collection.asScalaBuffer时,当java方法返回java.util.List时,我们可以让它转换成一个Buffer


补充(转自 http://blog.csdn.net/luyee2010/article/details/23801317):

变量定义:

val:类似java中final类型的变量

  • 1,基本格式:val 变量名:变量类型 = 值
  • 2,其中有时变量类型可以省略,可以自动识别
  • 3,变量不能赋值,修改
  • scala> val age :Int=0
    age: Int = 0
    
    scala> var msg name:String = null
    :1: error: illegal start of simple pattern
    var msg name:String = null
                ^
    
    scala> var name:String = null
    name: String = null
    
    scala> val age1,age2,age3 =0
    age1: Int = 0
    age2: Int = 0
    age3: Int = 0


函数定义

函数格式:
def 函数名(参数列表,...):返回结果类型={},下面给出一个max函数
1,有时函数必须制定返回结果类型,如函数时递归,就必须明确制定返回结果类型
2,在max这里例子中及时不写返回结果,编译器也能推断,如实这个函数就 编程如下的样子,作用功能都没有变化
3,如果函数仅 一个语句,连花括号都可以不写。如是max函数就成了这样,作用功能仍然没有变化
greeting():Unit,其中Unit值得时greetin的返回类型,类似于Java的void类型,而且Java中的void类型会被映射成Unit

  def greeting()=println{"no args no return?"}
  greeting()
  greeting
结果两个都返回
no args no return?
no args no return?

while循环

Scala中,i++或者++i都不能其作用,只能使用i=i+1

    var  i = 0
    while(i <= 5)
    {
      println("i is :" + i)
      i++ //value ++ is not a member of Int
    }
  }

foreach与函数字面量

函数字面量格式:参数列表 => 函数体
(x: Int, y:Int) => x + y
结果都一样
args.foreach(arg => println(arg))
  args.foreach((arg: String) => println(arg))
  args.foreach(println)

for循环

for循环中是val类型,因此在for表达式中不能重新对其赋值, <-可以理解为其中的意思,
for(arg <- args) 对于args中的arg, 纳尼?怎么感觉是Java中foreach中的in






你可能感兴趣的:(年薪100万)