Scala的简单学习二

Y 开心599

已于 2024-05-26 20:28:45 修改

阅读量630

点赞数 19

文章标签： scala 学习开发语言

于 2024-05-22 20:29:22 首次发布

本文链接：https://blog.csdn.net/weixin_65909965/article/details/139078249

版权

一集合

1.1 Java集合

1.在scala创建Java集合需要导入java.util包

2.不能使用scala中遍历迭代器的方法遍历Java集合

3.使用下标索引遍历Java集合

4.list集合中，add是添加元素(可以指定下表索引插入)，get是通过下标索引获取元素，size是获取集合长度

 //使用Java中的集合
    val list = new util.ArrayList[Int]()
    //添加元素
    list.add(11)
    list.add(12)
    list.add(13)
    list.add(14)
    list.add(15)
    list.add(16)
    println(list)
    println("="*100)
    //遍历集合
    var i: Int = 0
    while (i<list.size()){
      println(list.get(i))
      i+=1
    }

1.2 List

1.2.1 取元素

1.直接通过下标索引获取

集合名(索引)

2.特殊位置特殊取法

开头：集合名.head

结尾：集合名.head

    //创建Scala中的List集合
    val list: List[Int] = List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)
    println(list)
    println("="*100)
    //取元素
    val i: Int = list(1)
    println(i)
    println("="*100)//66

    //取第一个元素
    val head: Int = list.head
    println(head)//88
    println("="*100)

    //取最后一个元素
    val last: Int = list.last
    println(last)//33
    println("="*100)

1.2.2 tail 去掉开头返回集合

1.去除第一个元素，返回一个集合

 val tail: List[Int] = list.tail
    println(tail)//List(66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)
    println(list)//List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)

1.2.3 mkString 分隔符连接

 //使用分隔符连接集合中的元素
    val str: String = list.mkString("-")
    println(str)//88-66-22-99-11-33-110-11-22-44-22-55-11-33
    println("="*100)

1.2.4 reverse反转集合

//反转集合
    val reverseList: List[Int] = list.reverse
    println(reverseList)//List(33, 11, 55, 22, 44, 22, 11, 110, 33, 11, 99, 22, 66, 88)

1.2.5 取元素组成新集合

take，takeRight

 //从左向右取n个元素，组成新集合
    val takeList: List[Int] = list.take(4)
    println(takeList)//List(88, 66, 22, 99)
    println("="*100)

    //从右向左取n个元素，组成新集合
    val takeRightList: List[Int] = list.takeRight(4)
    println(takeRightList)//List(22, 55, 11, 33)
    println("="*100)

1.2.6 takeWhile

1.从第一个元素开始取，直到函数的返回值是false的时候

//从第一个元素开始取，直到函数的返回值是false的时候,组成新集合
    //p: A => Boolean
    val takeWhileList: List[Int] = list.takeWhile((p: Int) => p % 2 == 0)
    println(takeWhileList)//List(88, 66, 22)
    println("="*100)

1.2.7 distinct去重返回集合

val distinctList: List[Int] = list.distinct
    println(distinctList)//List(88, 66, 22, 99, 11, 33, 110, 44, 55)
    println("="*100)

1.2.8 sum求和

1.针对Int的List集合

//求和，针对Int的集合
    val sum: Int = list.sum
    println(sum)//627
    println("="*100)

1.2.9 最大小值

 //求最大小值
    val max: Int = list.max
    val min: Int = list.min
    println(max)//110
    println(min)//11
    println("="*100)

1.2.10 遍历集合

1.使用foreach遍历比较好

  //遍历集合
    list.foreach(println)
    println("="*100)
    for (elem <- list) {
      println(elem)
    }
    println("="*100)

2.foreach里面可以加匿名函数

  //求集合中偶数和
    var sum1:Int=0
    list.foreach((i:Int)=>{
      if (i%2==0){
        sum1+=i
      }
    })
    println(sum1)

1.2.11 map

1.处理集合中每个元素，返回一个列表

//map:处理集合中每个元素，返回一个列表
    //集合中每个元素+100
    val mapList: List[Int] = list.map((i: Int) => {
      i + 100
    })
    println(mapList)
    println("="*100)

    //需求，集合中的元素偶数+100 奇数-100
    val mapList1: List[Int] = list.map((i: Int) => {
      if (i % 2 == 0) {
        i + 100
      } else {
        i - 100
      }
    })
    println(mapList1)

1.2.12 filter 筛选

 //filter:筛选集合中的元素，组成新集合，true的部分成为新集合的元素
    //筛选偶数
    val filterList: List[Int] = list.filter((i: Int) => {
      i % 2 == 0
    })
    println(filterList)
    println("=" * 100)

1.2.13 flatMap 扁平化

    //flatMap：扁平化
    val strList: List[String] = List("python|java|linux", "mysql|redis|clickhouse", "hadoop|hive|zookeeper")
    val flapMapList: List[String] = strList.flatMap((str: String) => {
      str.split("\\|")
    })
    println(flapMapList)//List(python, java, linux, mysql, redis, clickhouse, hadoop, hive, zookeeper)
    println("=" * 100)

    //使用迭代器，扁平化
    strList.foreach((str: String) => {
      val splitList: Array[String] = str.split("\\|")
      splitList.foreach(println)
    })
    println("=" * 100)

1.2.14 排序 sort,sortWith

1.默认是升序

  //排序:sortBy,默认从小到大，前面加一个-就是从大到小
    //    sortWith：指定两个元素之间的大小关系进行排序
    val sortByList: List[Int] = list.sortBy((i: Int) => {
      i
    })
    println(sortByList)
    println("=" * 100)

    val sortByList1: List[Int] = list.sortBy((i: Int) => {
      -i
    })
    println(sortByList1)
    println("=" * 100)

    val sortWithList: List[Int] = list.sortWith((x: Int, y: Int) => x < y)//从小到大
    println(sortWithList)
    println("=" * 100)

    val sortWithList1: List[Int] = list.sortWith((x: Int, y: Int) => x > y)//从大到小
    println(sortWithList1)
    println("=" * 100)

1.2.15 groupBy 分组

1.得到的是一个字典

.group((变量:要分组的数据类型)=>{

变量的操作

})

    //分组 groupBy
    val stringList1: List[String] = List("hello", "world", "java", "world", "java", "world", "java", "hello", "hello", "spark", "flink", "hello", "spark", "flink")
    val map: Map[String, List[String]] = stringList1.groupBy((str: String) => {
      str
    })
    println(map)

    /**
     * Map(world -> List(world, world, world), 
     * java -> List(java, java, java), 
     * flink -> List(flink, flink), 
     * spark -> List(spark, spark), 
     * hello -> List(hello, hello, hello, hello))
     */
    map.foreach(println)

    /**
     * (world,List(world, world, world))
     * (java,List(java, java, java))
     * (flink,List(flink, flink))
     * (spark,List(spark, spark))
     * (hello,List(hello, hello, hello, hello))
     */

1.3 Set

1.List里面有的Set也有，但是Set是无序且唯一的

1.3.1 交、并、差

1.交：集合1名.&(集合2名)

集合1名 & 集合2名

2.并

集合1名.|(集合2名)

集合1名 | 集合2名

3.差

集合1名.&~(集合2名)

集合1名 &~ 集合2名

 //交集，并集，差集
    val set2: Set[Int] = Set(1, 2, 3, 4, 5)
    val set3: Set[Int] = Set(3, 4, 5, 6, 7)

    //交集
    println(set2.&(set3))
    println(set2 & set3)
    println(set2.intersect(set3))

    //并集
    println(set2.|(set3))
    println(set2 | set3)

    //差集
    println(set2.&~(set3))
    println(set2 &~ set3)

1.3.2 Set与List的转化

1.List搭配Set自动去重相同的

 //转化
    val list1: List[Int] = List(88, 66, 22, 99, 11, 33, 110, 11, 22, 44, 22, 55, 11, 33)
    val set1: Set[Int] = list1.toSet
    println(set1)
    println(set1.toList)

1.4 mutable 可变集合

1.通过观察源码发现，不可变集合属于scala.collection.immutable中

2.如果我们想要使用可变的集合，就要去scala.collection.mutable下找对应的集合进行使用

1.4.1 ListBuffer

1.创建ListBuffer new ListBuffer[Int]

2.添加元素

集合名.append(元素)

集合名.+=(元素)

3.指定位置添加

集合名.insert(索引,元素)

4.添加列表

集合名.++=(另一个集合名)

   //创建ListBuffer集合
    val listBuffer: ListBuffer[Int] = new ListBuffer[Int]
    //添加元素有两种方法
    listBuffer.append(1)
    listBuffer.append(2)
    listBuffer.append(3)
    listBuffer.+=(4)
    listBuffer.+=(4)
    println(listBuffer)
    println("="*100)

    //指定位置添加元素
    listBuffer.insert(2,9)
    println(listBuffer)
    println("="*100)

    //批量添加(添加另一个集合)
    val list: List[Int] = List(5, 6, 7, 8)
    listBuffer.++=(list)
    println(listBuffer)
    println("="*100)

5.更新元素

集合名.updata(索引,元素)

这个没有返回值

 //更新元素
    listBuffer.update(1,10)
    println(listBuffer)
    println("="*100)

6.指定下标删除元素

列表名.remove(索引)

7.从左向右删除第一个

列表名.-=(元素)

 //删除元素
    //指定下标删除元素
    val i: Int = listBuffer.remove(1)
    println(i)
    println(listBuffer)
    println("="*100)

    //删除元素 从左向右，只会删除第一次出现的对应字符串
    println(listBuffer.-=(4))
    println("="*100)

1.4.2 HashSet

1.添加元素使用 add或者+=

2.移除元素使用-=

1.5 Tuple

1.5.1 概念

1.固定长度的集合，元素不是固定的，可以是任意值

2.创建元组

Tuple长度(元素的个数等于长度)

或者直接 (元素)

val tuple: (Int, Int, Int, Int, Int, Int) = Tuple6(1, 2, 3, 4, 5, 6)
    println(tuple)

    val tuple1: (Int, Int, Int, Int) = (11, 12, 13, 14)
    println(tuple1)

1.5.2 获取元素

println(tuple1._2)

1.6 Map

1.6.1 不可变Map

1.创建Map

//创建Map
    val map: Map[String, Int] = Map("1001" -> 18, "1002" -> 19, "1003" -> 20)

2.通过键找值，getOrElse

    //通过键获取值
    println(map.get("1001"))//Some(18)

    //通过键获取值，如果没找到返回默认值
    println(map.getOrElse("1004", "没有这个元素"))//没有这个元素

3.map方法：将Map的键值对变成一个二元元组，操作里面的键与值最后返回的还是Map

注意最后匿名函数里面要返回一个二元元组

val map2: Map[String, Int] = Map(("1001", 18), ("1002", 19), ("1003", 10), "1004" -> 15)
    //将每个年龄+1
    val map1: Map[String,Int] = map2.map((kv: (String,Int)) => {
      val key: String = kv._1
      val value: Int = kv._2
      (key,value+1)
    })
    println(map1)//Map(1001 -> 19, 1002 -> 20, 1003 -> 11, 1004 -> 16)

4.获取所有的keys与values

//获取所有的key
    val keys: Iterable[String] = map2.keys
    println(keys)
    val values: Iterable[Int] = map2.values
    println(values)

1.6.2 可变Map

1.添加元素

.+=(())

.put()

//添加元素
    hashMap.+=(("xia",19))
    hashMap.put("mi",18)
    println(hashMap)

2.删除元素

只需要写一个键

hashMap -= "xia"
    println(hashMap)

1.7 Java与scala集合的转化

1.7.1 Java->scala

1.导入的包是 scala.collection.JavaConverters._

  //创建一个java中的集合
    val list1: util.ArrayList[String] = new util.ArrayList[String]()
    list1.add("java")
    list1.add("world")
    list1.add("hello")
    list1.add("spark")
    list1.add("java")
//    println(list1)
    /**
     * java集合->scala
     * 借助隐式转换，调用原本没有的功能
     */

    val scalaList: List[String] = list1.asScala.toList
    println(scalaList)

1.7.2 Scala->java

/**
     * scala中集合->java集合
     */
    val list2: List[Int] = List(1,2,3,4,5,6,7)
    val javaList: util.List[Int] = list2.asJava
    println(javaList)

二 JCBC

1.模板直接套

package com.shujia.day02

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

object Demo19JCBC {
  def main(args: Array[String]): Unit = {
    /**
     *  scala中连接数据库
     */
    //加载驱动
    Class.forName("com.mysql.jdbc.Driver")

    //创建与数据库连接对象
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://192.168.73.100/bigdata29?useUnicode=true&characterEncoding=utf8&useSSL=false", "root", "123456")

    //为了防止sql注入
    val state: PreparedStatement = conn.prepareStatement("select id,job_name,company_name," +
      "salary,addr,experience,education,company_type from job_listing where education=?")

    state.setString(1,"本科")

    //执行sql语句
    val resultSet: ResultSet = state.executeQuery()

    while (resultSet.next()){
      val id: Int = resultSet.getInt("id")
      val job_name: String = resultSet.getString("job_name")
      val company_name: String = resultSet.getString("company_name")
      val salary: String = resultSet.getString("salary")
      val addr: String = resultSet.getString("addr")
      val experience: String = resultSet.getString("experience")
      val education: String = resultSet.getString("education")
      val company_type: String = resultSet.getString("company_type")
      println(id+job_name+company_name+salary+addr+experience+education+company_type)

    }

    //释放资源
    state.close()
    conn.close()
  }

}

三匹配模式

3.1 基本数据类型

1.自上而下匹配

 var i: Int = 100
    i match {
      case 10 => println("i的值是10")
      case 100 => println("i的值是100")
      case _ => println("i的值是其他")
    }

3.2 匹配字符串

  //匹配字符串
    var str:String="java"
    str match {
      case "java"=>println("hello")
      case "spark"=>println("hh")
      case _=>println("ll")
    }

3.3匹配元组

1.元组不可变，只能case一个

2.匹配的是数据类型

 //匹配元组
    //匹配的是数据类型
    val tuple: (Int, Int, Int) = (11, 12, 13)
    tuple match {
      case (x:Int,y:Int,z:Int)=>println(x+y+z)//36
    }

3.4 匹配数组

1.匹配的是数据类型

2.可以匹配多个

 //匹配数组
    val array: Array[String] = Array("1001", "张三")
    array match {
      case Array(id:String,name:String)=>println(id+name)
      case Array(id:String,name:String,adr:String)=>println(id+name+adr)
      case _=>println("hello")
    }

3.5 匹配匹配值的类型

 //匹配匹配值的类型
    val obj:Any=100
    obj match {
      case a:Int=>println("obj是Int类型")
      case b:String=>println("obj是String类型")
      case _=>println("obj是其他类型")
    }

3.6 Map中的get方法

val map: Map[String, String] = Map("1001" -> "张三", "1002" -> "李四")
    val str1: String = map.get("1007") match {
      case Some(x) => x
      case None => "默认值"
    }
    println(str1)

    //等同于
    val str2: String = map.getOrElse("1007", "默认值")
    println(str2)

3.7 与函数一起用

1.map函数中将小括号变成大括号

val list: List[Array[String]] = Source
      .fromFile("scala/data/score.txt")
      .getLines()
      .toList
      .map((line: String) => {
        line.split(",")
      })
    list.map {
      case Array(id: String, _, score: String) => (id, score)
    }.foreach(println)
    //下面写法一样
    //    val list: List[String] = Source.fromFile("scala/data/score.txt").getLines().toList
    //    val list1: List[Array[String]] = list.map((line: String) => {
    //      line.split(",")
    //    })
    //    val tuples: List[(String, String)] = list1.map {
    //      case Array(id: String, _, score: String) => (id, score)
    //    }
    //    tuples.foreach(println)

四隐式转化

4.1 隐式转化函数

1.只针对参数类型和返回值类型，和隐式函数叫什么无关

2.同一种参数和返回值类型组合的隐式转换函数，同一作用域下只能出现一种

3.scala编译器，在编译代码的时候，会识别到需要将A类型转B类型，然后就去找参数是A类型，返回值是B类型的隐式转换函数，自动调用，否则找不到报错

//定义一个fun函数
    def fun(i: Int): Unit = {
      println(i + 100)
    }

    //定义一个将参数类型变成跟返回值类型一样的隐式转化函数
    implicit def strToInt(s:String): Int = {
      Integer.parseInt(s)
    }

//    implicit def strToInt2(s:String): Int = {
//      Integer.parseInt(s)
//    }//出现报错因为同一种参数和返回值类型组合的隐式转换函数，同一作用域下只能出现一种

    fun("100")//200

4.应用

    //应用
    import com.shujia.day02.Text1._
    val list: List[String] = "scala/data/students.csv".getLines().toList
    list.foreach(println)
  }
    //相当于
    val list1: List[String] = read("scala/data/students.csv").getLines().toList
    list1.foreach(println)

}

object Text1 {
  implicit def read(path: String): BufferedSource = {
    Source.fromFile(path)
  }
}

4.2 隐式转化类

1.隐式转换类可以隐式的将类的构造函数参数类型转换成当前类的类型，自动调用构造方法创建对象

package com.shujia.day02

import scala.io.Source

object Demo23Implicit {
  def main(args: Array[String]): Unit = {
    //普通方法
    val read = new Read("scala/data/students.csv")
    val list: List[String] = read.read()
    list.foreach(println)
    //隐式转化类方法
    val list1: List[String] = "scala/data/students.csv".read()
    list1.foreach(println)
    println("scala/data/students.csv".p("j"))
  }


  implicit class Read(path:String){
    def read(): List[String] = {
      Source.fromFile(path).getLines().toList
    }

    def p(str: String): String = {
      str + path
    }
  }
}

4.3 隐式转化变量

package com.shujia.day02

object Demo24Implicit {
  def main(args: Array[String]): Unit = {
    def add(x:Int)(implicit y:Int):Int={
      x+y
    }

    implicit val i:Int=100
    //正常传值
    println(add(2)(100))
    //使用隐式转化变量
    println(add(2))
  }

}