Scala

最新推荐文章于 2023-09-04 08:09:35 发布

升级打怪的辉哥

最新推荐文章于 2023-09-04 08:09:35 发布

阅读量267

点赞数

本文链接：https://blog.csdn.net/m0_57356943/article/details/118060623

版权

Scala

代码要先看等号右边的

Scala是把函数式编程思想和面向对象编程思想结合的一种编程语言。
大数据计算引擎Spark由Scala编写。

在面向对象编程中，我们把对象传来传去；那在函数式编程中，我们要做的是把函数传来传去，而这个，说成术语，我们把他叫做高阶函数。
在函数式编程中，函数是基本单位，，他几乎被用作一切，包括最简单的计算，甚至连变量都被计算所取代。在函数式编程中，变量只是一个名称，而不是一个存储单元，这是函数式编程与传统的命令式编程最典型的不同之处。

特点：函数式编程兼容YAVA 代码行短支持并发控制

基于JVM的语言：

在这里插入图片描述

demo1Java

package com.shujia.scala;
/**
 *  java中方法不加static是普通方法，普通方法调用需要通过类的对象调用
 *
 *  main函数是由虚拟机调用的，加上static才能通过类名直接调用（实际上是由“类对象”调用的）
 *
 *  类对象---class文件被加载到内存中的一个对象
 */
public class Demo1Java {
    public static void main(String[] args) {
        System.out.println("java");

        //在java中使用Scala的
        Demo4Student demo4Student = new Demo4Student();
        String s = demo4Student.print("java");
        System.out.println(s);
    }
}

demo2Scala

package com.shujia.scala
/**
  *  main函数必须放在object中才能运行
  *
  *  object: 修饰的类直接就是一个对象，单例
  */
object Demo2Scala {
  /**
    * def : 定义方法的关键字
    * main : 函数名
    *  args: Array[String] : 函数的参数
    *  args : 参数名
    *  Array[String] ：参数类型， [String]：泛型
    *  Unit：相当于void
    *  {} 中是函数体
    */
  def main(args: Array[String]): Unit = {
    println("scala")

    //在Scala中使用java中的类 （说明Scala和java是兼容的（类的兼容））
    /**
      * 类型推断：变量的类型会自动通过等号右边推断出来
      *
      * var：定义一个变量，变量可以重新指向其他的对象
      * val：定义不可变的变量，不能再指向其他的对象
      * 一般使用val
      */
    var student = new Demo3Student("001", "张三", 23)

    /**
      * 也可以加上类型，可读性提高了
      */
    val age: Int = student.getAge
    println(student.getName)
    println(student)

    /**
      * String : scala 中的String就是java中的String
      */
    val s:String ="scala"
    val split= s.split(",")

    /**
      * println函数底层和java是一样的
      */
    println(split)
    //也可以使用java的方式
    System.out.println(split)

  }
}

demo3Base （重点，字符串拼接）

package com.shujia.scala
import java.io.{BufferedReader, FileReader}
import java.sql.DriverManager
import scala.io.{BufferedSource, Source}

object Demo3base {
  def main(args: Array[String]): Unit = {
    /**
      * 变量：
      * val: 常量，不能再指向其它的对象，相当于java中给变量增加final修饰
      * var ：变量，可以再指向其它的对象
      *
      * 一般尽量使用val
      */
    val i: Int = 100
    println(i)	//100
    val j = i + 1
    println(j)		//101
    //不能指向其它对象
    // i = 200
    var a = 200
    a = 300
    println(a)		//300


    /**
      * 类型推断
      */
    //自动推断类型
    val str1 = "java"
    //手动加上类型
    val str2: String = "java"
    //多态，父类的引用指向子类的对象.(这时候str3使用的就是父类的方法，没有子类的方法了)
    val str3: Object = "java"


    /**
      * 类型转换
      *
      * 在scala中只要你确定类型转换没有问题，都可以直接to
      */
    val s: String = "100"
    //java中类型转换
    val si: Int = Integer.parseInt(s)
    //scala中的类型转换
    //隐式转换： 可以给对象动态增加方法
    val sj: Int = s.toInt
    println(sj)		//100


    /**
      * 文件读写
      *
      */
    val fileReader = new FileReader("scala/data/students.txt")
    val bufferedReader = new BufferedReader(fileReader)
    //读取第一行
    var line: String = bufferedReader.readLine()
    //判断是否为空
    while (line != null) {
      println(line)
      //读取下一行
      line = bufferedReader.readLine()
    }
    bufferedReader.close()
    println("=" * 100)

    /**
      * scala中读取文件
      */
    val source: BufferedSource = Source.fromFile("scala/data/students.txt")
    /** 迭代器和集合的区别：
      * 迭代器的数据可能并没有完全加载到内存中（说明它可以节省内存）
      *
      * 迭代器只能迭代一次，也就是迭代器里面的数据只能取一次，取完一次就不能再取了
      */
    //读取所有行，返回一个迭代器
    val lines: Iterator[String] = source.getLines()
    //循环遍历迭代器
    for (line <- lines) {
      println(line)
    }
    println("=" * 100)

    //链式调用
    val liness = Source
      .fromFile("scala/data/students.txt")
      .getLines()

      
    /** 这两行代码很重要：
      * JDBC:使用方式和java中没有区别
      *
      */
    //1、加载驱动
    Class.forName("com.mysql.jdbc.Driver")
    //2、创建链接
    val con = DriverManager.getConnection("jdbc:mysql://master:3306/student", "root", "123456")
    //查询数据
    println(con)

      
    /**
      * 字符串拼接
      */
    val k = 100
    //底层就是stringBuilder，它用于字符串的拼接
    val ss = s"java,asdasda,$k"		//简单的不用{}括起来，其他的就要括起来
    println(ss)		//java,asdasda,100


    //java的方式
    val stringBuilder = new StringBuilder

    stringBuilder.append("java")
    stringBuilder.append(k)

    println(stringBuilder.toString())		//java100
  }
}

demo6Class

类和对象不用深究，以后也不用写

package com.shujia.scala
object Demo6Class {
  def main(args: Array[String]): Unit = {

    val stu = new Student("001", "张三", 23)
    println(stu._age)
    println(stu._name)
    println(stu)	//Student(001, 张三, 23,null)

    val stu2 = new Student("002", "李四", 24, "男")
    println(stu2)	//Student(002, 李四, 24,男)

    /**
      * 类中的普通方法需要通过类的对象才能调用
      * object中的方法可以直接调用
      */
    val i = TextObject.fun("100")
    println(i)
  }
}


/**
  * 在类中可以定义属性，方法，构造函数
  */
class Student(id: String, name: String, age: Int) {	//这个大括号里面就是Scala默认构造函数
  println("默认构造函数")
  //定义属性并赋值，加上下划线为了防止和参数冲突
  val _id: String = id
  val _name: String = name
  val _age: Int = age
  //下划线是一个占位符，起到占用位置的作用
  var _gender: String = _

      
  /**
    * 重载构造函数
    * 在重载构造函数的第一行需要显示调用默认构造函数
    */
  def this(id: String, name: String, age: Int, gender: String) {
    this(id, name, age)		//必须放在第一行
    println("重载构造函数")
    this._gender = gender
  }


  /**
    * override：重写父类的方法
    */
  override def toString: String = {		//方法没有参数，括号可以省略toString()
    //默认函数最后一行作为返回值，所以return可以省略
    s"Student(${_id}, ${_name}, ${_age},${_gender})"	//scala中字符串的拼接形式，s是一个方法
  	//java方式："student("+_id+_name...
  }														//通过$引用上面的变量，用{}括起来
}


/**
  * 定义一个单例模式的对象
  * 对象中的方法可以直接调用
  */
object TextObject {
  def fun(s: String): Int = {
    s.toInt
  }
}

demo7Extends

package com.shujia.scala
object Demo7Extends {
  def main(args: Array[String]): Unit = {
    val b = new B("001", "李四", "男")
    println(b)	//A(001, 李四，男)
  }
}


class A(id: String, name: String) {
  println("A的默认构造函数")
  val _id: String = id
  val _name: String = name

  override def toString = s"A(${_id}, ${_name})"
}


/**
  * 继承类同时调用构造函数
  */
class B(id: String, name: String, gender: String) extends A(id, name) {
  println("B的默认构造函数")
  val _gender: String = gender

  //重写父类的方法,这样打印的时候，就可以把性别也打印出来了
  override def toString = s"A(${_id}, ${_name}，${_gender})"
}

demo8CaseClass(重要)

在Scala中样例类是一种特殊的类，可用于模式匹配。
定义形式：
case class 类型，是多例的，后面要跟构造参数。 case class Student(name:String)
case object 类型，是单例的。

package com.shujia.scala
object Demo8CaseClass {
  def main(args: Array[String]): Unit = {

    //样例类可以不使用new创建对象
    val p = Person("id", "李四", 23)
    println(p.age)
    println(p.id)
    println(p.name)
    println(p)

    //如果需要修改属性的值，需要将修饰符改成var
    p.age = 200
  }
}

/**
  * 样例类：scala在编译的时候会自动给样例类增加方法（toString方法,hashCode方法）
  * 位置没有限制
  * 可以省写很多代码，简化了代码
  */
case class Person(id: String, name: String, var age: Int)

demo9Apply

package com.shujia.scala
    
object Demo9Apply {
  def main(args: Array[String]): Unit = {
    /**
      * 不使用new创建对象，实际上是调用伴生对象的apply函数
      *
      */
    val dog: Dog = Dog("小狗", 2)
  }
}

class Dog(name: String, age: Int) {
}

//伴生对象：就是定义一个和这个类（dog）名字一样的object，这个object是个对象，那么我们称这个对象是这个类（Dog）的伴生对象
object Dog {
  def fun(): Unit = {
    println("dog")
  }

  /**
    * applyh函数可以直接通过对象名+括号调用
    *
    */
  def apply(name: String, age: Int): Dog = {
    val dog = new Dog(name, age)
    return dog
  }
}

函数 (重点)

demo10Fun1

package com.shujia.scala

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

      * 函数的定义，scala中的函数可以在任何位置定义
      *
      * def ;定义函数关键字
      * fun;函数的名称
      * str: String;函数的参数和参数的类型
      * Unit:函数的返回值，Unit代表没有返回值


    def fun(str: String): Unit = {
      println(str)
    }
    //调用函数
    fun("scala")


      * 函数的省略
      * 1、return 可以省略，默认最后一行作为返回值
      * 2、如果代码只有一行，大括号可以省略，
      * 3、返回值类型可以省略，scala会自动推断返回值的类型
      * 4、如果函数没有参数，小括号可以省略
      */

    def sToInt(s: String): Int = {
      return s.toInt
    }
    def sToInt1(s: String) = s.toInt
    println(sToInt1("100"))

  }
}

demo11Fun2 （高阶函数）

package com.shujia.scala1

object Fun1 {
  def main(args: Array[String]): Unit = {
      
    /** 面向对象编程：将对象传来传去，对象是有类型的，方法的参数是有类型限制的
      * 面向函数编程：将函数传来传去，函数也是有类型的
      */
//一个函数的类型是由函数的参数类型 和 返回值类型决定的
      
     高阶函数：
      * 1、以函数作为参数：定义一个方法，方法的参数是一个函数
      * 2、 以返回值作为参数
      
    /**
      * 以函数作为参数- --  定义一个方法方法的参数是一个函数
      *
      * fun1 的参数是一个函数，是一个参数为String 返回值为Int类型的函数
      *
      *  =>   ----> 描述函数的类型
      *
      */  
    def fun1(f: String => Int): Unit = {
      //调用传进来的函数
      val i: Int = f("100")
      println(i)
    }
    //这是一个参数为String，返回值为Int类型的函数
    def fun2(str: String): Int = {
      str.toInt
    }   
    //调用fun1，那么就要传入一个函数，传入fun2
    fun1(fun2)
首先，前面两个是定义，不会运行。当我们调用fun1的时候，传入fun2，fun2就是f。然后f 反过来 把100传给fun2。
f就相当于fun2, 当100传给f了，也就传给fun2了，然后fun2的返回值int 又 传给 i 了 

        
        
    /**
      * lambda表达式：对函数定义的简写 -- 匿名函数
      *
    def fun(str: String): Int = {
      str.toInt
    }
      * 比如：
      * (str：String) => str.toInt
      *
      * 左边是函数的参数和参数类型
      * 右边是函数的返回值和函数体
      */

    //使用lambda表达式调用函数
    fun1((str: String) => str.toInt + 1)
    //简写方式，    
    fun1(str => str.toInt + 1)
    //参数只使用一次，那么就可以用下划线代替
    fun1(_.toInt + 1)

  }

}

demo11Fun2 (整理)

package com.shujia.scala1

object Fun1 {
  def main(args: Array[String]): Unit = {
    /**
      * 面向函数编程：将函数传来传去，函数也是有类型的
      *
      * 高阶函数：
      * 1 、以参数作为参数：定义一个方法，方法的参数是一个函数
      * 2、 以返回值作为参数
      */

    def fun1(f: String => Int): Unit = {

      //调用传进来的函数
      val i: Int = f("100")
      println(i)
    }

    //这是一个参数为String，返回值为Int类型的函数
    def fun2(str: String): Int = {
      str.toInt
    }

    //调用fun1，那么就要传入一个函数，传入fun2
    fun1(fun2)


    /**
      * lambda表达式：对函数定义的简写 -- 匿名函数
      *
      * 比如：
      * (str：String) => str.toInt
      *
      * 左边是函数的参数和参数类型
      * 右边是函数的返回值和函数体
      */
        
    //    def fun(str: String): Int = {
    //      str.toInt
    //    }

    //使用lambda表达式调用函数
    fun1((str: String) => str.toInt + 1)

    //简写方式
    fun1(str => str.toInt + 2)
    fun1(_.toInt + 3)
  }
}

==========================================================
    
package com.shujia.scala1

object Fun11 {
  def main(args: Array[String]): Unit = {
    /**
      * 高阶函数
      * 1、以函数作为参数：定义一个方法，方法的参数是一个函数
      * 2、以函数的返回值
      *
      * fun的参数是一个函数，是一个参数为String，返回值为Int类型的函数
      * String => Int  ----> 描述函数的类型
      */
    def fun(f: String => Int): Unit = {

      val int = f("100")
      println(int)
    }

    //调用函数方式一：
    def fun1(str: String): Int = {
      str.toInt
    }

    fun(fun1)

    /**
      * 调用函数方式二：
      * 使用lambda表达式调用：对函数定义的简写
      * (str: String) => str.toInt
      */
    val lambda: String => Int = (str: String) => str.toInt
    fun(str => str.toInt + 1)


    def fun2(str: String): Unit = {
      println(str)
    }
    fun2("scala")
  }
}

demo13Fun3 (函数应用)

package com.shujia.scala1
object fun2 {
  def main(args: Array[String]): Unit = {

    /**
      * 以函数作为参数的应用
      */
    val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)

    /**
      * mkString：将集合中的元素通过拼接符拼接成成一个字符串
      */
    println(arr.mkString(","))

    /**
      * map函数：将集合中的元素一个一个遍历后传递给后面的函数，最终返回一个新的集合
      */
      //将arr集合中的元素乘二     map((i: Int) => i * 2)
    val arr1: Array[Int] = arr.map(i => i * 2)
    println(arr1.mkString(","))
  }

集合（重点）

demo14List

package com.shujia.scala
object Demo14List {
  def main(args: Array[String]): Unit = {
    /**
      * list 集合
      * 有序不唯一
      *
      * 在scala这种默认使用的集合是不可变的集合，就是不能增删改
      */
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 1)

    //通过下表获取数据，java中通过get获取
    println(list(1))
    //将集合中的元素通过分隔符拼接成一个字符串
    println(list.mkString("-"))
    //最大值
    println(list.max)
    //最小值
    println(list.min)
    //求和
    println(list.sum)
    //获取长度
    println(list.size)
    //获取第一个元素
    println(list.head)
    //获取最后一个元素
    println(list.last)
    //获取前几个元素，会返回一个新的集合
    println(list.take(2))
    //取出不包含第一个元素的所有元素
    println(list.tail)
    //反转集合，返回一个新的集合
    println(list.reverse)
    //判断是否为空
    println(list.isEmpty)
    //去重
    println(list.distinct)


    val l: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 1)
    /**
      * map函数，对集合中的元素进行处理，将集合中的元素一个一个传递给后面的函数
      * 处理完了之后返回一个新的集合
      *
      * 数据的对应关系是一对一
      */
    val l2: List[Double] = l.map((i: Int) => i.toDouble + 100)
    println(l2)


    /**
      * filter函数：对集合中的元素进行过滤
      * 将集合中的元素传递给后面的函数，如果函数最终返回true保留元素，如果函数返回false过滤元素
      *
      * 返回一个新的集合，新的集合类型和源集合一致
      */
    //取出集合中所有的奇数。   i % 2 == 1的结果是boolean值，是true保留，是false则过滤
    val l3: List[Int] = l.filter((i: Int) => i % 2 == 1)
    println(l3)


    /**
      * sortBy:通过一个排序的列对数据进行排序，默认是升序
      *
      */
    val l4: List[Int] = l.sortBy((i: Int) => -i) //就只有一列，就通过 i 排序，-i 代表降序
    println(l4)

    /**
      * sortWith: 传入一个比较规则
      * 返回值是一个Boolean值
      */
    val l5 = l.sortWith((x: Int, y: Int) => x > y)	// x>y 代表降序。x>y结果是一个Boolean值
    println(l5)


    /**
      * flatMap函数，将集合中的元素压扁，一行变多个
      *
      * 数据的对应关系是一对多
      *
      * map 函数需要的参数也是一个函数，函数的返回值必须是一个集合或者数组，
      * map函数会将返回的集合压扁
      *
      */
    val lines: List[String] = List("java,spark,hadoop", "spark,ava,hive", "hive,hbase")
    val words= lines.flatMap((line: String) => line.split(","))
    println(words)
    //List(java, spark, hadoop, spark, ava, hive, hive, hbase)
  }
}

demo15ListBuffer

package com.shujia.scala

import scala.collection.mutable.ListBuffer

object Demo15ListBuffer {
  def main(args: Array[String]): Unit = {
    /**
      * 可变集合 （可以增删改）
      *
      */
    val listBuffer: ListBuffer[Int] = new ListBuffer[Int]

    //增加元素      “+” 是一个方法
    listBuffer.+=(1)
    listBuffer += 2
    println(listBuffer)  //ListBuffer(1, 2)

    //增加多个元素
    listBuffer ++= List(1, 2, 3, 5)
    println(listBuffer)		//ListBuffer(1, 2, 1, 2, 3, 5)
    //删除一个元素
    listBuffer -= 2
    println(listBuffer)		//ListBuffer(1, 1, 2, 3, 5)
    //通过下表获取元素
    println(listBuffer(2))	//2
    //通过下标更新元素
    listBuffer.update(4, 10)
    println(listBuffer)	//ListBuffer(1, 1, 2, 3, 10)
    //通过下标更新元素
    listBuffer(4) = 100
    println(listBuffer)		//ListBuffer(1, 1, 2, 3, 100)


    //将listbuffer转换成list
    val list: List[Int] = listBuffer.toList
    println(list)		//List(1, 1, 2, 3, 100)
  }
}

demo16Set

package com.shujia.scala
import scala.collection.mutable
import scala.collection.mutable.HashSet

object Demo16Set {
  def main(args: Array[String]): Unit = {
    /**
      * set 无序唯一  不可变
      *
      */
    val set: Set[Int] = Set(12, 3, 123, 124, 123, 124, 12, 321, 4, 123, 123124, 32)

    println(set)//Set(321, 124, 123124, 32, 12, 3, 123, 4)
    println(set.max)//
    println(set.min)
    println(set.sum)
    println(set.mkString(","))//321,124,123124,32,12,3,123,4
    println(set.map(i => i * 2))//Set(24, 6, 248, 642, 64, 8, 246, 246248)
    println(set.filter(i => i % 2 == 1))//Set(321, 3, 123)


    val s1 = Set(1, 2, 3, 4, 5, 6, 7)
    val s2 = Set(3, 4, 5, 6, 7, 8, 9)
    println(s1 & s2) //交集  Set(5, 6, 7, 3, 4)
    println(s1 | s2) //并集  Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
    println(s1 &~ s2) //差集  Set(1, 2)


    /**
      * 可变Set
      *
      */
    val hashSet = new mutable.HashSet[String]()

    hashSet.add("java")
    hashSet += "spark"
    println(hashSet)// Set(java, spark)

    //清空
    hashSet.clear()
    println(hashSet)//Set()
  }
}

demo17Map

package com.shujia.scala

import scala.collection.mutable
import scala.collection.mutable.HashMap

object Demo17Map {
  def main(args: Array[String]): Unit = {
    /**
      * map： kv格式
      *
      */    二元组
    val map = Map(("001", "张三"), ("002", "李四"), "003" -> "王五") //"->"是一个方法
    println(map)  	     	//Map(001 -> 张三, 002 -> 李四, 003 -> 王五)
    //通过key获取value
    println(map("001")) //如果key不存在直接报错   张三
    println(map.get("001")) //如果key不存在返回None    Some(张三)
    println(map.getOrElse("004", "默认值")) //如果key不存在返回默认值   默认值
    //判断key是否存在
    println(map.contains("001"))  //true

      
    val map2: Map[String, String] = map.filter((kv: (String, String)) => kv._2.equals("张三"))
    println(map2) //Map(001 -> 张三)
    println(map.keys) //取出所有的key     Set(001, 002, 003)
    println(map.values) //取出所有的value     MapLike(张三, 李四, 王五)


    /**
      * 可变map
      *
      */
    val hashMap = new mutable.HashMap[String, Int]()
    //增加元素
    hashMap.+=(("001", 23))
    //简写
    hashMap += "002" -> 24
    println(hashMap)     //Map(002 -> 24, 001 -> 23)

    //删除元素
    hashMap -= "001"
    println(hashMap)   //Map(002 -> 24)
    hashMap.remove("002")
    println(hashMap)  //Map()
  }
}

demo18Tuple

package com.shujia.scala

object Demo18Tuple {
  def main(args: Array[String]): Unit = {
    /**
      * 元组:结构简单，可以通过下标取数据,不会出现下表越界
      *
      * 元组中最多可以有22个元素
      *
      */
    val t = (1, 2, 3, 4, 5, 6)

    println(t._1) //1
    println(t._6) //6
  }
}

demo19WordCount（重点）

package com.shujia.scala1

import scala.io.Source

object WordCount {
  def main(args: Array[String]): Unit = {
      
    //1 读取文件
    val lines: List[String] = Source.fromFile("scala/data/words.txt").getLines().toList
    lines.foreach(println) //foreach遍历集合

    //2 将每行的单词拆分为单独的一行。flatMap ：可以一行变多行
    val words: List[String] = lines.flatMap(line => line.split(","))
    words.foreach(println)

    //3 统计相同的单词，划分到一个集合中。分组
    val groups: Map[String, List[String]] = words.groupBy(word => word)
    groups.foreach(println)

    //统计单词数目
    val countgroup: Map[String, Int] = groups.map(kv=>{
      val words: String = kv._1
      //当前单词构建的集合
      val values: List[String] = kv._2
      val count: Int = values.size
      (words,count)
    })
    /**
      * foreach:  遍历集合，将集合中的元素一个一个传递给后面的函数，没有返回值
      *
      */
    //打印
    countgroup.foreach(println)
  
      
    /**
      * 简写
      */
    //链式调用
    Source
      .fromFile("scala/data/words.txt") //读取文件
      .getLines() //获取所有行
      .toList //转换成list
      .flatMap(_.split(",")) //将单词拆分出来
      .groupBy(word => word) //按照单词进行分组
      .map(kv => (kv._1, kv._2.size)) //统计单词额数量
      .foreach(kv => println(kv)) //打印结果
     
  }
}

demoStudentCount

package com.shujia.scala

import scala.io.Source

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

    /**
      * 统计班级的人数
      *
      */
    //1、读取数据
    val lines: List[String] = Source.fromFile("scala/data/students.txt").getLines().toList

    //2、取出班级
    val classs: List[String] = lines.map(line => line.split(",")(4))

    //3、按照班级进行分组
    val group: Map[String, List[String]] = classs.groupBy(clazz => clazz)

    //4、统计班级的人数
    val countMap: Map[String, Int] = group.map(kv => {
      val clazz: String = kv._1
      val values: List[String] = kv._2

      //计算班级的人数
      val count: Int = values.size

      (clazz, count)
    })

    //打印结果
    countMap.foreach(println)

    /**
      *
      * select clazz,count(1)  from student group by clazz
      *
      * sql 执行流程
      *
      * from  -->  join on --> where  --> group by ---> having --> select  --> order by --> limit
      *
      */
  }
}

模式匹配

demo20 Case

package com.shujia.scala

object Demo21match {
  def main(args: Array[String]): Unit = {
    /**
      * 模式匹配：
      *
      * java中的模式匹配可以匹配：基本数据类型，字符串，枚举
      *
      * scala中的模式匹配可以匹配：基本数据类型，字符串，枚举，对象，类型
      *
      */
      
    //匹配基本数据类型
    val i: Double = 100.1
    /**
      * 按照顺序执行case ,只有一个可以匹配成功
      *
      */
    i match {
      case 100 => {
        //如果一行不够，增加大括号写多行
        println(100)
      }
      case 10 => println(10)
      case 100.1 => println(100.1)
      case _ => println("默认")
    }

    /**
      * 匹配字符串
      *
      */
    val str: String = "java"
    str match {
      case "java" => println("java")
      case "scala" => println("scala")
    }

    /**
      * 匹配对象
      *
      */
      //首先定义一个样例类
    case class User(id: String, name: String)

    val user: User = User("001", "张三")
    user match {
      case User("001", "张三") => println("张三")
      case User("002", "李四") => println("李四")
      case _ => println("其它")
    }

    /**
      * 匹配类型
      *
      */
    //Any 相当于Object，是所有类型的超类
    val a: Any = "java"
    a match {
      //如果匹配成功i相当于a的引用
      case i: Int => println(s"$i 是int类型")
      case s: String => println(s"$a 是一个字符串")
      case u: User => println(s"$u 是一个User")
      case _ => println("其它")
    }

      
      
    val map = Map("001" -> "张三", "002" -> "李四")
    /**
      * Option:是一个可选的值，有两个取值，Some   None
      *
      */
    val opt: Option[String] = map.get("003")
    /**
      * match 可以有返回值
      *
      */
    val value: String = opt match {
      case Some(v) => v
      case None => "默认值"
    }
    println(value)
    //相当于
    println(map.getOrElse("001", "默认值"))
  }
}

隐式转换

demo21Implcat

package com.shujia.scala

object Demo23Implcat {
  def main(args: Array[String]): Unit = {
    /**
      * 显示转换（类型的转换）
      *
      */
     val s: String = "100"
     val i: Double = s.toDouble


    /**
      * 隐式转换
      * 1、隐式转换方法
      * 2、隐式转换变量
      * 3、隐式转换类
      *
      */


    /**
      * 1、隐式转换方法     定义一个方法，注意看方法名
      *
      * 隐式转换方法和方法名无关
      * 和参数类型返回值类型有关，同一个作用域中只能存在一个参数类型和返回值类型一样的隐式转换
      *
      */
    implicit def stringToInt(str: String): Int = {
      println("隐式转换方法被调用")
      Integer.parseInt(str)
    }
    def fun(i: Int) = {
      println(i + 100)
    }
    fun(1000)
    //自动调用隐式转换方法实现类型转换
    fun("123")
    //相当于
    fun(stringToInt("2000"))


      
    implicit def intToString(i: Int): String = {
      i.toString
    }
    /**
      * 隐式转换： 动态给对象增加方法
      *
      * 给Int类型的 j，加了一个方法，原本Int类型是没有这个方法的
      */
    val j = 1000
    val split: Array[String] = j.split(",")
  }
}

demo22Implcat

package com.shujia.scala

object Demo24implicit {
  def main(args: Array[String]): Unit = {
    /**
      * 隐式转换变量
      *
      * 同一个作用域中只能存在一个类型一样的隐式转换变量
      *
      */
    def fun(str: String)(implicit per: String) = {
      println(str + "\t" + per)
    }

    //隐式转换变量
    implicit val s: String = "后缀"

    fun("java")("spark")   //java	spark
    //自动使用隐式转换变量
    fun("scala")      //scala	后缀
  }
}

demo23Implcat

package com.shujia.scala

import scala.io.Source

object Demo25implicit {
  def main(args: Array[String]): Unit = {
    /**
      * 隐式转换类
      *
      */
    val words: List[String] = "scala/data/words.txt".read()
    words.foreach(println)
  }

  /**
    * 隐式转换类
    *
    * 可以将ReadFile构造函数参数的类型转换成ReadFile
    */
  implicit class ReadFile(path: String) {
    def read() = {
      Source.fromFile(path).getLines().toList
    }
  }
}

implicit def intToString(i: Int): String = {
  i.toString
}
/**
  * 隐式转换： 动态给对象增加方法
  *
  * 给Int类型的 j，加了一个方法，原本Int类型是没有这个方法的
  */
val j = 1000
val split: Array[String] = j.split(",")

}
}


### demo22Implcat

```scala
package com.shujia.scala

object Demo24implicit {
  def main(args: Array[String]): Unit = {
    /**
      * 隐式转换变量
      *
      * 同一个作用域中只能存在一个类型一样的隐式转换变量
      *
      */
    def fun(str: String)(implicit per: String) = {
      println(str + "\t" + per)
    }

    //隐式转换变量
    implicit val s: String = "后缀"

    fun("java")("spark")   //java	spark
    //自动使用隐式转换变量
    fun("scala")      //scala	后缀
  }
}

demo23Implcat

package com.shujia.scala

import scala.io.Source

object Demo25implicit {
  def main(args: Array[String]): Unit = {
    /**
      * 隐式转换类
      *
      */
    val words: List[String] = "scala/data/words.txt".read()
    words.foreach(println)
  }

  /**
    * 隐式转换类
    *
    * 可以将ReadFile构造函数参数的类型转换成ReadFile
    */
  implicit class ReadFile(path: String) {
    def read() = {
      Source.fromFile(path).getLines().toList
    }
  }
}

升级打怪的辉哥

关注

0
点赞
踩
1

收藏

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

Scala代码要先看等号右边的Scala是把函数式编程思想和面向对象编程思想结合的一种编程语言。大数据计算引擎Spark由Scala编写。在面向对象编程中，我们把对象传来传去；那在函数式编程中，我们要做的是把函数传来传去，而这个，说成术语，我们把他叫做高阶函数。在函数式编程中，函数是基本单位，，他几乎被用作一切，包括最简单的计算，甚至连变量都被计算所取代。在函数式编程中，变量只是一个名称，而不是一个存储单元，这是函数式编程与传统的命令式编程最典型的不同之处。特点：函数式编程兼容YAVA
复制链接

扫一扫