scala基本语法

 

 

一.Scala中的数据类型和变量常量

1、注意:在Scala中,任何数据都是对象。和Java不同。

举例:
        在Java中 1 是基本数据类型。

        cmd中 清屏快捷键:ctrl+l
        scala> 2.    (Tab键查看方法)

scala> 2.
!=   +   <<   >=    abs         compareTo     getClass     isNaN           isValidChar    isWhole     round        to               toDegrees     toInt           toShort   underlying
%    -   <=   >>    byteValue   doubleValue   intValue     isNegInfinity   isValidInt     longValue   self         toBinaryString   toDouble      toLong          unary_+   until
&    /   ==   >>>   ceil        floatValue    isInfinite   isPosInfinity   isValidLong    max         shortValue   toByte           toFloat       toOctalString   unary_-   |
*    <   >    ^     compare     floor         isInfinity   isValidByte     isValidShort   min         signum       toChar           toHexString   toRadians       unary_~

在scala中 2是对象。用法:
        scala> 2.toDouble
        res4: Double = 2.0

二. 数值类型:Byte,Short,Int,Long,Float,Double

  1. Byte:  8位有符号数字,从-128 到 127

  2. Short: 16位有符号数据,从-32768 到 32767

  3. Int:  32位有符号数据  -2147483648-2147483647(20亿)

  4. Long: 64位有符号数据   -9223372036854775808-9223372036854775807

字符串 String 字符 Char
      

java和scala对比:       
  scala> var s1 : String = "Hello world"   
  Java : String s1 = "Hello world"


        
      

 scala> var s1 : String = "Hello world"
        s1: String = Hello world
        scala> "My name is Tom and ${s1}"
        res6: String = My name is Tom and ${s1}

 
        
      

   需要在前面加入s才可以进行插值操作

 scala> s"My name is Tom and ${s1}"
        res7: String = My name is Tom and Hello world

三、变量 var 和 常量 val


    常量 val:
    

scala> val b : Int = 11
       b: Int = 11

    常量的值不可以改变
  

  scala> b = 12
    <console>:12: error: reassignment to val
           b = 12
             ^

  

  变量 var:

  

 scala> var a : Int = 11
    a: Int = 11

    变量的值可以改变
  

  scala> a = 12
    a: Int = 12
scala> a=001
<console>:1: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
a=001
  ^

 

错误:十进制整数文本不能有前导零。(八进制语法已过时。)

error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)


    
    scala自动类型推导:
  

    scala> var a = 11
    a: Int = 11
    scala> var a = "Hello"
    a: String = Hello
    scala> val a = 11
    a: Int = 11

 

索引越界:

scala> val a:Byte = 128
<console>:11: error: type mismatch;
 found   : Int(128)
 required: Byte
       val a:Byte = 128
                    ^

 

四、unit类型 Nothing类型
        
        (1)Unit 类型,相当于Java中的void,就是没有返回值。
        
      

 scala> val f = ()
        f: Unit = ()

         小括号代表一个函数,这个函数没有返回值
        
        (2)Nothing 类型,在执行过程中,产生Exception
        
      

 scala> def myFunction = throw new Exception("Some Error")
        myFunction: Nothing
        
scala> def myexception=throw new Exception("yufa exception")
myexception: Nothing


   

五、函数:是scala的头等公民
    
    (一)scala内置函数,可以直接使用
    
      

 scala> max(1,2)
        <console>:12: error: not found: value max
               max(1,2)
               ^


        错误原因,没有引入math包

      

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

    

    scala> max(1,2)
        res9: Int = 2


        说明:


        _ 相当于Java中的*,代表这个包下所有的东西。
        
      

  res9: Int = 2


        本质:定义了一个变量,res9,保存执行结果,推导出res9类型是Int。
        
      

 scala> var a1 : Int = max(1,2)
        a1: Int = 2


        
        也可以省略类型声明
      

  scala> var a2 = max(2,3)
        a2: Int = 3
        

 

scala> var a=max(90,89)
a: Int = 90


    (二)自定义函数: 关键字 def
        格式: def 函数名称(参数列表 举例 x : Int, y : Int) : 返回值类型 = {
            函数实现
        }
        
        举例:
        1、求和
        
        

scala> def sum(x:Int,y:Int) : Int = x + y
        sum: (x: Int, y: Int)Int
        scala> sum(10,20)
        res10: Int = 30
        scala> var a = sum(10 , 20)
        a: Int = 30


        
        2、求阶乘 递归
        
      

  scala> def myFactor(x:Int) : Int = {
             | if (x <= 1)
             | 1
             | else
             | x*myFactor(x-1)
             | }
        myFactor: (x: Int)Int


        
        注意:没有return语句。函数的最后一句话就是函数的返回值。
        上面例子中,有函数的分支,1 和 x*myFactor(x-1) 都有可能是函数的最后一句话。
        相当于在前面都有return
        
      

  scala> myFactor(5)
        res11: Int = 120
        


        3、求输入的年份是否是闰年
        普通闰年:能被4整除但不能被100整除的年份为普通闰年(如 2004年就是闰年,1999年不是闰年)
        世纪闰年:能被400整除的为世纪闰年(如 2000年就是世纪闰年 1900年不是世纪闰年)
        
      

   scala> def isLeapYear(x:Int)={
        | if(x%4 == 0 && x%100 !=0 ||x % 400 == 0)
        | true
        | else
        | false
        | }
   isLeapYear: (x: Int)Boolean
   

 结果:

 注意:在定义函数的时候,可以不写返回值类型,Scala会帮咋们自动推导对应的数据类型
   
   scala> isLeapYear(1600)
   res11: Boolean = true
   
   scala> isLeapYear(2000)
   res12: Boolean = true
   
   scala> isLeapYear(2019)
   res13: Boolean = false
   
   scala> isLeapYear(2020)
   res14: Boolean = true
   
   scala> isLeapYear(2004)
   res15: Boolean = true
   ```

六.循环语句

      

 

package day1018

import scala.math.sqrt
import util.control.Breaks._

/**
  * 作者:Jackson
  * Created by root on 2019/10/18
  * scala循环
  *
  * object相当于 java中的static(静态的)
  *
  * java中是使用static关键字,表示静态
  *
  * Object中所有的内容都是静态的
  */
object Demo1 {


  def main(args: Array[String]): Unit = {

    //for循环
    //定义一个集合
    println("----------for循环第一种写法-----------")
    var list = List("Jack", "Tom", "andy", "plus")

    for (s <- list) println(s)
    //<-表示scala中的提取符,把list中的每一个元素提取出来赋值给s


    println("----------for循环第二种写法-----------")

    for {
      s <- list
      if (s.length > 3)

    } println(s)

    println("----------for循环第三种写法-----------")

    for (s <- list if s.length <= 3) println(s)

    //使用yield关键字  作用:产生一个新的集合
    println("----------for循环第四种写法-----------")
    var newList = for {
      s <- list
      s1 = s.toUpperCase() //把名字变成大写

    } yield (s1)
    for (s1 <- newList) println(s1)

    println("----------while循环写法-----------")
    //定义循环变量
    var i = 0
    while (i < list.length) {
      println(list(i))
      i += 1
    }
    println("----------do while循环写法-----------")
    //定义循环变量
    var j = 0
    do {
      println(list(j))
      j += 1
    } while (j < list.length)

    println("----------foreach循环写法-----------")
    list.foreach(println)
    //foreach函数,就是把每个元素取出来赋值给参数的函数->println 打印出来list中每个元素
    //foreach以后用的非常多

    /**
      * 判断101-200之间有多少个素数
      *
      * 程序分析实现方法:
      * 判断一个素数的方法:
      * 用一个数分别去除2到sprt(这个数),如果可以被整除,则表明此数不是素数,反之是素数
      *
      * 程序实现方法:
      * 定义俩层循环
      * 第一层:101到200
      * 第二层:2->sqrt(第一层循环的数)
      *
      * 举例:16
      * 2循环到sqrt(16)4
      **/

    print("--------循环嵌套---------")
    var index_inner = 0
    var count = 0
    for (index_outner <- 101 until 200) {
      var b = false
      breakable {
        index_inner = 2
        while (index_inner <= sqrt(index_outner)) {
          if (index_outner % index_inner == 0) {
            //是素数
            b = true
            break
          }
          index_inner += 1
        }
      }
      if (!b) count += 1
    }
    println("个数为:" + count)


  }
}

 

                                                                                                                                    ————保持饥饿,保持学习

                                                                                                                                                                Jackson_MVP

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SuperBigData~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值