Scala

最新推荐文章于 2021-08-17 12:17:57 发布
最新推荐文章于 2021-08-17 12:17:57 发布
阅读量117 收藏
点赞数
分类专栏： 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45116848/article/details/103700449
版权

Scala

1.数据类型

scala相比较以与java语言多出来以下几种数据类型:

  • Unit:表示无返回值,与java语言中的void相同
  • Null:空值或者空引用
  • Nothing:所有其它类型的子类型,表示没有值
  • Any:所有类型的超类,任何实例都属于any类型
  • AnyRef:所有引用类型的超类
  • AnyVal:所有值的超类

在这里插入图片描述
在这里插入图片描述

2.类和对象

  • 在scala语言中一行的结尾可以省略分号,若一行中有多个语句,则需要用分号隔开

  • val 是声明常亮 var是声明变量的

  • class 属性是自带getter setter

  • class 如果有参数传进去,则是为他的默认构造器,重写构造器时,需要调用默认构造器

    class Person(xname: String, xage: Int)  {
    val name = xname
    val age = xage
    /**
      * 重写构造器，必须调用默认构造器
      */
    def this(xname: String, xage: Int, xmoney: Int) {
        this(xname, xage)
        money = xmoney
    }

  • class new对象时,除了方法内部不执行,其他的都执行

  • object 不能传参,object是单例,可以认为是java中的单例对象,并且它里面的方法也是静态的,

  • 在同一个scala文件中,若class与object的名字相同,则互为伴生类,伴生对象,它们可以直接访问对方的所有变量


class Person(xname:String,xage:Int){
  val name =xname;
  val age = xage;
  private var money=100;

  }
  def test(): Unit ={
    println(Person.test)
  }
}

object Person {
  private var test = "wuming"
  //public static void main (String[] args)
  def main(args: Array[String]): Unit = {
    val  person: Person =new Person("zs",18,1000)
    println(person.name+":"+person.age+":"+person.money)
  }
}

3.循环

  • to 和 until的用法
object Loop {
  def main(args: Array[String]): Unit = {
    //1 to 10 返回1到10的Range数组，包含10
    println(1 to 10)
    //1 to 10 返回1到10的Range数组，不包含10
    println(1 until 10)
  }
 }
  • for 循环
object Loop {
  def main(args: Array[String]): Unit = {
	for (i <- 1 to 10){
    println(i)
  }
 /**
  *可以在for循环中加入条件判断
  */
  for (i <- 1 to 10;if i>5;if i%2==0){
    println(i)
  }
 }
  • scala中不能使用count++，count–只能使用count = count+1 ，count += 1

4.Scala函数

  • 在scala语法中,return是可以省略掉,scala自动将函数的最好一行的值,作为返回值,{}在只有一行语句时也可以省略
object Function {
  def main(args: Array[String]): Unit = {
    def max(a:Int,b:Int)={
      if (a>b)
        a
      else
        b
    }
    val result=max(1,2)
    println(result)
  }
}

  • 函数可以省略返回类型,会自动推动,但是当显示的调用return时,不可以省略返回类型

  • 如果省略掉 = ,则函数会自动将返回值丢弃,所有我们可以在不需要返回值的函数上,省略=

  • 函数里面的参数都是val,所以在函数中不可以修改参数值

  • 递归函数,不可以省略返回类型
object Function {
  def main(args: Array[String]): Unit = {
  def f1(number:Int): Int ={
    if (number==1)
      return 1
    number*f1(number-1)
  }
  println(f1(3))
  • 包含默认值参数的函数
package com.shsxt
object Function {
  def main(args: Array[String]): Unit = {

  /**
    * 包含默认值参数的函数
    */
  def f2(a: Int = 4, b: Int = 5): Int = {
    a + b
  }
  println(f2(b = 6))
}
  • 可变参数函数,java中int…
package com.shsxt


object Function {
  def main(args: Array[String]): Unit = {
  /**
    * 可变参数函数
    */
  def sum(a:Int*) ={
    var sum =0
    for(i <- a){
      sum += i
    }
    sum
  }
  println(sum(1,2,3,4,5))
}
  • 匿名内部类
package com.shsxt


object Function {
  def main(args: Array[String]): Unit = {
  /**
    * 匿名函数
    */
  var f4 = (a:Int,b:Int) => {
    println(a+b)
  }
  f4(1,10)
  val f5 =()=>{
    println("无参匿名函数...")
  }
  f5()
}
  • 嵌套函数
package com.shsxt


object Function {
  /**
    * 嵌套函数
    */
  def f6(a: Int, b: Int) = {
    def f7(c: Int) = {
      (a + b) * c
    }

    println(f7(10))
  }

  f6(1, 2)
}
  • 偏应用函数,变化的自有一个参数
package com.shsxt

import java.util.Date
object Function {
  def main(args: Array[String]): Unit = {
  /**
    * 偏应用函数
    */
  def log(date: Date, log: String) = {
    println("date is " + date + ",log is " + log)
  }
  val date = new Date()
  //想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
  val logWithDate = log(date, _: String)
  logWithDate("log11")
  logWithDate("log12")
  logWithDate("log13")
  • 高阶函数: 函数的参数是函数，或函数的返回类型是函数，或函数的参数和函数的返回类型都是函数的函数
      def f7(a: Int, f: (Int, Int) => Int) = {
         val result = f(1, 2)
         println(   "result : " + result)
         println(a * result)
        }
       def sum(a: Int, b: Int):Int = {a + b}
        f7(5,sum)
       f7(5,(a:Int,b:Int)=>{a + b})
        def f8(a:Int,b:Int):(String,String)=>String = {
            def f9(c:String,d:String):String={
                a + "!" + b + "!" + c + "!" + d
            }
            f9
        }
        // alt + enter
   		 val f9: (String, String) => String = f8(1,2)
    	val result = f9("3","4")
    	println(result)
    	val result = f8(6,7)("8","9")
    	println(result)
  • 柯里化函数:可以理解为高阶函数的简化
package com.shsxt

import java.util.Date
object Function {
  def main(args: Array[String]): Unit = {
/**
 * 柯里化函数
 */
def fun7(a :Int,b:Int)(c:Int,d:Int) = {
   a+b+c+d
  }
 println(fun7(1,2)(3,4))
}

5.Scala字符串

package com.shsxt

/**
  * Created by Administrator on 2019/12/23.
  */
object String {
  def main(args: Array[String]): Unit = {
    val str = "abcd"
    println(str.indexOf(98))
    println(str.indexOf("b"))

    val str1 = "ABCD"
    //比较地址
    println(str==str1)
    /**
      * compareToIgnoreCase
      * 不区分大小写
      * 如果参数字符串等于此字符串，则返回值 0；
      * 如果此字符串小于字符串参数，则返回一个小于 0 的值；
      * 如果此字符串大于字符串参数，则返回一个大于 0 的值。
      *
      */
    println(str.compareToIgnoreCase(str1))
    /**
      * 字符串连接使用StringBuilder
      */
    var stringBuilder = new StringBuilder
    stringBuilder.append("abc")
    stringBuilder.+('d')
    stringBuilder+'e'
    stringBuilder.++("fg")
    stringBuilder++="hi"
    stringBuilder.+=('j')
    stringBuilder+='k'
    println(stringBuilder)
  }
}

6.数组

  • 创建,遍历,合并
package com.shsxt

/**
  * 可变集合,不可变集合
  */
object Sxt_Array {
  def main(args: Array[String]): Unit = {
    //创建数组
    val array =Array(1,2,3)
    //遍历
    for (i<- array){
      println(i)
    }
    array.foreach(x=>{println(x)})
    array.foreach(println(_))
    array.foreach(println)
    //创建数组
    val array1 =new Array[Int](3)
    array1(0)=1
    array1(1)=2
    array1(2)=3
    array1.foreach(println)

    println("=====创建二维数组======")
    //创建二维数组
    val array2=new Array[Array[Int]](3)
    array2(0)=Array(1,2)
    array2(1)=Array(3,4)
    array2(2)=Array(5,6)
    array2.foreach(x=>{
      x.foreach(println)
    })

    println("=====合并数组=======")
    //合并数组
    var arr1 = Array("1","2","3")
    var arr2 = Array("3","4","5")
    val array3=Array.concat(arr1,arr2)
    array3.foreach(println)

    println("======创建初始值的定长数组=======")
    //创建初始值的定长数组
    val arr = Array.fill(5)("shsxt")
    arr.foreach(println)
  }
}

在这里插入图片描述

  • 可变长数组
val arr = ArrayBuffer[String]("a","b","c")
arr.append("hello","scala")//添加多个元素
arr.+=("end")//在最后追加元素
arr.+=:("start")//在开头添加元素
arr.foreach(println)

7.list

  • 创建,遍历
package com.shsxt

/**
  * Created by Administrator on 2019/12/24.
  */
object Sxt_list {
  def main(args: Array[String]): Unit = {
    //创建
    var list =List(1,2,3)
    //遍历
    for (i<-list){
      println(i)
    }
    list.foreach(println)

    println("======常用方法=========")
    //filter  过滤
    val result: List[Int] =list.filter(x=>{
      if(x>2)
        true
      else
        false
    })
    result.foreach(println)

    //计算符合条件的元素个数
    val  count: Int =list.count(x=>{
      if(x>2)
        true
      else
        false
    })
    println(count)

    //操作集合里面的元素
    val result1: List[Int] =list.map(x=>{
      x*2
    })
    result1.foreach(println)

    val array = List("hello shsxt","hello bjsxt","hello gzsxt")
    val mapResult: List[Array[String]] =array.map(x=>{
      x.split(" ")
    })
    mapResult.foreach(println)

  println("======flatmap ：压扁扁平,先map再flat========")
    val result2: List[String] = array.flatMap(x=>x.split(" "))
    result2.foreach(println)
  }
}
  • 可变长数组
val listBuffer = ListBuffer(1,2,3)
   listBuffer.append(3,4,5)
   listBuffer.foreach(println)
val listBuffer: ListBuffer[Int] = ListBuffer[Int](1,2,3,4,5)
listBuffer.append(6,7,8,9)//追加元素
listBuffer.+=(10)//在后面追加元素
listBuffer.+=:(100)//在开头加入元素
listBuffer.foreach(println)

8.set

  • 创建,遍历,常用方法
package com.shsxt

/**
  * set
  */
object Sxt_set {
  def main(args: Array[String]): Unit = {
    //set自动去重
    val set1: Set[Int] = Set(1,2,2,3)
    set1.foreach(println)
    //最大
    println(set1.max)
    //最小
    println(set1.min)
    val set2 = Set(1,4,5)
    //转成字符串
    val str = set2.mkString("!")
    println(str)
    println("====并集====")
    val set = set1.union(set2)
    set.foreach(println)
    println("===差集====")
    val set3 = set2.diff(set1)
    set3.foreach(println)
    println("===交集====")
    val set4 = set1.intersect(set2)
    set4.foreach(println)
  }
}
  • 可变长度set(需手动导包)
import scala.collection.mutable.Set
val set = Set[Int](1,2,3,4,5)
set.add(100)
set.+=(200)
set.+=(1,210,300)
set.foreach(println)

9.Map

  • 创建,遍历,合并map
package com.shsxt

/**
  * Created by Administrator on 2019/12/24.
  */
object Sxt_map {
  def main(args: Array[String]): Unit = {
    //创建map
    val map: Map[String, Any] = Map("name" -> "zs", "age" -> "18", ("money", 100))
    //全遍历
    map.foreach(x => println(x._1 + " " + x._2))
    //不确认map是否存在
    val option = map.get("name")
    println(option.get)
    //如果没有指定map的值,就赋值传入的值
    val result = map.getOrElse("lala", 100)
    println(result)
    println("==========================")
    //遍历key
    val keyIterable = map.keys
    keyIterable.foreach(key => {
      println(key + " " + map.get(key).get)
    })
    println("==========================")
    //遍历value
    val valueIterable = map.values
    valueIterable.foreach(value => {
      println(value)
    })
    println("==================")
    //合并map 合并map会将map中的相同key的value替换
    val map1 = Map((1, "a"), (2, "b"), (3, "c"))
    val map2 = Map((1, "aa"), (2, "bb"), (2, 90), (4, 22), (4, "dd"))
    map1.++(map2).foreach(x=>{
      println(x._1+" "+x._2)
    })
  }
}
  • map的常见方法
    /**
     * map方法
     */
    //count统计符合条件的记录数
    val countResult  = map.count(p => {
      p._2.equals("shsxt")
    })
    println(countResult)
    
    //filter过滤，留下符合条件的记录
    map.filter(_._2.equals("shsxt")).foreach(println)
    
    //contains map中是否包含某个key
    println(map.contains(2))
   
    //exist 符合条件的记录存在不存在
    println(map.exists(f =>{
      f._2.equals("xasxt")     
    }
  • 可变长读map(需手动导包)
import scala.collection.mutable.Map
val map = Map[String,Int]()
map.put("hello",100)
map.put("world",200)
map.foreach(println)

10.元组

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的

  • 创建元组与取值

    package com.shsxt

object Sxt_tuple {
  def main(args: Array[String]): Unit = {
    //创建，最多支持22个
    val tuple = new Tuple1(1)
    val tuple2 = Tuple2("zhangsan",2)
    val tuple3 = Tuple3(1,2,3)
    val tuple4 = (1,2,3,4)
    val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
    val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
    //使用
    println(tuple2._1 + "\t"+tuple2._2)
    val t = Tuple2((1,2),("zhangsan","lisi"))
    println(t._1._2)
      
    //创建和取值
    val tuple2: (String, Int) = Tuple2("zhangsan",2)
    println(tuple2._1 + "\t"+tuple2._2)
    val t = Tuple2((1,2),("zhangsan","lisi"))
    println(t._1._2)

    //遍历
    val tuple4 = (1,2,3,4)
    val tupleIterator=tuple4.productIterator
    while(tupleIterator.hasNext){
      println(tupleIterator.next())
    }
    //swap方法,元素翻转(只针对二元组)
    val swap=tuple2.swap
    println(swap)
  }
}
vitorl_Ch
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala简要笔记整理
weixin_45817632的博客
02-19 293
IDEA创建Scala项目： 创建一个Maven项目：在maven项目环境下进行编码 新建目录需要编译 目录-->右键-->Mark Dirctory as --->Source Root 作为源码(编译成功 目录颜色会从灰色变色浅绿色) 把项目和Scala关联 项目-->右键-->Add Framework Support --->scala 右...
scala中的Unit
weixin_34362875的博客
04-27 3561
2019独角兽企业重金招聘Python工程师标准>>> ...
Scala函数式编程
Markble
08-23 5246
一、函数式编程 1）面向对象编程 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。 对象：用户 行为：登录、连接JDBC、读取数据库 属性：用户名、密码 Scala语言是一个完全面向对象编程语言。万物皆对象 对象的本质：对数据和行为的一个封装 2）函数式编程 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。 例如：请求->用户名、密码->连接JDBC->读取数据库 Scala语言是一个完全函数式
Scala基础5——第5章：函数式编程
qq_35556504的博客
08-17 248
第5章：函数式编程 （1）面向对象编程 ​ 解决问题，分解对象，行为，属性，然后通过对象的关系以及的调用来解决问题 ​ 对象：用户 ​ 行为：登录、连接JDBC、读取数据库 ​ 属性：用户名、密码 ​ Scala语言是一个完全面向对象编程语言。万物皆对象 ​ 对象的本质：对数据和行为的一个封装 （2）函数式编程 ​ 不断的对表达式求值 y=f(x) 5.1 函数基本语法 （1）基本语法 // sum函数名 // (x:Int,y:Int)参数名，参数类型 // : Int = {} 返回值类型
九阴真经--scala函数式编程高级
奔波在代码路上
04-28 141
一、高阶函数 在scala中函数是一等公民，对于一个函数我们可以定义函数、调用函数。 函数可以作为值传递： 在函数后加 空格 + _，可以把函数整体赋值给某个变量 如果明确函数的返回值。可以不加 _ ，将函数的返回值赋值给某个变量 函数可以作为参数传递：一般已匿名函数进行传递 函数可以作为函数值返回：通常通过函数嵌套来实现 def f1(name:String) : Unit = ...
scala：scala代码
02-10
Scala是一种多范式编程语言，它融合了面向对象和函数式编程的概念，为开发者提供了强大的工具来构建复杂、高效和可扩展的软件系统。在"scala: scala代码"的描述中，我们可以推测这是一个关于Scala编程语言的学习资源...
Scala考试题1
08-08
Scala 是一种多范式的编程语言，它融合了面向对象和函数式编程的特性。下面将详细解释题目中涉及的Scala知识点： 1. **var、val 和 def 的区别**： - `var` 定义可变变量，可以多次赋值。 - `val` 定义不可变变量...
ScalaAPI
03-08
Scala Web API 一个教育性项目，旨在探索功能性网络编程。欢迎使用ScalaAPI！ 该API提供有关动物穿越的游戏信息； 新视野，组织成各种端点。 如果您不熟悉，可以在官方页面。 简要介绍一下，您扮演的是岛上居民的新...
ScalaTest
02-20
ScalaTest 是一个强大的测试框架，专门用于 Scala 编程语言。它为开发者提供了一种简洁、类型安全的方式来编写测试，涵盖了单元测试、集成测试和端到端测试等多个方面。ScalaTest 的设计目标是使测试代码尽可能地...
scala0000000000
03-26
Scala是一种多范式编程语言，它融合了面向对象和函数式编程的概念，为开发者提供了强大的工具来构建复杂、可扩展的软件系统。标题"scala0000000000"暗示我们将深入探讨Scala语言的核心特性以及其最新版本2.13.6的...
scala 返回值_Scala系列3-Scala函数
weixin_39956612的博客
01-30 1655
Scala函数1. Scala函数的定义· 有参函数· 无参函数注意点：· 函数定义语法 用def来定义· 可以定义传入的参数，要指定传入参数的类型· 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。· scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，...
scala函数
weixin_52576490的博客
03-30 291
Scala中函数： 方法也是函数 在类中声明的函数称为方法，在其他场合声明就是函数了 类中的方法可以重载和重写，但是函数没有重载和重写 方法不可以嵌套使用，但是函数可以嵌套使用 1)无参无返回值： def fun1() : Unit = { //函数体 } 2)无参有返回值 def fun2() : String = { //函数体 } 3)有参，无返回值 def fun3(age : Int) : Unit = { //函数体 } 4)有参，有返回值 def fun4(age : Int) : Int =
Scala 函数的特征
Smiling_lzy的博客
04-20 235
函数特征1、函数返回值类型推导2、Unit( = 省略)3、参数为0 ()可省4、参数默认为 val5、函数的默认值 1、函数返回值类型推导 函数的返回值类型可以省略，然后 scala 会根据最后一行代码，推导处函数返回值类型 注：        有些情况不能推导：        1. 函数内有 return 语句     &nb
2024年中国汽车行业AI大模型
最新发布
08-12
一、大模型概述 二、中国大模型发展挑战 三、大模型测评 测评平台：方法论、评估维度 IDC 测试：基础能力、应用能力 通用大模型：Qwen-Max-0428 等 四、2024 年大模型发展趋势 技术方向：模型整合、参数规模扩展、多模态融合、小型化 产业方向：国产 AI 芯片、数据产权标准、套壳微调、人工智能伦理 五、大模型知识密度 知识密度提升：MMLU 榜单表现 小参数模型：MiniCPM-Llama3-V 2.5 六、大模型产业应用案例 百度文心一言：发展历程、技术架构、应用场景 华为盘古大模型：CloudMatrix 架构、ModelArts AI 开发生产线 科大讯飞星火大模型：语音交互、智能座舱、机器人超脑 商汤日日新大模型：SenseChat V5、SenseNova 5.0、车载端侧部署 腾讯混元大模型：研发历程、技术优势、行业应用 特斯拉 FSD：端到端自动驾驶、数据驱动 小鹏汽车 XGPT：自动驾驶大模型、AI 天玑系统 毫末智行 DriveGPT：雪湖·海若、多模态感知、语义感知 思必驰 DFM-2：统一生成式对话基础模型、DUI 2.0 面壁智能 MiniCPM
ISTQB(专家级-改进测试过程-实施测试过程改进)考试大纲_模拟题&答案.zip
08-12
ISTQB(专家级-改进测试过程-实施测试过程改进)考试大纲_模拟题&答案
Swift Swift简单例子,需要配置相关环境才能正常运行
08-12
Swift Swift简单例子,需要配置相关环境才能正常运行 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步。
Huawei CE12800-V200R023SPH150
08-12
Huawei CE12800_V200R023SPH150，里面包含补丁说明书和补丁安装指导书，该补丁支持哪些型号，支持哪些版本可以安装当前补丁，请参考补丁说明书和补丁安装指导书。
基于Springboot和Vue的图书馆管理系统源码 图书馆管理系统代码（98分期末优秀大作业）
08-12
图书馆管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C++教学资料，入门+提高+核心
08-12
C++是一种高效、功能丰富的编程语言，它继承了C语言的高效性和灵活性，同时引入了面向对象编程的概念，如类和对象、继承、多态和封装。这些特性使得C++在软件设计中能够提供更好的代码复用性和模块化。 C++的设计哲学强调性能和对资源的精细控制，这使得它在需要高性能计算的场合，如游戏开发、实时系统、嵌入式系统等领域非常受欢迎。C++也支持异常处理，允许程序在遇到错误时优雅地恢复或终止。 随着C++标准的不断更新，语言本身也在不断进化，引入了新的功能和特性，如智能指针、Lambda表达式、并发编程支持等，以适应现代软件开发的需求。 C++广泛应用于各种类型的软件开发中，包括桌面和移动应用、服务器和网络软件、高性能计算、科学计算以及各种需要精细控制硬件资源的场合。由于C++与C语言的兼容性，许多C语言编写的库和工具可以无缝集成到C++程序中。 然而，C++的复杂性和对性能的强调也意味着它需要程序员具备较高的技能水平，以避免常见的陷阱和错误。尽管如此，C++依然是一门强大且广泛使用的语言，适合那些追求高性能和精细控制的开发者。
Scala编程指南
"Programming.Scala - 一本由Dean Wampler和Alex Payne合著的关于Scala编程的书籍" 在《Programming Scala》这本书中，作者深入浅出地介绍了Scala这门多范式编程语言，它融合了面向对象和函数式编程的特性。Scala...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值