Scala基础（一）从零开始

红红火火恍恍惚惚240

已于 2024-05-23 09:51:17 修改

阅读量790

点赞数 24

文章标签： scala 大数据开发语言

于 2024-05-21 23:56:20 首次发布

本文链接：https://blog.csdn.net/weixin_74027659/article/details/139087600

版权

Scala是开发Java的核心人员开发的

Scala类的编译执行还是使用的Java jdk

配置Scala

安装Scala SDK

链接：https://pan.baidu.com/s/1lKW7JGY3uDxPm3aXgKKB-w?pwd=qwer
提取码：qwer

打开IDEA设置安装插件Scala

添加scala SDK

查看依赖已经添加成功，完成

现在就可以创建Scala类了

Scala基础

新建一个测试类，注意要选择Object

变量定义

常用类型(scala指定类型是在变量名后面加冒号类型)

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型。没有包装类

object Test {
  def main(args: Array[String]): Unit = {
    print("Scala")
    //定义变量格式：【val/var】 变量名【：数据类型】=值
    val a=1233
    val b="张三"
    val c:String="21"
    //val不能重新赋值
    var d="体重"
    var e=83.21
    //var可以重新赋值
    e=90
    print(a,b,c,d,e)
  }
}

表达式

条件表达式

  def main(args: Array[String]): Unit = {
    //条件表达式
    val age=2
    val v=if(age>3) 5
    print(v)
    
    //与Java思想一样但更为简单

    val str="qwqw"
    val f=if(str.equals("qwqw")) "相同" else "不同"
    print(f)
  }

这里v未赋值输出（）

块表达式

循环

在scala中有for循环和while循环，用for循环比较多

Scala里面的for是用来遍历集合的，如果非要用for来（1，2，3，4....）,可以使用var a=0.until(10)构建一个集合用来做遍历

object ForDemo {
  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    //箭头表示赋值
    for (i <- 1 to 10)
      println(i)
    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)
    //高级for循环,可以带条件
    //每个生成器都可以带一个条件，注意：if前面没有分号（这是个条件：j <- 1 to 3 //if i != j）
    for (i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()
    //12 13 21 23 31 32
    val value = Array(1, 3, 4, 5, 6, 7, 8, 9);
    for (i <- value; if (i % 2 == 0))
      println(i)  
      
  }
 val value = Array(1, 3, 4, 5, 6, 7, 8, 9);
  val arr = for (i <- value; if (i % 2 == 0))
    yield i
  //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
  //每次迭代生成集合中的一个值 yield表示把生成结果再生成一个新集合
  val v = for (i <- 1 to 10) yield i * 10
  println(v+":::")
}
使用脚标访问 until前闭后开 to是前后包括
val value=Array(1,3,4,5,6,7,8,9);
    for(i <-0 until value.length) println(value(i))
var values=1.to(10).map(_*3) map表示传递个函数处理前边的每一个值
   println(values)

调用方法和函数（所有运算符都是方法）

Scala中的+ - * / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有

一点特别的：这些操作符实际上是方法。例如：

a + b

是如下方法调用的简写：

+(b)

a 方法 b可以写成 a.方法(b)

定义方法和函数（方法和函数有区别的）

定义方法

def add(a:Int,b:Int):Int=a+b;
def add(a:Int,b:Int){
    a+b
  }  
  def add(a:Int,b:Int) =a+b   a+b就是方法体

定义函数（不加返回值类型）

Scala中函数是变量：前面定义时可以当作变量，后面函数实现又是方法，可以将其传递给方法，val 函数名=（a:参数类型，b:参数类型）=>{代码块返回值}

调用：函数名（参数1，参数2）

方法和函数的区别

在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作

案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面

object Test 
{
  //定义一个方法参数为一个函数
  def my(f:(Int,Int)=>Int):Int=f(3,4);
  
  val fun=(a:Int,b:Int)=>a+b;
   
  def main(args: Array[String]): Unit = {
    //函数可以当作值传递给方法    
    println(my(fun));
  }
}

def main(args: Array[String]): Unit = {
   aa((x)=>x*10);//在传递匿名函数可以不写类型 aa((x)=>x*10) 一个参数可以省略括号
   aaa((x,y)=>{x+y}) //在传递匿名函数可以不写类型
  }
  //方法声明为函数类型 函数声明处必须回类型
  def aa(f:(Int)=>Int)={
    f(2);
  }
  
  def aaa(f:(Int,Int)=>Int)={
    f(2,3);
  }
  
  }
  
  def aa(f:(Int)=>Int)={
    f(2);
  }
  
  def aaa(f:(Int,Int)=>Int)={
    f(2,3);
  }


object Test 
{
  
def main(args: Array[String]): Unit = {
  val arr=Array(2,4,5);

  var xx=arr.map(x=>x*10);
  var xx1=arr.map(x=>x-10);
  print(xx.toBuffer)
  print(xx1.toBuffer)
  }
  

  
}
 package com.oracle.cls

object MyInvoke {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int) : Int = {
    f(2, 6)
  }
  //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n

  //main方法
  def main(args: Array[String]) {

    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println(r1)

    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

将方法转换成函数

数组、映射、元组、集合

数组

定长数组和变长数组

object MyInvoke {

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

//初始化一个长度为8的定长数组，其所有元素均为0

val arr1 = new Array[Int](8) //后赋值

//直接打印定长数组，内容为数组的hashcode值

for (i <- 0.until(arr1.length)) {

arr1(i) = i

}

for (i <- 0.until(arr1.length)) {

println(arr1(i))

}

val arr2 = Array[Int](10,45,34) //构建出来就有内容。调用Array静态方法

println(arr2.toBuffer)

//定义一个长度为3的定长数组

val arr3 = Array("hadoop", "storm", "spark") //想构建出就有内容

//使用()来访问元素

println(arr3(2))

//变长数组（数组缓冲）

//如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包

val ab = ArrayBuffer[Int]()

//向数组缓冲的尾部追加一个元素

//+=尾部追加元素

ab += 1

//追加多个元素

ab += (2, 3, 4, 5)

//追加一个数组++=

ab ++= Array(6, 7)

//追加一个数组缓冲

ab ++= ArrayBuffer(8,9)

//打印数组缓冲ab

//在数组某个位置插入元素用insert

ab.insert(0, -1, 0)//在0脚标处加-1,0

//删除数组某个位置的元素用remove

ab.remove(8, 2)//在脚本为8的地方删除2元素

println(ab)

}

遍历数组

1.增强for循环

2.好用的until会生成脚标，0 until 10 包含0不包含10

object MyInvoke {

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

//初始化一个数组

val arr = Array(1,2,3,4,5,6,7,8)

//增强for循环

for(i <- arr)

println(i)

//好用的until会生成一个Range

//reverse是将前面生成的Range反转

for(i <- (0 until arr.length).reverse)

println(arr(i))

}

数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

object MyInvoke {

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

//初始化一个数组

val arr = Array(1,2,3,4,5,6,7,8)

val xx= for(i<-arr)

yield i*10

println(xx.toBuffer)

}

数组常用算法

在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

object Test

{

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

val ar= Array(1,4,5,6,32,11);

val dd=ar.sortBy(x=>{x-1});//自定义规则

println(dd.toBuffer)

print(ar.sorted.toBuffer);//升序

print(ar.sorted.reverse.toBuffer);//降序

print(ar.sortWith((x,y)=>{x<y}).toBuffer)//按照x<y的方式进行排序

}

映射

在Scala中，把哈希表这种数据结构叫做映射

构建映射

获取和修改映射中的值

好用的getOrElse

注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变

例子：

注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型

元组

映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

创建元组

获取元组中的值

将对偶的集合转换成映射

object MyInvoke {

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

val arr=Array((1,2),(3,4))

val map=arr.toMap

for(x<-map.keys)

{

println(map.get(x))

}

拉链操作

zip命令可以将多个值绑定在一起

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

集合

Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质

在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）

序列

不可变的序列 import scala.collection.immutable._

在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

val lst=List()

if(lst==Nil)

{

println("为空")

可变的序列 import scala.collection.mutable._

Set

不可变的Set

注：import scala.collection.immutable.HashSet

可变的Set

注导入：mutable

Map

导入mutable

其它方法调用

List(List(3, 4), List(5, 6))

2个元素一组

对分组后数据进行平坦

List(3, 4, 5, 6)

示例：

每个单词出现次数

mapValues以key为中心对value做计算

聚合：

多个集合

等价于

0初始值 x是初始值或以前的运算结果

Aggregate让多个元素聚合。

Aggregate先聚合局部，再聚合局部之后结果

求差异

并集

求交集

去重

红红火火恍恍惚惚240

关注

24
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
Scala基础（一）从零开始

常用类型(scala指定类型是在变量名后面加冒号类型)Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型。没有包装类//定义变量格式：【val/var】变量名【：数据类型】=值val a=1233val b="张三"//val不能重新赋值var d="体重"//var可以重新赋值e=90a+bdef add(a:Int,b:Int) =a+b a+b就是方法体。
复制链接

扫一扫