第 1 章 Scala核心编程之基础案例

其他 2020-03-06 22:52:31 阅读次数: 0

1、字符串输出3种方式

方式一：格式化输出
代码具体实现：

package com.study.scala01

object Scala_01 {
  def main(args: Array[String]): Unit = {
    var str1:String="hello"
    var str2:String="word!"
    println(str1+str2)

    var name:String="tom"
    var age:Int=10
    var sal:Float=10.34f
    var height:Double=180.15

    //格式化输出
    printf("名字=%s 年龄是%d 薪水是.2f  高薪是.3f",name,age,sal,height)
  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述
方式二：编译器会去解析输出
具体代码实现：

package com.study.scala01

object Scala_01 {
  def main(args: Array[String]): Unit = {
    var str1:String="hello"
    var str2:String="word!"
    println(str1+str2)

    var name:String="tom"
    var age:Int=10
    var sal:Float=10.34f
    var height:Double=180.15

  
    //scala支持使用$输出的内容,编译器会去解析$对应的变量
    println(s"\n个人信息列表如下: \n名字$name \n年龄$age \n薪水$sal")
  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述
若想对属性的参数添加，可以对代码修改如下：
在这里插入图片描述

 //如果在字符串中出现了类似{age+10}，则表达{}是一个表达式
 println(s"\n个人信息列2表如下: \n名字${name} \n年龄${age+10} \n薪水${sal*100}")

启动程序，控制台输出打印的信息：
在这里插入图片描述

小结：Scala输出的三种方式
（1）字符串通过+号连接（类似java）
（2）printf用法（类似C语言）字符串通过%传值
（3）字符串通过$引用（类似PHP）

2、关联Scala源码

代码实现：

package com.study.scala01

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

    var arr=new Array[Int](10)
    //对代码进行格式化的快捷键ctrl+alt+l
    for (item <-arr){
      println("item="+item)
    }
  }
}

启动程序，控制台输出打印的信息：
在这里插入图片描述
查看源码
在这里插入图片描述
在这里插入图片描述
弹出
在这里插入图片描述
拷贝源码包：scala-sources-2.12.4.tar，放在lib文件下
在这里插入图片描述
还需要对这个包进行解压，再进行源码关联，关联后：
在这里插入图片描述

3、文档注释

具体代码：

package com.study.scala01

object Scala_03 {
  def main(args: Array[String]): Unit = {
    println("HelloWord")
  }

  /**
   * @deprecated 过期了
   * @example
   *          输入n1=10 n2=20 return  30
   * @param n1
   * @param n2
   * @return 和
   */
  def sum(n1:Int,n2:Int){
    return n1+n2
  }
}

保存（ctlrl+S）

cmd窗口执行：
在这里插入图片描述
弹出cmd窗口，输入：scaladoc
在这里插入图片描述
输入生成文档的类，执行命令：scaladoc -d d:/mydoc scala_03.scala
在这里插入图片描述
文件夹查看，已经超过生成了
在这里插入图片描述
在这里插入图片描述

4、基本变量的使用

代码实现

package com.study.scala01

object Scala_04 {
  def main(args: Array[String]): Unit = {
   //编译器，动态的（逃逸分析）
    var age:Int=10
    var name:String="tom"
    var height:Double=10.9
    var isPass:Boolean=true

   var score:Float=70.9f

    //在scala中，小数默认为Double，整数默认为：Int
    println(s"${age} ${isPass}")

  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述

类型转换、数据插入到转换位置
具体代码实现：

package com.study.scala01

object Scala_04 {
  def main(args: Array[String]): Unit = {
    var num1:Int=10

    println(num1.toDouble + "\t" +num1.toString + 2020.toDouble)
  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述

5、Scala整型

代码实现：

package com.study.scala01

object Scala_04 {
  def main(args: Array[String]): Unit = {
    println("long的最大值："+Long.MaxValue+"~"+ Long.MinValue)
  }
}

启动程序，控制台输出打印的信息：

在这里插入图片描述

6、for循环遍历

代码实现：

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      println(i)
  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述

7、数据循环

代码实现：

package com.study.scala01

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)
  }

}

启动程序，控制台输出打印的信息：
在这里插入图片描述
高级循环，执行代码：

 //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()

启动程序，控制台输出打印的信息：

在这里插入图片描述
for推导式

package com.study.scala01

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)
  }
}

启动程序，控制台输出打印的信息：
在这里插入图片描述

8、定长数组和变长数组

代码实现：

package com.study.scala01

import scala.collection.mutable.ArrayBuffer

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //初始化一个长度为8的定长数组，其所有元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)

    //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

    //////////////////////////////////////////////////
    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab

    //在数组某个位置插入元素用insert
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove
    ab.remove(8, 2)
    println(ab)

  }
}

启动程序，控制台输出打印的信息：
在这里插入图片描述

9、遍历数组

好用的until会生成脚标，0 until 10 包含0不包含10
代码实现：

package com.study.scala01

import scala.collection.mutable.ArrayBuffer

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //初始化一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for(i <- arr)
      println(i)
    println()

    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))

  }
}

启动程序，控制台输出打印的信息：
在这里插入图片描述

10、数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
代码实现：

package com.study.scala01

import scala.collection.mutable.ArrayBuffer

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)

    //更高级的写法,用着更爽
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)

  }
}

启动程序，控制台输出打印的信息：
在这里插入图片描述

集合

在这里插入图片描述

序列

在这里插入图片描述
代码实现：

package com.study.scala01

import scala.collection.mutable.ArrayBuffer

object Scala_04 {
  def main(args: Array[String]): Unit = {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    val lst3 = lst1.::(0)
    val lst4 = 0 +: lst1
    val lst5 = lst1.+:(0)

    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3

    val lst0 = List(4,5,6)
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst1插入到lst0前面生成一个新的集合
    val lst8 = lst1 ++ lst0

    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)

    println(lst9)

  }
}

启动程序，控制台输出打印的信息：

在这里插入图片描述

可变的序列
代码实现：

package com.study.scala01

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

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

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

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1

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

  println("一个可变lst0列表"+lst0)
  println("一个可变lst1列表"+lst1)
  println("一个可变lst2列表"+lst2)
  println("一个可变lst3列表"+lst3)
}

启动程序，控制台输出打印的信息：
在这里插入图片描述
不可变的Set
代码实现：

package com.study.scala01

import scala.collection.mutable

object Scala_04 extends App{
  val set1 = new mutable.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)
  println()
  println(set1.getClass)
  println()
  println(set2.getClass)
  println()
  println(set3.getClass)
}

启动程序，控制台输出打印的信息：
在这里插入图片描述

可变的Set
代码实现：

package com.study.scala01

import scala.collection.mutable

object Scala_04 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)

}

启动程序，控制台输出打印的信息：
在这里插入图片描述

Map
代码实现：

package com.study.scala01

import scala.collection.mutable

object Scala_04 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)

}

启动程序，控制台输出打印的信息：
在这里插入图片描述

江湖侠客
发布了216 篇原创文章 · 获赞 20 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_39868387/article/details/104377342
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022