Scala编程进阶（个人超详细笔记）

难以触及的高度

于 2024-05-29 09:36:55 发布

阅读量1.3k

点赞数 27

分类专栏： scala 文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/2301_77836489/article/details/139225915

版权

scala 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Scala编程

期待您的关注

☀小白的Scala学习笔记

❤人之所以能是因为相信能

1.Scala中的一些API

package com.oracle.jt

object Test141 {
  def main(args: Array[String]): Unit = {
    //本质上要new 不过在Object里面已经new过了 可以不new Class需要new
    val array=Array(3,5,67,8,2) //apply()=new Array()

    array.foreach(x=>println(x))
    println("----完美分割线----")
    val array2=array.map(x=>x+12)
    array2.foreach(x=>println(x))
    println("----完美分割线----")
    val array3=array.sortBy(x=>(-x))//每个元素按照-x值排序 降序
    array3.foreach(x=>println(x))
    println("----完美分割线----")
    array.reverse.foreach(x => println(x))
    println("----完美分割线----")
    val sum=array.reduce((a,b)=>{println(a,b);a+b})
    println(sum)
  }

}

2.什么是API

API（应用程序编程接口）是一组定义了软件组件如何相互交互的规则和工具集合。简单来说，API就像是软件系统的门户，允许不同的应用程序之间进行通信和交互。它定义了数据的传输格式、通信协议以及可以调用的函数或方法等。

想象一下，你去餐厅点餐，服务员是一个接口，你是一个应用程序。你只需要告诉服务员你要点什么菜，而不需要亲自去厨房告诉厨师。服务员将你的需求传达给厨师，厨师再根据菜单做出相应的菜品。在这个过程中，服务员充当了你和厨师之间的接口，简化了交互过程。

在软件开发中，API起着类似的作用。它定义了程序之间的交互方式，使得不同的软件组件可以相互通信和协作。例如，操作系统提供了各种API，允许应用程序访问硬件设备、文件系统、网络等资源。同样，互联网服务提供商（如Google、Twitter等）也提供了API，允许开发者访问其数据或服务，从而构建新的应用程序或增强现有的应用程序功能。

总之，API是软件开发中非常重要的概念，它促进了不同软件之间的集成和协作，为开发者提供了丰富的资源和功能。

3.映射（KV对）

1）不可更改

package com.oracle.jt

object Test142 {
  def main(args: Array[String]): Unit = {
    //映射 相当于Java的 HashMap
    //不可以追加 更改
    val m=Map("name"->"zhangsan","sex"->"nan")
    val keys=m.keys
    for(elm<-keys){
      println(elm,m{elm})
    }
  }
}

2）可以更改

package com.oracle.jt
import scala.collection.mutable.Map

object Test143 {

  def main(args: Array[String]): Unit = {
    val map=Map[String,String]()
    //追加
    map.+=(("1929200","zhangsan"))
    map.+=(("1929201","lisi"))
    map.+=(("1929202","wangwu"))
    //更改
    map("1929201")="liuliu"

    for(elm<-map.keys){
      println(elm,map{elm})
    }
  }
}

3）取值

package com.oracle.jt
import scala.collection.mutable.Map

object Test143 {

  def main(args: Array[String]): Unit = {
    val map=Map[String,String]()
    //追加
    map.+=(("1929200","zhangsan"))
    map.+=(("1929201","lisi"))
    map.+=(("1929202","wangwu"))
    //更改
    map("1929201")="liuliu"

    for(elm<-map.keys){
      println(elm,map{elm})
    }
    //还有一种取值方法
    val k=map.get("1929200")
    println(k.get) //有的话调用get方法 没有会报错

    val kk=map.getOrElse("192920110","default")
    println(kk)
  }
}

4）map练习

package com.oracle.jt
import scala.collection.mutable.Map


object Test144 {
  def main(args: Array[String]): Unit = {
    val str="hello,tom,jerry,tom,hello"
    val map=Map[String,Int]()

    val array=str.split(",")
    for(elm<-array){
      if(map.keySet.contains(elm)){
        map(elm)=map(elm)+1
      }else{
        map(elm)=1
      }
    }
    println(map)
  }

}

Scala简便写法

package com.oracle.jt
import scala.collection.mutable.Map
object Test145 {
  def main(args: Array[String]): Unit = {
    val str="hello,tom,jerry,tom,hello"
    val map=Map[String,Int]()

    val array=str.split(",")
    val tuples: Array[(String, Int)] = array.map(x => (x, 1))
    val stringToTuples = tuples.groupBy(x => x._1)
    val words = stringToTuples.map(x => (x._1, x._2.map(x => x._2).sum))
    println(words)

    //更加简便
    val res = array.map(x => (x, 1)).groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(res)
  }
}

val array=str.split(",")

将集合的值转换为KV对 
val tuples: Array[(String, Int)] = array.map(x => (x, 1))

将KV对根据K 排序 排序结果也为KV对 K 字符串 V 集合Array
val stringToTuples = tuples.groupBy(x => x._1)

我们排序对V中只需要后面的值 所以再做一个转换 
val words = stringToTuples.map(x => (x._1, x._2.map(x => x._2).sum))
println(words)

4.元组

package com.oracle.jt


object Test146 {
  //元组 元组就是list 把它当成list就可以 但是元组只能存储死值
  def main(args: Array[String]): Unit = {
    val tuple=(2,3,4,5,7,8)//在做开发时 使得代码简单

    //取值
    println(tuple._1,tuple._2)
    


  }

}

访问元组使用下划线元组名._1,........

5.数据类型转换

package com.oracle.jt

object Test147 {
  def main(args: Array[String]): Unit = {
    //两个元素的元组 可以看成是KV对
    val list=Array(("192922","zhangsan"),("12123445","lisi"))
    val map=list.toMap
    println(map)

    val i=233
    val str=i.toString
    println(str)

    val s="2233"
    val num=s.toInt
    println(num)

    val long=333333
    val f=long.toFloat
    println(f)
  }

}

1）练习：

val a="23"

val b="26"

求a+b算数运算

package com.oracle.jt

object Test148 {
  def main(args: Array[String]): Unit = {
    val a="23"
    val b="34"
    val aa=a.toInt
    val bb=b.toInt
    val c=aa+bb
    println(c)
  }

}

2）练习：分组求和（SQL思想）

package com.oracle.jt

object Test148 {
  def main(args: Array[String]): Unit = {
  //SQL思想 1）分组 2）求和

    val list=Array(("1929233",12),("28838383",34),("1929233",19),("28838383",10))
    val res=list.groupBy(x=>x._1).map(x=>(x._1,x._2.map(x=>x._2).sum))
    println(res)
  }

}

3）练习Set集合

package com.oracle.jt

object Test149 {
  def main(args: Array[String]): Unit = {
    val list=Set(("2020-12-12",12),("2020-12-12",34),("2020-12-13",19),("2020-12-13",10))

    val res=list.toArray.groupBy(x=>x._1).map(x=>(x._1,x._2.map(x=>x._2).sum))
    println(res)
  }
}

3）练习：怎么把数据转换成KV对

package com.oracle.jt

object Test150 {
  def main(args: Array[String]): Unit = {
    val order="2020-12-12,23#2020-12-12,23#2020-12-13,23#2020-12-13,23"
    val array=order.split("#")
    //求和 首先要把我们的数据变成KV对
    val tuples: Array[(String, String)] = array.map(x => {
      val ord = x.split(",")
      (ord(0), ord(1))
    })
    val stringToStrings = tuples.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2.toInt).sum))
    println(stringToStrings)

  }
}

4）求每个城市上网花费的时间

package com.oracle.jt

object Test149 {
  def main(args: Array[String]): Unit = {
    val session="济南,火狐,9#济南,谷歌,10#南宁,谷歌,60"
    val array=session.split("#")
    val tuples: Array[(String, String)] = array.map(x => {
      val ord = x.split(",")
      (ord(0), ord(2))
    })
    val res = tuples.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2.toInt).sum))
    println(res)
  }
}

6.拉链

package com.oracle.jt

object Test149 {
  def main(args: Array[String]): Unit = {
    val array1=Array("zhangsan","lisi")
    val array2=Array("你好","你坏")
    val tuples: Array[(String, String)] = array1.zip(array2)
    tuples.foreach(x=>println(x))

  }
}

7.集合

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

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

1）序列 Seq (List)：不可变长

package com.oracle.jt

object Test151 {
  def main(args: Array[String]): Unit = {
    val list=List("jhw","wjs","wcs")
    list.foreach(x=>println(x))
    println("----完美分割线----")
    //转化为KV对
    val tuples: List[(String, Int)] = list.map(x => (x, 1))
    tuples.foreach(x=>println(x))
    println("----完美分割线----")

    list.sorted.foreach(x=>println(x))
    println("----完美分割线----")

    val index = list.indexOf("jhw")
    println(index)
  }
}

List中的 flatMap 方法

将数组中的元素进行拆分重新放到数组当中

2）ListBuffer：可变长

练习：使用1.可变长添加元素 2.并添加KV对 3.统计单词出现个数

package com.oracle.jt

import scala.collection.mutable.ListBuffer

object Test283 {
  def main(args: Array[String]): Unit = {
    val listBuffer=new ListBuffer[String]()
    listBuffer.+=("hello#tom")
    listBuffer.++=(Array("hello#tom","tom#jerry","kelly#lisi"))
    val strings: ListBuffer[String] = listBuffer.flatMap(x => x.split("#"))
    strings.foreach(x=>println(x))
    val tuples: ListBuffer[(String, Int)] = strings.map(x => (x, 1))
    println(tuples)
    val stringToInt: Map[String, Int] = tuples.groupBy(x => x._1).map(x => (x._1, x._2.map(x => x._2).sum))
    println(stringToInt)
  }

}

3）集 Set：不可变长

List是用来存放多个元素的 Set也是但是Set中的元素不能重复（去重）

toMap方法前提：元素为KV对才可以转

package com.oracle.jt

object Test284 {
  def main(args: Array[String]): Unit = {
    val set=Set(1,2,5,90)
    set.foreach(x=>println(x))
    println("----完美分割线----")
    println(set.size)
    println("----完美分割线----")
    val sum = set.sum
    println(sum)
    println("----完美分割线----")
    val res = set.reduce((a, b) => a * b)
    println(res)
  }

}

HashSet练习

package com.oracle.jt
import scala.collection.mutable

object Test285 {
  def main(args: Array[String]): Unit = {
    //求用户数
    val set=new mutable.HashSet[String]()
    set.+=("u01,zhangsan")
    set.+=("u02,lisi")
    set.+=("u01,zhangsan1")
    // HashSet去重
    val strings: mutable.HashSet[String] = set.map(x => x.split(",")(0))
    println(strings.size)

  }

}