Scala笔记

最新推荐文章于 2024-07-29 09:42:20 发布

癞皮dog

最新推荐文章于 2024-07-29 09:42:20 发布

阅读量124

点赞数

分类专栏： Scala 文章标签： spark scala

本文链接：https://blog.csdn.net/weixin_49520007/article/details/118092623

版权

Scala 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Scala

Scala_01【开发环境搭建】

主要内容

Scala是什么
为什么选择Scala
和Java的关系
安装ScalaSDK
配置IDEA环境
使用Scala DOC
HelloWorld

学习目标

掌握scala环境安装
掌握IDEA配置
掌握hello world编写和运行

Scala开发环境搭建

1.1 Scala是啥

Scala产生于瑞士的洛桑联邦理工学院(EPFL),是"可扩展语言"(Scalable Language)的缩写,Scala是一门现代的多范式语言,志在以简洁,优雅及类型安全的方式来表达常用的编程模型.它平滑的集成了面向对象和函数式语言的特性.

Scala是面向对象的
1. 鉴于一切值都是对象,可以说Scala是一门纯面向对象的语言
2. 对象的类型和行为是由类和特质来描述的.类可以由子类化和一种灵活的.基于混入的组合机制来扩展.
Scala是函数式的
1. 鉴于一切函数都是值,又可以说Scala是一门函数式语言
2. Scala为定义匿名函数提供了轻量级的语法,支持高阶函数,允许函数嵌套及柯里化
3. Scala的样例类和支持的模式匹配代数模型在许多函数式编程语言中都被使用.
4. 对于那些并非类的成员函数,单利对象提供了便携的方式去组织它们.
Scala是静态类型的
1. 孙然Scala在声明变量时不需要书写变量类型,但与java相同的是变量的类型是静态的(不可变的),编译器提供了根据赋值对变量类型的自动推断
Scala是可扩展的
1. Scala支持通过隐式类给已有的类型添加扩展方法
Scala的互操作性
1. Scala设计的目标是与流行的Java运行环境(JRE)进行良好的互操作,特别是与主流的面向对象编程语言–Java的互操作尽可能的平滑.Java的最新特性如lambda表达式,注解及泛型类在Scala中都有类似的实现.
2. 另外有些Java中没有的特性,如缺省参数值和带名字的参数等,也是尽可能的向Java靠拢.Scala拥有类似Java的编译模型(独立编译,动态类加载),且允许使用Java生态已有的成千上万的高质量类库.
1.2 Scala和Java的关系
- Scala与Java和众多的JVM语言的共同之处在于,使用专门的编译器(Compiler)将源代码编译成字节码(ByteCode)文件,并最终使用JVM执行程序,所以具有和Java相同的优良移植性
1.3 安装Scala
- 条件
  - Scala需要使用JVM来运行字节码文件,所以需要先安装JDK
- 版本选择
  - 为了更好学习和使用Spark,Flink等高性能的大数据引擎,Scala的学习是必要的.
  - Scala的当前流行版本是2.11.x,2.12.x
- 官网
- 下载步骤及环境变量配置参考其他资料
1.4 使用Scala的REPL(R(read)、E(evaluate)、P(print)、L(loop):交互式解释器)
- Scala与Java一样是编译型语言,及Scala源代码需要被编译成字节码文件才能被运行在JVM上;
- Scala为了实现与Python,Shell,JavaScript之类的脚本语言类似的解释执行(书写一行运行一行)的功能,专门实现了一个名为REPL的解释器
1.5 Scala的IDEA程序开发

1.5.1 为IDEA下载Scala插件(idea->File->settings->Plugins->搜索框输入scala->Install->重启idea)

1.5.2 创建空的Maven工程

1.5.3 创建Scala源代码目录(main->右键->New->Directory->输入scala->标记为源代码目录)

1.5.4 添加ScalaSDK全局库(File->ProjectStructure->GlobalLibraries->±>ScalaSDK)

1.5.6创建HelloWorld单例对象(scala->New->ScalaClass->Object)

1.5.7 编写HelloWrold
```
object HelloScala {
  def main(args: Array[String]): Unit = {
    println("Hello,World!!!")
  }
}
```

Scala_02【scala基础】

主要内容

表达式
常量
变量
代码块
方法
函数
类
对象
特质

学习目标

初步了解Scala基础知识
掌握变量的声明
掌握方法声明
掌握函数声明
掌握类，对象，特质的声明

基础

1.表达式

表达式是可计算的语句(1+1)

2.值类型

与Java类似的Scala有Byte,Short,Int,Long,Float,Double,Char,Boolean.8中常用值类型
与Java不同的是,Scala中,真万物皆对象,所以没有所谓的包装类,上面这8中值类型都是对象

3.常量和变量

使用val关键字命修饰的对象为常量,不能被重新赋值
使用var关键字定义的对象为变量,可以重新赋值
需要注意的是,在标识符后面,可以显式的声明对象的类型,也可以不声明,Scala会推断出值类型

class Scala_01常量和变量 {
  def main(args: Array[String]): Unit = {
    
    //val声明的是常量,他的值不可变
    val a:Int=2
    //a=5(编译不通过)

    //var声明的是变量,值可以改变
    var b:Int=3
    b=4

    //可以不用声明对象类型,scala可以通过右边的值推断类型
    val c="hello,world!!!"
    var d='我'
  }
}

4.代码块

我们可以组合几个表达式,并且用{}包起来,我们称之为代码块(block)
代码块中最后一个表达式的结果,也是整个块的结果

object Scala_02代码块 {
  def main(args: Array[String]): Unit = {
    /**
     *Scala代码块每行都有返回值
     * 而代码块有多行表达式
     * 代码块的返回值就是最后一行的表达式的值
     */

    print({
      val a = 1.+(5)
      val b=a.+(2)
      b.+(2)
    })
  }

  //运行结果:10

}

5.方法

方法由def关键字定义.def后面跟着一个名字,参数列表,返回值类型和方法体

语法:

def 方法名 (参数名:参数类型) :返回值类型 = {方法体}

object Scala_03方法和函数 {
  //java中方法的定义
  // 权限修饰符    静态   返回值类型   方法名    参数列表          方法体
  // public     static void         main     (String[] args) { }

  //Scala中方法的定义
  // 关键字  方法名     参数    参数类型       返回值类型   方法体
  //  def    main     (args: Array[String]): Unit =      {方法体}


  def add(a: Int): Int = {
    a + 3
  }

  def main(args: Array[String]): Unit = {
    print(add(5))
  }
  //运行结果:8
}

无返回值的方法

//没有参数列表
// Unit代表无返回值
def sum(): Unit ={
  222
}

def main(args: Array[String]): Unit = {
 println(sum())
}
//运行结果:()

6.函数

正常函数和方法没有区别

object Scala_03方法和函数 {
  //这是一个方法
   def main(args: Array[String]): Unit = {
    //这是一个函数
    def sum(b:Int,c:Int)={
      b+c
    }

    println(sum(3,5))
  }

}

函数是带有参数的表达式
匿名函数语法:(参数名:参数类型) =>{函数体}

//这是一个匿名函数
  val add=(x:Int)=>x+1;
  println(add(3))

我们可以定义一个匿名函数(没有名字),来返回一个给定整数加一的结果

7.函数和方法的区别

方法是类的成员
方法是描述一类事务的行为
函数就是一个有输入有返回值的一段代码块
方法和函数都可以使用def进行声明
声明和使用两者没有本质区别

8.类

class:面向对象语言中用来描述一些具有相同属性和方法的对象的模板
我们可以使用class关键字定义一个类,后面跟着它的名字
Scala类中的属性,构造器,和方法介绍见下方代码块

object Scala_04类 {
  def main(args: Array[String]): Unit = {
    val stu1=new Student;
    stu1.name="zhangsan"
    stu1.age=18
    println(stu1.name)

  val stu2=new Student2("李四",19);
    stu2.sayHello()

  }

}


//声明类
class Student{
  //类属性声明是可以用"_"来作为属性的默认值
var name:String= _
  var age :Int = _

  def study(): Unit ={
    println("正在学习....")
  }

}

//类的构造器
//Scala中类的构造器和类的声明在同一个位置
//    主构造器
class A(){}
//主构造器默认是空参的,空参是可以省略的
class B{}
//如果主构造器中用var或val声明变量,那么这些变量将作为对象的成员属性'
class Student2(val name:String,val age:Int){
  def sayHello(): Unit ={
    println("我是"+name+"今年"+age+"岁,谢谢!")
  }
}


class Teacher(){
  var name:String = _
  var age:Int=_
//Scala中通过辅助构造器的重载提供多样的构造方式
  //辅助构造器是一系列名字叫this的方法
  //所有的辅助构造器都必须直接或间接的调用主构造器
def this(name:String){
this()//调用主构造器
this.name=name
  }

  def this (age:Int){
this()
    this.age=age
  }

  def this (name:String,age:Int){
    this(name)//间接调用主构造器
    this.age=age
  }
}

9.对象

这里说的对象是使用object关键字定义的单个实例,我们可以把它看做是自己类的单例

object Scala05_对象 {

  var name: String = "aaa"

  def main(args: Array[String]): Unit = {
    // scala提供了object关键字用来声明一个单例对象

    val person = new Person
    person.name


    val p1 = Person()

    val p2 = Person("amos")

  }
}

10.伴生

// 声明在同一个Scala源代码文件中
// 名字完全相同的class和object互为伴生关系

class Person {
  var name: String = "person"
  var age: Int = 18
}

object Person {
  def apply(): Person = new Person()

  def apply(name: String): Person = {
    val person = new Person()
    person.name = name
    person
  }
}

11.特质(trait)

特质是使用一个trait关键字声明的包含某些字段和方法的结构,类似于java中的接口(interface).特质允许多继承

object Scala07_特质 {
  def main(args: Array[String]): Unit = {
    val student = new Student with Gamer with EatMan

  }
}

trait Gamer{
  def playWZRY(): Unit ={
    println("打的贼菜...")
  }
}

trait EatMan{
  def ganfan(): Unit ={
    println("吃的贼多...")
  }
}

Scala_03【特殊语法】

主要内容

Scala类型层次结构
类型转换
算术和操作符重载
apply,update方法
Option类型
异常

学习目标

了解Scala类型层次结构
掌握类型转换
了解操作符重载
理解方法的隐式调用
掌握Option用法
掌握异常处理

特殊语法

1.统一的类型体系

1.1 类型层次结构

在Scala中,所有的值都有类型,包括数值和函数.下图阐述了类型层次结构的一个子集.
Any是所有类型的超类型,也称为顶级类型.它定义了一些通用的方法,如equals,hashCode和toString.Any有两个直接子类:AnyVal和AnyRef
AnyVal代表值类型.有9个预定义的非空的值类型分别是:Double,Float,Long,Int,Short,Byte,Char,Unit和Boolean.Unit是不带任何意义的值类型,它仅有一个实例可以像这样声明:().所有函数必须有返回值,所以说有时候Unit也是有用的返回值类型.
AnyRef代表引用类型.所有非值类型都被定义为引用类型.在Scala中,每个用户自定义的类型都是AnyRef的子类型.如果Scala被应用在Java的运行环境中,AnyRef相当于java.lang.object

1.2类型转换

值类型可以按照下面方向进行转换:
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-owAubk1h-1624272921300)(E:\素材\img\笔记\Scala\leixingzhuanhaun.png)]

自动类型转换

语法:val 对象名:目标类型=源对象

//自动类型转换
   //Byte->Short->Int->Long->Float->Double
   //char->Int
 
   //Byte->Int
   val b:Byte=101
   val c:Int=b
   println(c)
   //运行结果:101

强制类型转换

语法:源对象.asInstanceOf[目标类型]

//强制类型转换
   //语法: 源对象.asInstanceOf[目标类型]
   val d=129
   val e:Byte=d.asInstanceOf[Byte]
   println(e)
   //运行结果:-127

判断对象类型
- 类似于Java中的InstanceOf,Scala也提供了isInstanceOf用来判断对象是否属于某个类型
- 语法:对象.isInstanceOf[目标类型]
- ```
println(d.isInstanceOf[Byte])
   //运行结果:false
```
Nothing和Null
- Nothing是所有类型的子类型,也称为底部类型,没有一个值是Nothing类型的,它的用途之一是给出非正常终止的信号,如抛出异常,程序退出或者无限循环(可以理解它是不对值进行定义的表达式类型,或者一个不能正常返回的方法)
- ```
def getmo(num:Int)={
 
   throw new ArithmeticException()
   }
```
- Null是所有引用类型的子类型(即AnyRef的任意子类型).它有一个单例值由关键字null所定义.Null主要是使得Scala满足和其它JVM语言的互操作性,但是几乎不应该在Scala代码中使用.

2 .算术和操作符重载

±*/%可以完成和Java中相同的工作,但有一点区别,它们都是方法.你几乎可以使用任何符号来为方法命名.

中缀表达式

Scala中可以将:对象.方法(参数)简写为:对象方法参数
例如:

//Scala中由于没有基本数据类型,所以只能为每一个值类型设计一些与算术运算符名称一样的方法
     val i:Int=1
     val res =i.+(1)
   //上面这种写法虽然符合面向对象的书写方式,但是过于恶心
   //所以Scala又提供了中缀表达式的语法
   //可以将形如:对象.方法名(参数)  写作  对象 方法名参数
     val res1=i + 1
   val str="a,b,c"
   val strings = str.split(",")
   //中缀表达式写法
   val strs=str split ","
  
   println(strings.toList)
   //运行结果:List(a, b, c)
   println(strs toList)
   //运行结果:List(a, b, c)

3.apply,update方法

Scala中提供了很多隐式操作用来简化编码的书写量,例如典型的apply和update方法

3.1 apply方法

定义在object中名为apply的一系列方法在调用时可以直接使用对象名(参数)的形式完成调用
例如:使用object和apply方法定义的DateUtils工具类实现日期格式转换

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

    val l = System.currentTimeMillis()

    println(apply(l))
     //运行结果:2021-06-19 10:01:24
    println(apply("1993-05-29 17:30:00").getTime)
     //运行结果:738667800000
  }

   val format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

  def apply(time:Long) ={
    format.format(time)
  }

  def apply(time:String) = {
    format.parse(time)
  }
}

3.2 update方法

Scala中不可变数组被定义为Array对象,更新数组中的元素时,可以使用update方法,或其隐式形式
数组对象(索引)=值等价于数组对象.update(索引,值)

val array=new Array[Int](5)
 array.update(0,5)//给数组的0号元素赋值5
 array(1)=3//数组1号元素赋值3
 array(2)=8
 println(array.toList)

4.Option类型

Scala为单个值提供了对象的包装器,表示那种可能存在也可能不存在的值.
它只有两个有效的子类对象,一个是Some,表示某个值,另一个是None,表示为空,通过Option的使用,避免了使用null,空字符串等方式来表示缺少某个值得做法.

object Scala_0303Option类型 {
  def main(args: Array[String]): Unit = {
    //Scala中为了避免map集合取值是取到的元素为null
    //所以在使用key取值时,默认会返回一个Option类型
    //Option是一个抽象类
    //有两个实例 Some可以取到值时,将取到的v封装在Some中返回
    //          None 取不到值是返回一个None

    val map=new mutable.HashMap[String,Int]()
    map.put("zs",18)
    val maybeInt = map.get("zs")
    println(maybeInt.isInstanceOf[Int])
    //运行结果为:false
    println(maybeInt.isInstanceOf[Some[Int]])
    //运行结果:true
    val maybeInt1 = map.get("ls")
    println(maybeInt1.isInstanceOf[Some[Int]])
    //运行结果:false
    println(maybeInt1.isInstanceOf[None.type ])
    //运行结果:true

    //Scala为了避免取到None,也设计了默认值
    val i = map.getOrElse("ls", 10)
    println(i)
    println(i.isInstanceOf[Int])  //为什么这里写[Some[Int]]会报错
    //运行结果:10
    //        true


  }

5.异常

与Java类似的,Scala提供异常处理机制用于终止错误的程序运行和错误提示
但是Scala没有"受检"异常,我们不需要声明说函数或者方法可能会抛出某种异常.受检异常在编译器被检查,Java必须声明方法所会抛出的异常类型

object Scala_0304异常 {
  def main(args: Array[String]): Unit = {
    //Scala不提供受检异常,也就是说方法声明时不需要指定可能抛出的异常类型
    //与java类似的是Scala也用try-catch-finally的结构捕获和处理异常
    //不同的是catch部分可以直接捕获和处理多种异常
    try {
    val stream = new FileInputStream("")
    println(stream)
    }catch{
      case e:Exception=>println(e)
      case e:ArrayIndexOutOfBoundsException=>println(e)
      case e:FileNotFoundException=>println(e)
    }
  }

}

Scala_04【控制结构】

主要内容

if else 表达式
while 表达式
for 表达式

学习目标

熟练使用if else
熟练使用for循环

控制结构

1.if-else表达式

Scala中提供与大部分编程语言中类似的if-else选择结构语句‘

语法：

if(expr) {expr为true时执行的语句}else{expr为false时执行的语句}

例如:将a和b中较大值得平方赋值给max

object Scala_0401if_else {
  def main(args: Array[String]): Unit = {
    val a=9
    val b=15
    var c=0;
    if(a>b) {
       c=a*a
    }else{
       c=b*b
    }
    println(c)

    //if或else分支只有一行代码时可以省略{}
    if (a>b) c=a else c=b
    println(c)

    //调用评级方法获得成绩级别并输出
    println(getGrade(66))
  }

  //练习:一个方法输入成绩返回评级:85分以上A,75分以上B,60分以上C,60分一下D
  def getGrade(score:Int)={
    var s=""
    if(score>85) s="A"
    else if(score>75 && score<=85) s="B"
    else if(score>60 && score<=75) s="C"
    else s="D"
    s
  }
}

2.while和do-while表达式

whi和do-while表达式固定返回Unit

2.1 while

while语法:

while(expr){expr为true时反复执行的语句}

例如打印1000以内的斐波那契数列

 def main(args: Array[String]): Unit = {
    var first=0
    var second=1
    var fbnq=0;
    while (fbnq<1000){
      println(fbnq)
      first=second
      second=fbnq
      fbnq=first+second
    }
  }

2.2 do-while

do-while语法:

do{ expr 为true时反复执行的语句} while(expr)

例如:计算一个正整数的各位之和

2.3 关于break

需要注意的是Scala中没有提供break和continue的关键字
如果要实现类似的功能,可以使用控制循环条件,函数封装+return或BreakAPI
例如:判断一个整数是否含有偶数位

3. for推导式

3.1 概述

Scala提供了一个功能强大的序列推导式以for关键字开始
语法
```
for (enumerators) {循环体}
```
- 枚举器(enumerators):指的是一组以分号分隔的枚举器,枚举器可以由一个产生新变量的生成器(generator)以及一个守卫(guard)组成.
- 生成器(generator):指的是形如(变量名 <- 集合)的表达式,生成器会在每次迭代时从<-右边的集合中取一个元素赋值给<-左边的变量
- 守卫(guard):指的是一个形如(if expr)的表达式,expr为true时执行循环体,为false时类似java中的continue操作,跳过当前循环进行下次循环.
- ```
object Scala_0403for循环 {
  def main(args: Array[String]): Unit = {
    println("====================九九乘法表=====================")
    for ( i<-1 to 9;j<-1 to i){
    printf("%dx%d=%d\t",j,i,i*j)
      if(i==j){
        println()
      }
    }
  }
}
```

3.2 与java的foreach类似

Scala的for推导式使用时与Java的foreach极为相似,但功能更加强大

Java的foreach

//for ( 类型 变量 : 集合 ) {
//  循环体;
//}
int[] arr = {1, 2, 3};
for (int i : arr) {
  System.out.print(i + " ");
}
// 1 2 3

Scala的for推导式

    //Scala的for推导式
    val lists=Array("zs","ls","ww")
    for (elem <- lists) {println(elem)}

3.3 守卫(guard)

守卫可以实现对生成器生成的元素进行过滤,可以理解为提供类似java的continue的功能
例如:打印100以内3的倍数

    //Scala中的守卫
    for(i<-1 to 100 if i%3==0){
      print(i+"\t")
    }

3.4 包含多个枚举器

for推导式允许包含多个枚举器,相当于for循环嵌套,运行时会按照顺序在第一个枚举器取一个值时,执行完第二个枚举器的所有取值
例如:打印9x9乘法表

 println("====================九九乘法表=====================")
    for ( i<-1 to 9;j<-1 to i){
    printf("%dx%d=%d\t",j,i,i*j)
      if(i==j){
        println()
      }
    }

3.5 yield

另一种for推导式语法:
```
for (enumerators) yield e
```
for-yield会将生成器中满足守卫条件的元素带入表达式e的运算,最终将所有的运算结果收集到集合并返回
例如:获取字符串中所有字符的ASCII值

Scala_05【数据结构与集合】

主要内容

数据结构概述
Scala的集合分支
定长数组
变长数组
数组转换
多维数组
和Java数组的互操作
元组
序列
集
映射
集合操作的通用方式
集合转换的通用算子
特殊集合分支线程安全的集合

学习目标

理解数据结构
了解Scala中数据结构的实现
掌握Scala常见数据结构（集合）的操作

数据结构与集合

1. 数据结构概述

1.1 数据结构(Data Structure)

数据结构讨论是在抽象层面上一组具有一定关系的数据元素的存储及处理.
1. 数据元素之间逻辑关系的分类,每种逻辑关系对应的操作
2. 每种逻辑关系在计算机内部的存储模型
3. 对应于每种存储模式和操作的实现过程

1.2 逻辑结构(Logical Structure)

描述数据元素之间的逻辑关系,是数据结构研究的子范畴.
逻辑结构分为线性结构,树状结构,集合结构和图状结构4类
数据结构研究并给出每种逻辑结构的处理方法

1.2.1 线性结构(Linear Structure)

一对一关系
同一数据集合中的元素排成一个有序的序列
序列的第一个元素称(起始节点(Initial Node)),最后一个元素称(终端节点(Terminal Node))
任意一对相邻元素,前者是后者的(直接前驱(Directly Predecessor)),后者是前者的(直接后继(Directly Successor))
起始节点只有直接后继没有直接前驱,终端节点只有直接前驱,没有直接后继
除起始节点和终端节点外,每个元素都只有一个直接前驱和一个直接后继.

1.2.2 集合结构(Set structure)

松散的逻辑结构
处于同一数据集合中的元素之间除同属于该集合这一联系外没有其他关系.
集合结构通常需要借助其它数据结构,比如线性结构和树.
唯一专用于集合类型的数据结构是哈希表

1.2.3 树状结构(Tree)

一对多关系
同一集合中除了特殊的根(root)元素之外,每个元素有且仅有一个直接前驱,后继数目不限.
根元素没有直接前驱

1.2.4 图状结构

多对多关系
数据集合中每个元素的直接前驱和直接后继数目都不限

1.3 存储结构(Storage Structure)

逻辑结构在计算机内的存储方式
包括数据元素的存储和数据元素之间的关系.
为了便于计算,有事还会增加一些辅助信息.

1.3.1 顺序存储(Sequence Storage)

所有的节点存储存放在一块连续的存储区域中,用于存储节点的位置来体现节点之间的逻辑关系的存储方式.

1.3.2 链接存储(Link Storage)

用指针指出存储节点间关系的存储方法.

1.3.3 索引存储(Index Storage)

分别存放数据元素和元素间关系的存储方式

1.3.4 哈希存储(Hash Storage)

又称为散列存储

2. Scala的集合

2.1 集合继承层次

Scala同时支持可变集合和不可变集合,不可变集合长度不可变,可以安全的并发访问.
两个主要包:
- 不可变集合:scala.collection.immutable
- 可变集合:scala.collection.mutable
- Scala优先采用不可变集合.集合主要分为三大类:序列,集,映射.
- 所有集合都扩展自Iterable特质.对于几乎所有的集合类,Scala都同时提供了可变和不可变的版本
不可变集合继承层次

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WNmsgGmX-1624272921304)(E:\素材\img\笔记\Scala\image990.png)]

可变集合继承层次

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FXutJ1rU-1624272921308)(E:\素材\img\笔记\Scala\image1014.png)]
Seq:是一个线性表.IndexedSeq是一个线性表能够通过整形下标快速访问元素
Set:是一个没有先后次序的值集合.在SortedSet中,元素以某种排过序的顺序被访问
Map:是一组键值对偶,SortedMap按照键的排序访问其中的实体
每个Scala集合特质或者类都有一个带有Apply方法的伴生对象(类似于静态方法),这个apply方法可以用来构建该集合中的实体.这样的设计叫"统一创建原则".

2.2 数组

2.2.1 定长数组

创建

 //1  Array:不可变数组
    //1.1  创建
    //1.1.1 new关键字创建
    val arr1=new Array[Int](5)
    //1.1.2 apply方法创建
    val arr2=Array(5,3,1,4,2)

赋值

    //1.2 赋值
   arr1(2)=9

取值

 //1.3  取值
    val i = arr2(2)

遍历

//1.4  遍历
    //1.4.1  使用下标遍历
    for(i <- 0 to arr2.length-1){
      print(arr2(i))
    }
    //1.4.1  下标简单写法
    for(i <- arr2.indices){
      print(arr2(i))
    }
    //1.4.2 for推导式直接遍历
    for(i <- arr2) print(i)
 //1.4.3 foreach 遍历
    //def foreach[U](f : scala.Function1[A, U]) : scala.Unit =
    arr2.foreach((x:Int) => print(x))
    arr2.foreach(x=>print(x))
    //当匿名函数中,参数只有一个,并且值调用一次时,可以用_代替
    arr2.foreach(print(_))
    arr2.foreach(print)

2.2.2

创建

  //2.1 创建
    //2.1.1 new 关键字创建
    val buffer1 = new ArrayBuffer[Int]()
    //2.1.2  apply方法创建
    val  buffer2=ArrayBuffer("a","b","c","d")

赋值

 //2.2 添加元素
    //2.2.1  +=添加元素
    buffer2 += "e"
    buffer2 += "f"
    //2.2.2  append添加元素
    buffer2.append("g","h","i")

取值

 //2.3 取值
   buffer2(5)

遍历

癞皮dog

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Scala笔记

ScalaScala_01【开发环境搭建】主要内容Scala是什么为什么选择Scala和Java的关系安装ScalaSDK配置IDEA环境使用Scala DOCHelloWorld学习目标掌握scala环境安装掌握IDEA配置掌握hello world编写和运行Scala开发环境搭建1.1 Scala是啥 Scala产生于瑞士的洛桑联邦理工学院(EPFL),是"可扩展语言"(Scalable Language)的缩写,Scala是一门现代的多范式语言,志在以简洁,
复制链接

扫一扫