Scala基础篇【下】

上篇：Scala基础篇【中】

一、List的常用方法测试

用例1.1、list集合的使用

代码实现：

package org.apache.scala.day03

/**
 * 描述： List的常用方法测试，用例1
 * 时间： 2021/7/18
 */
object Demo012_ListTest1 {
  def main(args: Array[String]): Unit = {

    //创建一个List
    val list0 = List(1, 7, 9, 8, 0, 3, 5, 4, 6, 2)
    //将list0中每个元素乘以10后生成一个新的集合
    val list1 = list0.map(x => x * 2)
    //结果是：List(2, 14, 18, 16, 0, 6, 10, 8, 12, 4)
    println(list1)
    println(list0(1))

    //将list0中的偶数取出来生成一个新的集合
    val list2 = list0.filter(x => x % 2 == 0)
    //运行结果是：List(8, 0, 4, 6, 2)
    println(list2)

    //将list0排序后生成一个新的集合
    val list3 = list0.sorted
    //运行结果：List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(list3)

    val list4 = list0.sortBy(x => x)
    //运行结果：List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(list4)

    val list5 = list0.sortWith((x, y) => x < y)
    //运行结果：List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(list5)
    println("--------------------------------1----------------------------------")

    //反转顺序
    val list6 = list3.reverse
    //运行结果：List(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
    println(list6)

    //将Iterator转换成List
    val list7 = list0.toList
    //运行结果是：List(1, 7, 9, 8, 0, 3, 5, 4, 6, 2)
    println(list7)

    //先按空格切分，再压平
    val a = Array("a b c", "d e f", "h i j")
    a.flatMap(_.split(" "))
    //运行结果是：[Ljava.lang.String;@54a097cc
    println(a)

    val value1 = list0.reduce(_ + _)
    //运行结果是：45
    println(value1)

    val value2 = list0.fold(10)(_ + _)
    //运行结果是：55
    println(value2)
    println("--------------------------------2----------------------------------")

    //并行计算求和
    val value3 = list0.par.sum
    //运行结果是：45
    println(value3)

    val value4 = list0.par.map(_ % 2 == 0)
    //运行结果：ParVector(false, false, false, true, true, false, false, true, true, true)
    println(value4)

    val value5 = list0.par.reduce((x, y) => x + y)
    //运行结果：45
    println(value5)

    //简化：reduce
    //将非特定顺序的二元操作应用到所有元素
    val list9 = list0.par.reduce((x, y) => x + y)
    //运行结果是：45
    println(list9)

    //按照特定的顺序
    val list10 = list0.reduceLeft(_ + _)
    //运行结果：45
    println(list10)
    println("--------------------------------3----------------------------------")

    //折叠：有初始值（无特定顺序）
    val list11 = list0.par.fold(100)((x, y) => x + y)
    //运行结果是：945，第二次是1045，最后又回到945
    println(list11)

    //折叠：有初始值（有特定顺序）
    val list12 = list0.foldLeft(100)((x, y) => x + y)
    //运行结果一直是145
    println(list12)

    //聚合
    val arr = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))
    val result = arr.aggregate(0)(_ + _.sum, _ + _)
    //运行结果：20
    println(result)

    val l1 = List(5, 6, 4, 7)
    val l2 = List(1, 2, 3, 4)
    //求并集
    val r1 = l1.union(l2)
    //结果是：List(5, 6, 4, 7, 1, 2, 3, 4)
    println(r1)

    //求交集
    val r2 = l1.intersect(l2)
    //运行结果：List(4)。并集只有一个4
    println(r2)

    //求差集
    val r3 = l1.diff(l2)
    //求l1中不包含l2元素的集合，运行结果是：List(5, 6, 7)
    println(r3)
  }
}

打印输出：

用例1.2、list的fill、concat方法使用

代码实现：

package org.apache.scala.day03
/**
 * 描述： List的常用方法测试，用例2
 * 时间： 2021/7/18
 */
object Demo012_ListTest2 {

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

    val list1: List[Int] = List.apply(1, 2, 3)
    println(list1)

    val list2: List[Int] = List.range(2, 6)
    val list3: List[Int] = List.range(2, 6, 2)
    val list4: List[Int] = List.range(2, 6, -1)
    println(list2)
    println(list3)
    println(list4)

    val list5: List[String] = List.fill(5)("hey")
    println(list5)

    val list6: List[String] = List.concat(List("a", "b"), List("c"))
    println(list6)
  }
}

打印输出：

用例1.3、list合并新的listBuffer

代码实现：

package org.apache.scala.day03

/**
 * 描述： List的常用方法测试,用例3
 * 时间： 2021/7/18
 */

import scala.collection.mutable.ListBuffer
object Demo012_MutableList extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val list0 = ListBuffer[Int](1, 2, 3)
  //创建一个空的可变列表
  val list1 = new ListBuffer[Int]
  //向list1中追加元素，注意：没有生成新的集合
  list1 += 4
  list1.append(5)
  println(list1)

  //将list1中的元素最近到list0中， 注意：没有生成新的集合
  list0 ++= list1

  //将list0和list1合并成一个新的ListBuffer 注意：生成了一个集合
  val list2 = list0 ++ list1

  //将元素追加到list0的后面生成一个新的集合
  val list3 = list0 :+ 5
}

打印输出：

用例1.4、集合set方法实现

代码实现：

package org.apache.scala.day03

import scala.collection.immutable.HashSet
/**
 * 描述： List的常用方法测试,用例4
 * 时间： 2021/7/18
 */
object Demo013_ImmutableSet extends App {

  val set1 = new HashSet[Int]()
  //将元素和set1合并生成一个新的set，原有set不变
  val set2 = set1 + 4

  //set中元素不能重复
  val set3 = set1 ++ Set(5, 6, 7)

  val set0 = Set(1, 3, 4) ++ set1
  println(set0.getClass)
}

打印输出：

用例1.5、集合HashSet的使用

代码实现：

package org.apache.scala.day03
import scala.collection.mutable
/**
 * 描述： List的常用方法测试,用例5
 * 时间： 2021/7/18
 */
object Demo013_MutableSet extends App {

  //创建一个可变的HashSet
  val set1 = new mutable.HashSet[Int]()

  //向HashSet中添加元素
  set1 += 2
  //add等价于+=
  set1.add(4)

  set1 ++= Set(1, 3, 5)
  println(set1)

  //删除一个元素
  set1 -= 5
  set1.remove(2)
  println(set1)
}

打印输出：

用例1.6、集合的union、intersect、diff方法使用

代码实现：

package org.apache.scala.day03
/**
 * 描述： List的常用方法测试,用例6
 * 时间： 2021/7/18
 */
object Demo013_SetTest {

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

    val set1: Set[Int] = Set(1, 2, 3, 4, 5)
    val set2: Set[Int] = Set(3, 4, 5, 6, 7)

    println(set1.union(set2))
    println(set1.intersect(set2))
    println(set1.diff(set2), set2.diff(set1))
  }
}

 打印输出：

用例1.7、集合map使用

代码实现：

package org.apache.scala.day03

/**
 * 描述： List的常用方法测试,用例7
 * 时间： 2021/7/18
 */
import scala.collection.mutable
object Demo014_MutableMap extends App {

  val map1 = new mutable.HashMap[String, Int]()

  //向map中添加数据
  map1("spark") = 1
  map1 += (("hadoop", 2))
  map1.put("storm", 3)
  println(map1)

  //从map中移除元素
  map1 -= "spark"
  map1.remove("hadoop")
  println(map1)
  println("----------------------1--------------------------------------------")

  // 访问map1中的key-value
  println(map1("storm"))
  //  println(map1("spark"))
  val result = if (map1.contains("spark")) map1("spark") else 0
  println(result)
  println(map1.get("storm"))
  println(map1.getOrElse("storm", 0))
  println(map1.getOrElse("spark", 0))
  println("----------------------2--------------------------------------------")

  // 遍历
  val map2 = Map("a" -> 1, "b" -> 2, "c" -> 3)
  for (kv <- map2) {
    println(kv._1, kv._2)
  }
  for ((k, v) <- map2) {
    println(k, v)
  }
  println("----------------------3--------------------------------------------")
}

打印输出：

用例1.8、List的拉链操作

代码实现：

package org.apache.scala.day03
/**
 * 描述： List的常用方法测试,用例8
 * 时间： 2021/7/18
 */
object Demo015_Tuple {

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

    // 声明一个Tuple
    val t = ("huangbo", 22, 55.55, true)

    // 声明一个Tuple
    val t1, (a, b, c, d) = ("huangbo", 22, 55.55, true)

    // 打印输出一个Tuple
    println(t1)
    println(a, b, c, d)

    // 访问Tuple对应位置上的元素
    val aa = t1._1
    println(aa, t1._2, t1._3)

    // 将元素是 二元组 的集合转换成Map
    var array = Array(("A", 1), ("B", 2))
    val map1 = array.toMap
    println(map1)

    // 可以将一个map转成一个 二元组 的数组
    val tuple1 = map1.toArray
    println(tuple1.toBuffer)

    // 如果只需要使用元组中的部分元素呢。
    val (aa1, _, bb1, _) = t1
    println(aa1, bb1)

    // List的拉链操作
    val alist = List("a", "b", "c")
    val blist = List(1, 2, 3)
    val result33: Map[String, Int] = alist.zip(blist).toMap
    println(result33)
  }
}

 打印输出：

---

 2、99乘法表

代码实现：

package org.apache.scala.day03

/**
 * 99乘法表
 */
object Demo021_99 {

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

    // 传统方式
    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        printf("%d*%d=%2d\t", i, j, (i * j))
      }
      println()
    }

    println("-------------------------------------")

    // 新方式1
    for (i <- 1 to 9; j <- 1 to i) {
      printf("%d*%d=%2d\t", i, j, (i * j)); if (i == j) println()
    }

    // 新方式2
    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$i*$j=${i * j}${if (i == j) "\n" else "\t"}")
    }
  }
}

打印输出：

---

3、Java版本的wordcount

代码实现：

package org.apache.java.dayo3;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 描述： Java版本的wordcount
 *
 * 准备数据：在E:\TestDemo下创建wcount.txt文本，该文本主要数据有：
 *
 * hadoop,workproject
 * flink,flume
 * spark,hive
 * chickhouse,kylie
 * hbase,spark,spark Streaming
 * window time
 *
 * 运行会在E:\TestDemo文件下生成result.txt文本，该文本里面会生成如下内容：
 * Streaming	1
 * hadoop,workproject	1
 * spark,hive	1
 * flink,flume	1
 * chickhouse,kylie	1
 * hbase,spark,spark	1
 * window	1
 * time	1
 */
public class Demo022_JavaWordCount {
    public static void main(String[] args) throws Exception {

        FileInputStream fileInputStream = new FileInputStream(new File("E:\\TestDemo\\wcount.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(fileInputStream));

        Map<String, Integer> wordContext = new HashMap<String, Integer>();

        String line = null;
        while ((line = br.readLine()) != null) {

            String[] words = line.split(" ");
            for (String word : words) {
                if (wordContext.containsKey(word)) {
                    wordContext.put(word, wordContext.get(word) + 1);
                } else {
                    wordContext.put(word, 1);
                }
            }
        }

        File file = new File("E:\\TestDemo\\result.txt");
        if (!file.exists()) {
            file.delete();
        }
        file.createNewFile();
        PrintWriter printWriter = new PrintWriter(file);

        // 展示结果
        Set<String> keys = wordContext.keySet();
        for (String key : keys) {
            System.out.println(key + "\t" + wordContext.get(key));
            printWriter.println(key + "\t" + wordContext.get(key));
        }

        br.close();
        printWriter.close();
    }
}

 打印输出：统计出现次数

4、scala版本的wordcount

代码实现：

package org.apache.scala.day03

/**
 * 描述： wordcount
 */
object Demo022_WordCount {
  def main(args: Array[String]): Unit = {

    val array = Array("hello huangbo", "hello xuzheng", "hello wangbaoqiang")

    /**
     * 第一种方式
     */
    val result: List[(String, Int)] = array.flatMap(_.split(" "))
      .map((_, 1))
      .groupBy(t => t._1)
      .map(t => (t._1, t._2.length))
      .toList
      .sortBy(t => t._2)
      .reverse
    for (t <- result) {
      println(t)
    }
    println("------------------------------1------------------------------------")


    /**
     * 第二种方式
     */
    val result2: Map[String, Int] = array.flatMap(_.split(" "))
      .map(x => (x, 1))
      .groupBy(x => x._1)
      .mapValues(x => x.length)
    for ((k, v) <- result2) {
      println(k, v)
    }
    println("------------------------------2------------------------------------")


    /**
     * 第三种方式
     */
    val result3: Map[String, Int] = array.flatMap(_.split(" "))
      .map(x => (x, 1))
      .groupBy(x => x._1)
      .mapValues(x => x.foldLeft(0)((x, y) => x + y._2))
    for ((k, v) <- result3) {
      println(k, v)
    }
  }
}

打印输出：

---

5、Scala的插入排序

代码实现：

package org.apache.scala.day03
import scala.util.control.Breaks
/**
 * 描述： Scala的插入排序
 */
object Demo023_InsertSort {
  def main(args: Array[String]): Unit = {

    val array = Array(4, 12, 6, 3, 8, 9, 5)
    val ab = array.toBuffer

    // 创建Breaks对象
    val forLoop = new Breaks

    for (i <- 1 until ab.length) {
      val value_i = ab(i)

      // 把需要可能break的代码放在 breakable 中执行
      forLoop.breakable {
        for (j <- 0 to i - 1) {

          val value_j = ab(j)
          if (value_j > value_i) {
            ab.remove(i, 1)
            ab.insert(j, value_i)

            // 使用break进行跳出
            forLoop.break()
          }
        }
      }
    }
    println(ab)
  }

}

打印输出：

---

6、保留所有正数

代码实现：

package org.apache.scala.day03

/**
 * 描述： 练习
 * 保留所有正数
 * 移除list中的第一个负数
 * 移除list中出第一个负数外的所有负数
 */
object Demo024_Exercise {
  def main(args: Array[String]): Unit = {

    val list1 = List(1, 2, 3, -1, -2, -3)
    list1.foldLeft((0, 0))((x, y) => (x._1 + y, x._2 + 1))

    // 1、保留所有的正数
    list1.filter(x => if (x > 0) true else false).foreach(println)

    // 2、移除list1中的第一个负数得到List(1,2,3,-2,-3)
    var flag = 0
    list1.filter(x => {
      if (x < 0) flag += 1
      (x > 0 || flag >= 2)
    }).foreach(x => println(x))

    // 3、移除除第一个负数外的所有负数List(1,2,3,-1)
    var abc = 0
    list1.filter(x => {
      if (x < 0) abc += 1
      (x > 0 || abc <= 1)
    }).foreach(x => println(x))

    var array1 = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val result1 = array1.foldLeft(10)((x: Int, y: Int) => x + y)
    println(result1)

    val result2 = array1.foldRight(10)((x: Int, y: Int) => x + y)
    println(result2)

    val tuple = array1.foldLeft((0, 0))((x, y) => (x._1 + y, x._2 + 1))
    println(tuple._1.toDouble / tuple._2)
  }
}

 打印输出：