Scala(第一节)Scala简介、Scala编程环境搭建、数据类型、流程控制语句、方法、函数、懒值加载

1300-黄同学

发表文章数:85

热门标签

首页 » 大数据 » 正文

Scala简介

什么是Scala

scala官方网址:
http://www.scala-lang.org
Scala是一种多范式的编程语言,其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台(Java虚拟机),并兼容现有的Java程序。http://www.scala-lang.org

为什么要学Scala

1、优雅:这是框架设计师第一个要考虑的问题,框架的用户是应用开发程序员,API是否优雅直接影响用户体验。
2、速度快:Scala语言表达能力强,一行代码抵得上Java多行,开发速度快;Scala是静态编译的,所以和JRuby,Groovy比起来速度会快很多。
3、能融合到Hadoop生态圈:Hadoop现在是大数据事实标准,Spark并不是要取代Hadoop,而是要完善Hadoop生态。JVM语言大部分可能会想到Java,但Java做出来的API太丑,或者想实现一个优雅的API太费劲。

Scala编程环境搭建

1、 安装JDK

因为Scala是运行在JVM平台上的,所以安装Scala之前要安装JDK。

2、 安装Scala

Windows安装Scala编译器

访问Scala官网http://www.scala-lang.org/下载Scala编译器安装包,目前最新版本是2.12.x,这里下载scala-2.11.8.msi后点击下一步就可以了(自动配置上环境变量)。也可以下载scala-2.11.8.zip,解压后配置上环境变量就可以了。
环境变量配置如下:
1、定义SCALA_HOME变量
Scala(第一节)Scala简介、Scala编程环境搭建、数据类型、流程控制语句、方法、函数、懒值加载
2、添加下图变量到path
Scala(第一节)Scala简介、Scala编程环境搭建、数据类型、流程控制语句、方法、函数、懒值加载

Linux安装Scala编译器

下载Scala地址https://www.scala-lang.org/download/2.11.8.html
然后解压Scala到指定目录
tar -zxvf scala-2.11.8.tgz -C /usr/java
配置环境变量,将scala加入到PATH中

vi /etc/profile
export JAVA_HOME=/usr/java/jdk1.8
export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.11.8/bin

Scala开发工具安装

目前Scala的开发工具主要有两种:Eclipse和IDEA,大多数Scala程序员都选择IDEA,安装IDEA后还需要安装Scala插件。
这里我们使用离线安装Scala插件:

  1. 安装IDEA,点击下一步即可。
  2. 下载IEDA的scala插件
    插件地址: https://plugins.jetbrains.com/plugin/1347-scala/versions,到插件地址找适合自己的IDEA版本的插件,下载。
  3. 安装Scala插件:Configure -> Plugins -> Install plugin from disk -> 选择Scala插件 -> OK -> 重启IDEA。

Scala项目创建

第一步:idea当中创建创建普通maven工程
第二步:修改pom.xml添加scala的版本以及打包插件
pom如下:

<dependencies>
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
        <version>2.11.8</version>
        <!-- 如果想要用java -jar 来运行我们打包之后的jar包,则下面这个配置必须注释掉 -->
       <!-- <scope>provided</scope>-->
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 限制jdk版本插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    <!-- 编译scala需要用到的插件 -->
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <version>3.2.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- 项目打包用到的插件 -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifest>
                        <mainClass>cn.itcast.scala.demo1.ScalaFirst</mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

第三步:创建scala文件夹,并将该文件夹设置为SourceRoot
第四步:建包,建类(创建主类用Object,写脚本则用Scala Worksheet)

Scala数据类型

scala当中常用数据类型

类型 值范围
Boolean true 或者 false
Byte 8位, 有符号
Short 16位, 有符号
Int 32位, 有符号
Long 64位, 有符号
Char 16位, 无符号
Float 32位, 单精度浮点数
Double 64位, 双精度浮点数
String 其实就是由Char数组组成

scala当中的常用类型结构图

Scala中,所有的值都是类对象,而所有的类,包括值类型,都最终继承自一个统一的根类型Any。统一类型,是Scala的又一大特点。更特别的是,Scala中还定义了几个底层类(Bottom Class),比如Null和Nothing。

  1. Null是所有引用类型的子类型,而Nothing是所有类型的子类型。Null类只有一个实例对象,null,类似于Java中的null引用。null可以赋值给任意引用类型,但是不能赋值给值类型。
  2. Nothing,可以作为没有正常返回值的方法的返回类型,非常直观的告诉你这个方法不会正常返回,而且由于Nothing是其他任意类型的子类,他还能跟要求返回值的方法兼容。
  3. Unit类型用来标识过程,也就是没有明确返回值的函数。 由此可见,Unit类似于Java里的void。Unit只有一个实例,(),这个实例也没有实质的意义。

Scala(第一节)Scala简介、Scala编程环境搭建、数据类型、流程控制语句、方法、函数、懒值加载

Scala流程控制语句

if else表达式

scala中没有三目运算符,因为根本不需要。scala中if else表达式是有返回值的,如果if或者else返回的类型不一样,就返回Any类型(所有类型的公共超类型)。
例如:if else返回类型一样

val a=20
val aReslut=if (a>10){
  "hello"
}else{
  30
}
println(aReslut)

例如:if else返回类型不一样

val c = 50
val d = if(c > 20){
  println("返回一个字符串")
  "ABC"
}else{
  println("helloworld")
}

while表达式

scala提供了类似于java的while和do循环,但是while语句的本身是没有任何返回值类型的,也就是while语句最终的返回结果是Unit类型的()。

var e=1
val f=while (e<=10){
  e+=1
}
println(e) 
println(f) //while循环没有返回值

scala当中while循环的contine和break,注意:scala当中并没有提供类似于java的continue和break操作,如果需要终止循环,我们可以有以下几种方式
1、 使用Boolean标识来进行终端
2、 使用嵌套函数,从函数中直接return
3、 使用Breaks对象当中的break方法

//scala中break循环的用法
var g=10
val loop=new Breaks
loop.breakable{
  val f=while (g<=20){
    g+=1
    if (g==15){
      loop.break()
    }
    println(g)
  }
}

for表达式

scala当中,为for循环这一常用的循环结构提供了很多的特性,这些特性被称之为for推导式或者for表达式。

示例一:使用to实现左右两边均为闭合的访问

//scala当中,多个for循环可以合并,无需嵌套
for (i <- 1 to 3;j <- 1 to 5){
  println(i*j)
} // to是两边闭合的

示例二:使用util实现左右两边分别为前闭后开的访问

for (i <- 1 until  3;j <- 1 until  5){
  println(i*j)
} // until是左闭右开的

Scala方法

scala定义方法的标准格式为

示例一:定义一个最标准的方法,且定义方法的返回值类型为Int类型

def hello(c1:Int,c2:String):Int={
  c1
}

示例二:定义一个方法,且不定义返回值
注意:如果定义的方法没有返回值,那么方法的返回值会做自动推断。根据我们方法的最后一个返回类型来推断我们的方法返回类型

def hell02(c1:Int,c2:String)={
  "hello world!"
}

示例三:定义一个方法,不定义返回值,可以通过自动推断,返回不同类型的值

def hell03(c1:Int,c2:String)={
  if (c1>5)
    c1
  else
    c2
}

hell03(2,"b")
// scala支持指定参数名并不按参数顺序传参
hell03(c2 = "b",c1 = 10)

示例四:定义一个方法,参数给定默认值,如果不传入参数,就使用默认值来代替

// scala支持参数带默认值
def hello4(c1:Int=10,c2:String): Unit ={
  println(c1,c2)
}

示例五:变长参数,方法的参数个数不定的,类似于java当中的方法的…可变参数

// 变长参数
def hell05(cc:Int*): Unit ={
  for (i <- cc)
    println(i)
}

示例六:递归函数。我们可以定义一个方法,使得方法自己调用自己,形成一个递归函数,但是方法的返回值类型必须显示的手动指定

// scala的递归需要显式指定方法返回值的类型
def hello6(c:Int):Int={
  if (c <= 1)
    1
  else
    c*hello6(c-1)
}

hello6(10)

示例七:定义一个方法,没有显示的指定返回值,那么我们方法当中定义的等号可以省掉
注意:如果省掉了=号,那么这个方法强调的就是一个代码执行的过程

/*
 不加=的方法和“unit=”效果一样,
 不返回任何值,
 与java中的void方法类似
 */
def hello7(c1:Int,c2:String){
  c1
}

示例八:直接通过def定义一个方法

// scala中可以用变量定义的方式来定义方法
def hello8()={"abc"}
def hello8new()="abc"
def hello8new2="abc"
hello8()
hello8new()
hello8new2

Scala函数

函数定义和使用

示例一:定义一个标准函数,使用 =>来进行定义

// 标准的函数定义方式
val func1=(c1:Int,c2:Int) => {
  c1+c2
}

func1(1,2)

示例二:定义匿名函数。也就是我们可以定义一个没有名字的函数

// 匿名函数
(c1:Int,c2:String) => {c1+c2}
// 单独定义匿名函数没有意义,因为它没有函数名,不能调用

示例三:函数定义的另外一种形式,定义一个函数,参数只有一个且是Int类型,返回值也是Int类型

// 不定义参数名,指定返回值类型的方式
val func3 :(Int) => Int = {
  x => x*x
  /*
  由于没有定义参数名,所以用x,y指代参数,
  用一个内部的匿名函数来完成函数体
   */
}

示例四:定义一个函数,参数值是两个,分别是Int和String,返回值是一个元组,分别是String和Int

val func4:(Int,String) =>(String,Int) ={
  (x,y) => (y,x)
}
println(func4(10,"hello"))

scala当中函数与方法的区别以及方法转换成函数

在scala当中,函数与方法是有区别的,函数可以作为一个参数,传入到方法里面去,可以定义一个函数,然后再定义一个方法,但是方法的参数是一个函数。

val myFunc = (x:Int) =>{
  x * x
}
val myFunc2 :(Int) => Int ={
  x => x * x
}

def methodFunction(f:Int => Int):Int ={
    println(f(100))
  f(100)
}
val methodFunctionResult = methodFunction(myFunc)
val methodFunctionResult2 = methodFunction(myFunc2)
println(methodFunctionResult)
println(methodFunctionResult2)

方法可以自动转换成函数作为参数传递到方法里面去

def method2(x:Int) ={ x * x }
def methodFunc2(x:Int => Int):Int ={
  x(100)
}
val methodFunc2Result = methodFunc2(method2)
println(methodFunc2Result)

可以通过 _ 将方法转换成函数

def method3(x:Int,y:String ) :Int = {
  println(x)
  x
}
val methodToFunc = method3 _
println( methodToFunc)

懒值加载

当val被声明为lazy时,它的初始化将被推迟,直到首次调用它,适用于初始化开销较大的场景。

// 懒值加载,变量只有在被使用时才赋值
def initLazy():String={"懒值加载完成!"}
lazy val msg=initLazy()
println("lazy方法没有执行")
println(msg)
标签:
分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录