2021-05-08

最新推荐文章于 2024-09-29 21:46:37 发布
最新推荐文章于 2024-09-29 21:46:37 发布
阅读量265 收藏
点赞数
分类专栏： scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52111247/article/details/116535491
版权
本文详细介绍了Scala中的集合和数组操作，包括不可变数组、可变数组、List、Set和Map的基本操作，如创建、遍历、修改、转换等，并展示了如何进行集合计算和队列操作。同时，讨论了元组的使用以及集合的衍生操作，如并集、交集和差集。
摘要由CSDN通过智能技术生成

文章目录

Scala day05

集合

数组

不可变数组
val arr: Array[Int] = new Array[Int](10)

import scala.collection.mutable.ArrayBuffer

object TestArray{

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

        //（1）数组定义
        val arr01 = new Array[Int](4)
        println(arr01.length) // 4

        //（2）数组赋值
        //（2.1）修改某个元素的值
        arr01(3) = 10
        //（2.2）采用方法的形式给数组赋值
        arr01.update(0,1)

        //（3）遍历数组
        //（3.1）查看数组
        println(arr01.mkString(","))

        //（3.2）普通遍历
        for (i <- arr01) {
            println(i)
        }

        //（3.3）简化遍历
        def printx(elem:Int): Unit = {
            println(elem)
        }
         arr01.foreach(printx)
        // arr01.foreach((x)=>{println(x)})
        // arr01.foreach(println(_))
        arr01.foreach(println)

        //（4）增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数组）
        println(arr01)
        val ints: Array[Int] = arr01 :+ 5
        println(ints)
    }
}


package com.gc.scala.day05.arr

/**
 * Author guochao
 * Date 2021/5/8 15:22
 */
object Array1 {
  def main(args: Array[String]): Unit = {
    //创建数组长度为10的int数组  等价于java: new Int[10]
    val arr: Array[Int] = new Array[Int](10)
    println(arr)
  }

}
可变数组
val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)
 val buffer2: ArrayBuffer[Int] = new ArrayBuffer[Int]()

import scala.collection.mutable.ArrayBuffer

object TestArrayBuffer {

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

        //（1）创建并赋值可变数组
        val arr01 = ArrayBuffer[Any](1, 2, 3)

        //（2）遍历数组
        for (i <- arr01) {
            println(i)
        }
        println(arr01.length) // 3
        println("arr01.hash=" + arr01.hashCode())

        //（3）增加元素
        //（3.1）追加数据
        arr01.+=(4)
        //（3.2）向数组最后追加数据
        arr01.append(5,6)
        //（3.3）向指定的位置插入数据
        arr01.insert(0,7,8)
        println("arr01.hash=" + arr01.hashCode())

        //（4）修改元素
        arr01(1) = 9 //修改第2个元素的值
        println("--------------------------")

        for (i <- arr01) {
            println(i)
        }
        println(arr01.length) // 5
    }
}


package com.gc.scala.day05.arr

import scala.collection.mutable.ArrayBuffer

/**
 * Author guochao
 * Date 2021/5/8 15:28
 */
object Array2 {
  def main(args: Array[String]): Unit = {
    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)
    val buffer2: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    // println(buffer)
    // println(buffer1)
    // val b2: ArrayBuffer[Int] = buffer1 :+ 10

    //原地添加buffer1，在尾部添加元素
    buffer2 += 100
    200 +=: buffer2 //在头部添加
    println(buffer2) //ArrayBuffer(200, 100)

    val b3 = buffer1 ++ buffer2 //合并
    println(b3)

    buffer1 ++= buffer2 //把buffer2的集合追加到buffer1的后面，更新的是buffer1

    buffer1 ++=: buffer2 //把buffer1的元素添加到buffer2的前面，更新的是buffer2

    println(buffer1) //ArrayBuffer(1, 2, 3, 4, 200, 100)
    println(buffer2) //ArrayBuffer(1, 2, 3, 4, 200, 100, 200, 100)
    buffer1 -= 1
  }
}
不可变数组与可变数组的转换

arr1.toBuffer //不可长数组转可变数组
arr2.toArray //可变数组转不可变数组
（1）arr2.toArray返回结果才是一个不可变数组，arr2本身没有变化
（2）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化

package com.gc.scala.day05.arr

import scala.collection.mutable.ArrayBuffer

/**
 * Author guochao
 * Date 2021/5/8 16:07
 */
object Array3 {
  def main(args: Array[String]): Unit = {
    val arr1 = Array(30, 50, 70, 60, 10, 20)
    val bufffer = arr1.toBuffer //不可变数组转换为可变
    println(bufffer)

    val b = ArrayBuffer(10, 20)
    println(b.toArray.mkString) // .toArray可变数组转不可变数组

  }
}
多维数组
  1. 定义
 val arr = Array.ofDim[Double](3,4)

说明：二维数组中有三个一维数组，每个一维数组中有四个元素

package com.gc.scala.day05.arr

/**
 * Author guochao
 * Date 2021/5/8 16:11
 */
object Array4 {
  def main(args: Array[String]): Unit = {
    //多维数组  二维数组   假的，是用一维数组模拟的多维数组

    val arr: Array[Array[Int]] = Array.ofDim[Int](2, 3) //生成一个2x3的数组
    println(arr(0)(1))

    //遍历
    for (a1 <- arr) {
      for (elem <- a1) {
        println(elem)
      }
    }
  }
}

List

不可变List
  1. 说明
    （1）List默认为不可变集合
    （2）创建一个List（数据有顺序，可重复）
    （3）遍历List
    （4）List增加数据
    （5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
    （6）取指定数据
    （7）空集合Nil
  2. 案例实操
package com.gc.scala.day05.list

/**
 * Author guochao
 * Date 2021/5/8 16:19
 */
object List1 {
  def main(args: Array[String]): Unit = {
    //1.创建有元素的集合
    val l1=List(1,2,3)
    println(l1)
    //2.空list
    val l2=List[Int]()
    //3.空集合
    val l3=Nil
    //4.向List添加元素
    val l4=200+: l1 :+ 100

    val l5=200::100::l1

    val l6=List(6,6,6,6)
    val l7=l6:::l1//合并
  }
}
/*
List
  就是列表
  默认不可变

不可变List专用
  :: 等同于 +: 在前面添加元素
  ::: 合并两个List
 */
可变List
package com.gc.scala.day05.list

import scala.collection.mutable.ListBuffer

/**
 * Author guochao
 * Date 2021/5/8 16:28
 */
object ListBuffer1 {
  def main(args: Array[String]): Unit = {
   val buffer=ListBuffer(1,2,3)//可变List
    buffer+=10
    100+=:buffer
    println(buffer)

  }
}

Set

不可变Set
  1. 说明
    （1）Set默认是不可变集合，数据无序
    （2）数据不可重复
    （3）遍历集合
  2. 案例实操
package com.gc.scala.day05.Set

/**
 * Author guochao
 * Date 2021/5/8 16:34
 */
object Set1 {
  def main(args: Array[String]): Unit = {
    //不可变集合
    /*val set1 = Set(1, 2, 3, 4, 5, 6)
    val set2=set1+10
    println(set1)*/
    val set1 = Set(1, 2, 3, 4, 5, 6)
    val set2 = Set(45,34,78,32)
    val set3=set1++set2
    val set4=set1 | set2
    val set5=set1 union set2

    val set6=set1 & set2
    val set7=set1 intersect(set2)

    val set8=set1 &~ set2  //减去共同部分
  }
}
/*
Set
    可变和不可变，默认不可变
    不可重复，无序

      其实就是代数里的集合
      并集
      |
      ++
      union
      交集:&  intersect
      差集:&~
 */

object TestSet {

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

        //（1）Set默认是不可变集合，数据无序
        val set = Set(1,2,3,4,5,6)

        //（2）数据不可重复
        val set1 = Set(1,2,3,4,5,6,3)

        //（3）遍历集合
        for(x<-set1){
            println(x)
        }
    }
}
可变Set（mutable.Set）
package com.gc.scala.day05.Set

import scala.collection.mutable

/**
 * Author guochao
 * Date 2021/5/8 16:44
 */
object Set2 {
  def main(args: Array[String]): Unit = {
    val set1=mutable.Set(10,20,30)
    set1+=100
    println(set1)

    //使用set去重
    val list1=List(30,20,50,30,30)
    val list2=list1.toSet.toList
    println(list2)
  }
}


object TestSet {

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

        //（1）创建可变集合
        val set = mutable.Set(1,2,3,4,5,6)

        //（3）集合添加元素
        set += 8

        //（4）向集合中添加元素，返回一个新的Set
        val ints = set.+(9)
        println(ints)
        println("set2=" + set)

        //（5）删除数据
        set-=(5)

        //（2）打印集合
        set.foreach(println)
        println(set.mkString(","))
    }
}

Map

不可变Map
package com.gc.scala.day05.Map

/**
 * Author guochao
 * Date 2021/5/8 16:49
 */
object Map1 {
  def main(args: Array[String]): Unit = {
   val map1= Map[String,Int](("a",97),("b",98),("c",99))
    for (elem <- map1) {
      println(elem)
      println(elem._1)
    }
  }
}
/*
Map映射
  默认不可变，具体的实现是HashMap

scala中的Map，把键和值当作元组来处理
 */

package com.gc.scala.day05.Map

/**
 * Author guochao
 * Date 2021/5/8 16:56
 */
object Map2 {
  def main(args: Array[String]): Unit = {
    val map1=Map("a"->1, "b"->2, "c"->3)
    println(map1)

   val map2= map1+("f" ->102)
    println(map2)

    val map3=map1++map2//合并
  }
}


package com.gc.scala.day05.Map

/**
 * Author guochao
 * Date 2021/5/8 17:01
 */
object Map3 {
  def main(args: Array[String]): Unit = {
    val map1=Map("a"->1, "b"->2, "c"->3)
    //根据key获取值
    val v1=map1("a")
    println(v1)
  }
}
可变Map
package com.gc.scala.day05.Map

import scala.collection.mutable

/**
 * Author guochao
 * Date 2021/5/8 17:02
 */
object Map4 {
  def main(args: Array[String]): Unit = {
    val map1=mutable.Map("a"->1, "b"->2, "c"->3)//可变Map
    map1+=("aa"->100)
    println(map1)
    map1.update("aa",233)//更新Map
    println(map1)

  }
}


object TestSet {

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

        //（1）创建可变集合
        val map = mutable.Map( "a"->1, "b"->2, "c"->3 )

        //（3）向集合增加数据
        map.+=("d"->4)

        // 将数值4添加到集合，并把集合中原值1返回
        val maybeInt: Option[Int] = map.put("a", 4)
        println(maybeInt.getOrElse(0))

        //（4）删除数据
        map.-=("b", "c")

        //（5）更新数据
        map.update("d",5)

        //（2）打印集合
        map.foreach((kv)=>{println(kv)})
    }
}

元组

  1. 说明
    元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
    注意：元组中最大只能有22个元素。
  2. 案例实操
    （1）声明元组的方式：(元素1，元素2，元素3)
    （2）访问元组
    （3）Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶
object TestTuple {

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

        //（1）声明元组的方式：(元素，元素2，元素3)
        val tuple: (Int, String, Boolean) = (40,"bobo",true)

        //（2）访问元组
        //（2.1）通过元素的顺序进行访问，调用方式：_顺序号
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)

        //（2.2）通过索引访问数据
        println(tuple.productElement(0))

        //（2.3）通过迭代器访问数据
        for (elem <- tuple.productIterator) {
            println(elem)
        }

        //（3）Map中的键值对其实就是元组,只不过元组的元素个数为2，称之为对偶
        val map = Map("a"->1, "b"->2, "c"->3)

        map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})
    }
}

集合基本属性和常用操作

  1. 说明
    （1）获取集合长度
    （2）获取集合大小
    （3）循环遍历
    （4）迭代器
    （5）生成字符串
    （6）是否包含
  2. 案例实操
object TestList {

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

    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

    //（1）获取集合长度
    println(list.length)

    //（2）获取集合大小
    println(list.size)

    //（3）循环遍历
    list.foreach(println)

    //（4）迭代器
    for (elem <- list.iterator) {
      println(elem)
    }

    //（5）生成字符串
    println(list.mkString(","))

//（6）是否包含

    println(list.contains(3))
  }
}

衍生集合

  1. 说明
    （1）获取集合的头head
    （2）获取集合的尾（不是头就是尾）tail
    （3）集合最后一个数据 last
    （4）集合初始数据（不包含最后一个）
    （5）反转
    （6）取前（后）n个元素
    （7）去掉前（后）n个元素
    （8）并集
    （9）交集
    （10）差集
    （11）拉链
    （12）滑窗
  2. 案例实操
object TestList {

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

    val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)

    //（1）获取集合的头
    println(list1.head)

    //（2）获取集合的尾（不是头的就是尾）
    println(list1.tail)

    //（3）集合最后一个数据
    println(list1.last)

    //（4）集合初始数据（不包含最后一个）
    println(list1.init)

    //（5）反转
    println(list1.reverse)

    //（6）取前（后）n个元素
    println(list1.take(3))
    println(list1.takeRight(3))

    //（7）去掉前（后）n个元素
    println(list1.drop(3))
    println(list1.dropRight(3))

    //（8）并集
    println(list1.union(list2))

    //（9）交集
    println(list1.intersect(list2))

    //（10）差集
    println(list1.diff(list2))

    //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println(list1.zip(list2))

    //（12）滑窗
    list1.sliding(2, 5).foreach(println)
  }
}

集合计算初级函数

  1. 说明
    （1）求和
    （2）求乘积
    （3）最大值
    （4）最小值
    （5）排序
  2. 实操
object TestList {

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

    val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)

    //（1）求和
    println(list.sum)

    //（2）求乘积
    println(list.product)

    //（3）最大值
    println(list.max)

    //（4）最小值
    println(list.min)

    //（5）排序
    // （5.1）按照元素大小排序
    println(list.sortBy(x => x))

    // （5.2）按照元素的绝对值大小排序
    println(list.sortBy(x => x.abs))

    // （5.3）按元素大小升序排序
	println(list.sortWith((x, y) => x < y))

	// （5.4）按元素大小降序排序
    println(list.sortWith((x, y) => x > y))
    
  }
}

集合计算高级函数

  1. 说明
    （1）过滤
    （2）转化/映射
    （3）扁平化
    （4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作
    （5）分组
    （6）简化（规约）
    （7）折叠
  2. 实操
object TestList {

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

    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")

    //（1）过滤
    println(list.filter(x => x % 2 == 0))

    //（2）转化/映射
    println(list.map(x => x + 1))

    //（3）扁平化
    println(nestedList.flatten)

    //（4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作
    println(wordList.flatMap(x => x.split(" ")))

    //（5）分组
    println(list.groupBy(x => x % 2))
  }
}
  1. Reduce方法
    Reduce简化（规约） ：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。
    案例实操
object TestReduce {

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

        val list = List(1,2,3,4)

        // 将数据两两结合，实现运算规则
        val i: Int = list.reduce( (x,y) => x-y )
        println("i = " + i)

        // 从源码的角度，reduce底层调用的其实就是reduceLeft
        //val i1 = list.reduceLeft((x,y) => x-y)

        // ((4-3)-2-1) = -2
        val i2 = list.reduceRight((x,y) => x-y)
        println(i2)
    }
}

4.Fold方法
Fold折叠：化简的一种特殊情况。
（1）案例实操：fold基本使用

object TestFold {

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

        val list = List(1,2,3,4)

        // fold方法使用了函数柯里化，存在两个参数列表
        // 第一个参数列表为 ： 零值（初始值）
        // 第二个参数列表为：

        // fold底层其实为foldLeft
        val i = list.foldLeft(1)((x,y)=>x-y)

        val i1 = list.foldRight(10)((x,y)=>x-y)

        println(i)
        println(i1)
    }
}

（2）案例实操：两个集合合并

object TestFold {

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

        // 两个Map的数据合并
        val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
        val map2 = mutable.Map("a"->4, "b"->5, "d"->6)

        val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
            (map, kv) => {
                val k = kv._1
                val v = kv._2

                map(k) = map.getOrElse(k, 0) + v

                map
            }
        }

        println(map3)
    }
}

队列

package com.gc.scala.day05.queue

import scala.collection.mutable

/**
 * Author guochao
 * Date 2021/5/8 17:08
 */
object Queue1 {
  def main(args: Array[String]): Unit = {
    val q1=mutable.Queue[Int](10,20,30)
    q1.enqueue(100,200)//添加在尾部   入队
    println(q1)
    q1.dequeue()//删除最前面的   出队
    println(q1)

    val s1=mutable.Stack[Int](10,20,30)
    val p=s1.pop()
    println(p)
    s1.push(100)
    val p2=s1.pop()
    println(p2)//10
  }
}
/*
队列
入队
出队

栈
push 入栈
pop 出栈



 */
Starry sky325
关注
专栏目录
2021-05-05
樊金良的博客
05-05 765
你需要努力，fighting！
2021-01-05
weixin_44822406的博客
01-05 950
第一次接触这个CSDN博客，希望大家多多关照，有什么做的不好不周到的地方希望大家谅解。从现在开始会陆续发一些大家所需要的东西。
2021-05-26
yzpbright的博客
05-26 570
更新了http请求为https后，执行https请求时报错 2021-05-26 18:08:19.705 17359-17444/org.securesms D/PushServiceSocket: Opening URL: https://wallet-server-pre.coming.chat/api/v1/coin/priceAndUsable/5H3U6wPpe5Hi6ozX5LEcAszJ81KY4afHc2jeUxJcSmUShVks 2021-05-26 18:08:19.705 1735
2021-05 补丁日：微软多个漏洞通告
爱国小白帽
05-12 1424
报告编号：B6-2021-051201 报告来源：360CERT 报告作者：360CERT 更新日期：2021-05-12 0x01 事件简述 2021年05月12日，360CERT监测发现微软发布了5月份安全更新，事件等级：严重，事件评分：9.9。 此次安全更新发布了55个漏洞的补丁，主要覆盖了以下组件：Windows操作系统、Exchange Server、.Net Core、Office、SharePoint Server、Hyper-V、 Visual Studio。其中包含4个严重漏洞，50个.
Ubuntu更新最新版本内核 V5.12.2 2021-05-08
songjiangem的博客
05-08 2035
下载文件 https://kernel.ubuntu.com/~kernel-ppa/mainline/ 目前最新版本V5.12.2 下载4个文件headers-generic；headers-all；image-generic；modules-generic 安装内核文件 sudo dpkg -i linux-headers-5.12.2-051202_5.12.2-051202.202105071130_all.deb sudo dpkg -i linux-headers-5.12.2-0
2021-11-17
夜月晓晓的博客
11-17 480
2021-01-04
wubaoyu123的博客
01-04 2268
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 知了一笑 博客园 首页 新随笔 联系 订阅 管理 数据仓库组件：Hive环境搭建和基础用法 本文源码：GitHub || GitEE 一、Hive基础简介 1、基础描述 Hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，是一个可以对Hadoop中的大规模存储的数据进行查询和分析存储的组件，Hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成
日期解析：2021-05-15T23:30:00+08:00
热门推荐
weixin_45616483的博客
05-15 2万+
这是一种常见的第三方接口返回的日期格式，因为有别于我们常用的"yyyy-MM-dd HH:mm:ss"格式,所以我们首先要把这种字符串解析为Date，再转为需要的格式。 类似日期2021-05-15T23:30:00+08:00 的 格式为： yyyy-MM-dd’T’HH:mm:ssXXX 其中： T是不需要解析的无意义字符，需要用单引号包起来 +08:00是时区，对应为"XXX" 1.老式Java API解析 String a = "2021-05-14T23:30:35+08:00"; SimpleD
2021-05-12
qq_56064879的博客
05-12 1324
https://pan.baidu.com/s/1AzVyvHOn8yQj9F08L4KPpg
java中如何把2021-04-05T11:22:23.349+08:00转成Date呢
qq_43153224的博客
04-14 5295
java中如何把2021-04-05T11:22:23.349+08:00转成Date呢 public static Date dealDateFormat(String oldDateStr) { DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX"); try { Date date = df.parse(oldDateStr); return date; }
log-sessions-2021-08-21-041328.session
09-04
log-sessions-2021-08-21-041328.session
查询所有Redis集群配置信息-data-2021-05-06 11_08_34.zip
05-06
查询所有Redis集群配置信息-data-2021-05-06 11_08_34.zip
74HC165D驱动 2021-05-08
保持每天的清醒
05-08 705
---------------------------------------------------------------------------------------------------------------------- 元件:74HC165D ------------------------------------------------------------------------------------------.
操作记录-2021-05-08: daizhongye_project
垚垚爸的博客
05-09 271
一、ChIP_seq 数据加工处理 1.建立相应目录 对新数据建立对应实验人员（daizhongye）、测序类型（ChIP_seq）和日期（2021_05_08）的目录。 # 建立后如下： (base) zexing@DNA:~/projects/daizhongye/ChIP_seq/2021_05_08$ # 新建对应的目录 mkdir raw_data bam bam_bw bam_sort sam macs2_bdgdiff macs2_callpeak matrix_reference_poin
Scala 字符串
wjs2024的博客
09-29 448
Scala 是一种多范式的编程语言，它结合了面向对象和函数式编程的特点。在 Scala 中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能更改它。Scala 字符串由 Java 字符串支持，因此 Scala 字符串的方法与 Java 字符串的方法非常相似。
SpinalHDL之语义(Semantic)（三）
m0_59092412的博客
09-29 550
⼀、简介(Introduction)SpinalHDL背后的语义学很重要, 学会语义你就能理解在这些情景背后到底发⽣了什么, 并且如何去控制它。这些语义通过以下⼏条规则定义：
PHP基于微信公众号的点餐系统源码.zip
10-03
用Yii2框架做的一个微信公众号点餐系统，商家接入管理后台之后就可以在后台添加菜式的类型和菜式的名称，客户在微信扫描二维码关注公众号就可以在公众号点餐，下单时提交餐桌号还有相应的信息到商家后台，商家在后台可以查看到订单信息 提示，因为个人原因缺乏支付功能，支付代码已经完成
基于Delaunay三角剖分的大学生方程式无人赛车路径规划算法
最新发布
10-03
【作品名称】：基于Delaunay三角剖分的大学生方程式无人赛车路径规划算法 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 基于 Delaunay 三角剖分的路径规划算法：将锥桶位置视为离散点，构建 Delaunay 三角，然 - 第一列为锥桶序号，内外侧锥桶已经分别按照赛道顺序排序 - 第二列为锥桶类型（颜色），`2` 为外侧锥桶（蓝色，位于车辆行驶方向的左侧）、`11` 为内侧锥桶（黄色，位于车辆行驶方向的右侧） - 第三四列为 x 坐标与 y 坐标，单位为 [m] 在真实场景中，安装在赛车上的传感器的感知范围是有限的，并不能一次获取所有锥桶位置。因此，设计一个变量 `interval`，用于控制每次规划时考虑的锥桶数量。（换言之，将整条赛道划分为若干个路段，每次只在一个路段内进行规划。）如图所示，若 `i 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础能够看懂代码，能够自行调试代码并解决报错，能够自行添加功能修改代码。
MATLAB 实现的基于随机森林（Random Forest, RF）的工业增加值预测模型的详细实例（包含详细的完整的程序和数据
10-03
主要内容：本文介绍了一个完整的案例，展示用MATLAB的TreeBagger函数实现基于随机森林的方法来进行工业增加值的预测。该模型考虑了生产总值、投资以及消费等因素，通过详细的操作步骤生成了相关数据，训练与评估了随机森林模型。文中还提供了完整的源代码和示例，方便开发者动手实践和学习如何利用统计和机器学习工具箱进行预测任务。 适用人群：熟悉基本MATLAB语法，具有一定数据分析经验和统计学基础知识的研发和工程技术人员。 使用场景及目标：适合用于工业经济分析师或者研究学者们在需要快速预测行业增长趋势时借鉴，特别当涉及到多因素复杂变量情况下时。 补充说明：此案例还包括划分训练集与验证集，计算如均方误差（RMSE）等评估指数帮助检验模型准确度的功能部分，便于初学者快速搭建模型，理解每个阶段的工作细节及其重要性。
逗号分隔的多个数据，每个数据项由#分隔的四个小项构成。 # 第一个为题号；第二个为时间；第三个为操作类型，可能的取值：12、11、10--读题，空值-作答；第四个为科目。 data = '''1#2021-05-18 14:31:55##初级会计实务,2#2021-05-18 14:31:57#12#初级会计实务,2#2021-05-18 14:32:08##初级会计实务,3#2021-05-18 14:32:09#12#初级会计实务,4#2021-05-18 14:32:34#12#初级会计实务,4#2021-05-18 14:32:45##初级会计实务,5#2021-05-18 14:32:46#12#初级会计实务,5#2021-05-18 14:32:57##初级会计实务,6#2021-05-18 14:33:00#12#初级会计实务,7#2021-05-18 14:33:44#12#初级会计实务,7#2021-05-18 14:34:42##初级会计实务,8#2021-05-18 14:34:43#12
06-10
data = '''1#2021-05-18 14:31:55##初级会计实务,2#2021-05-18 14:31:57#12#初级会计实务,2#2021-05-18 14:32:08##初级会计实务,3#2021-05-18 14:32:09#12#初级会计实务,4#2021-05-18 14:32:34#12#初级会计实务,4#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值