Scala实战专栏 (一) ——— 字符串

最新推荐文章于 2021-11-11 17:15:11 发布
最新推荐文章于 2021-11-11 17:15:11 发布
阅读量4.5k 收藏 2
点赞数 1
分类专栏： Scala 后端 Scala编程实战 文章标签： Scala Scala隐式转换 Scala字符串的处理函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thinking_fioa/article/details/82597306
版权

scala-basic 基础篇

@author 鲁伟林
Scala基础知识介绍，主要包括《Scala编程实战》基础章节

GitHub地址: https://github.com/thinkingfioa/scala-in-action
本人博客地址: http://blog.csdn.net/thinking_fioa/article/details/78265745

第1章 字符串

第1章项目源码阅读

1. 引言

初一看Scala的String和Java的String并没有什么区别，基本上Java的String所具有的属性Scala的String都具有。另一方面，由于Scala提供了隐式转换的魔法，Scala的String同时还拥有StringOps类、StringLike类WrappedString等方法。

下列是Scala的String常具有的方法

1. "hello".foreach(println) 
2. for(c <- "hello") println(c)
3. "hello".getBytes.foreach(println)
4. var result = "hello world".filter(_ != 'l')

Scala隐式转换的理解

Scala隐式转换是一种非常强大的代码查找机制。通过隐式转换，程序员可以在编写Scala程序时故意遗漏一些信息，让编译器去尝试在编译期间自动推导出这些信息，减少冗长代码。

简单的说，隐式转换就是：当Scala编译器进行类型匹配时，如果找不到合适的候选，那么隐式转化提供了另一种途径来告诉编译器如何将当前的类型转换成预期类型

使用方式:

  1. 将方法或变量标记为implicit 
  2. 将方法的参数列表标记为implicit
  3. 将类标记为implicit
  4. 参考例子：*.chapter.one.impl.{ImplicitHelper, ImplicitTest}

代码:

package org.lwl.scala.basic.chapter.one.impl

object ImplVal {
  implicit val name: String="reynold1"
}

object ImplicitHelper {

  def echo(param: String)(implicit impl: String): Unit = {
    println(param + "," +impl);
  }

  /**
    * 这个函数和函数名字无关，和入参名字无关，只和入参类型以及返回类型有关
    */
  implicit def strToInt(str: String) = {
    str.toInt
  }

 /**
    *  隐式类的主构造函数参数有且仅有一个！之所以只能有一个参数，
    */
  implicit class ImpAdd(origin: Int) {
    def add(param: Int) = origin + param;
  }
}

1.1 测试字符串的相等性

  1. 比较两个字符串相等, eg: s1 == s2。不会抛出NPE异常
  2. 不考虑字符大小写问题比较, eg: s1.toUpperCase == s2.toUpperCase。需要处理抛出NPE异常
  3. 使用Java的字符串类, eg: s1.equalsIgnoreCase(b)

代码:

object String1P1 {
  def main(args: Array[String]): Unit = {
    val s1="thinking"
    val s2="Thinking"

    println(s1==s2) // 输出: false
    println(s1.toUpperCase == s2.toUpperCase) // 输出: true
    println(s1.equalsIgnoreCase(s2)) // 输出: true
  }
}

1.2 创建多行字符串

Scala使用三个双引号创建多行字符串

  1. 多行字符串，所见即所得。也就是，你在代码中怎么写，输出就是什么样
  2. 使用特殊字符+stripMargin，达到多行字符串都是顶格写
  3. 多行字符串单行显示， """moreLineStr""".stripMargin.replaceAll("\n", " ")
  4. 多行字符串语法中允许写单引号和双引号，无需转义

代码:

object String1P2 {

  def main(args: Array[String]): Unit = {
    val moreStr = moreLineStr
    println(moreStr)

    val oneStr = singleLine
    println(oneStr)
  }

  def moreLineStr : String = {
     """ thinking_fioa
      | luweilin"""".stripMargin

  }

  def singleLine : String = {
    """" "thinking_fiao"
      | 'luweilin'""".stripMargin.replace("\n", "")
  }
}

1.3 分割字符串

使用split("...")分割一个字符串。split支持使用正则表达式，eg： str.split("\s+")

代码:

object String1P3 {

  def main(args: Array[String]): Unit = {
    val str : String = "thinking, fioa, lu ppp"
    val strArray : Array[String] = splitStr(str)
    strArray.foreach(println)
  }

  def splitStr(str: String) : Array[String] = {
    val strArray: Array[String] = str.split("\\s+").map(_.trim)
    strArray
  }
}

1.4 字符串中的变量代换

在字符串中引用变量的值

1.4.1 字符串插值 - 字符串前加字母's'

在每个字符串前的's'实际上是一个方法

  • $variable ----- println(s"Age is $age")
  • 使用表达式 ----- println(s"Age next year: ${age + 1}")

1.4.2 字符串插值 - 字符串前加字母'f'

在字符串前加字母'f'，格式化内部字符串。eg: val out = f"$name, you weight $weight%.2f pounds."

1.4.3 字符串插值 - 字符串前加字母raw

raw插入符"不会对字符串中的字符进行转义"

代码:

object String1P4 {

  def main(args: Array[String]): Unit = {
    strOfS()
    strOfF()
    strOfRaw()
  }

  def strOfS() : Unit = {
    val name : String = "thinking"
    val age : Int = 23

    println(s"$name is $age years old")
    println(s"Age next year: ${age +1}")
  }

  def strOfF() : Unit = {
    val weight : Double = 120

    println(f"my weight is $weight%.2f")
  }

  def strOfRaw() : Unit = {
    val str = raw"thinking\nppp"
    println(str)
  }
}

1.5 挨个处理字符串中的字符

遍历字符串中的每个字符，在遍历的同时对字符串做些操作。可以使用map、foreach方法、for循环来遍历集合

1.5.1 map

对于字符串字符序列集合，先使用filter过滤单个字符，然后调用map方法处理每个字符. eg: val upper = "thinking, fioa".filter(_ != 'i').map(_.toUpper)

1.5.2 使用for + yield语句实现1.5.1中的效果

在for循环添加yield实际上将每次循环的结果放入一个临时存放区。等循环结束后，以集合的形式返回. eg: val upper = for(c <- "thinking, fioa") yield c.toUpper

1.5.3 传入函数到map中

可以给map方法传入一个大的代码块. eg: val upper = "thinking, fioa".filter( _ != 'i').map(strToUpper)

1.5.4 foreach方法

使用foreach方法操作每个Byte值. eg: "hello".getBytes.foreach(println)

代码:

object String1P5 {

  def main(args: Array[String]): Unit = {
    mapStr()
    forStr()
    mapOfMethod()
  }

  def mapStr() : Unit = {
    val upper = "thinking, fioa".filter( _ != 'i').map(_.toUpper);
    println(upper)
  }

  def forStr() : Unit = {
    val upper = for( c <- "thinking, fioa") yield c.toUpper
    println(upper)
  }
  
  def mapOfMethod() : Unit = {
    val upper = "thinking, fioa".filter( _ != 'i').map(strToUpper)
    println(upper)
  }

  def strToUpper(c : Char) : Char = {
    c.toUpper
  }
}

1.6 字符串中的查找模式

判断一个字符串是否符合一个正则表达式

1.6.1 创建Regex对象

  1. 在一个String上调用.r方法可以创建一个Regex对象. val numPattern = "[0-9]+".r
  2. 创建Regex实例. val numPattern = new Regex("[0-9]+")

1.6.2 查找匹配方法： findFirstIn(含有一个匹配) + findAllIn(全部匹配)

  • findFirstIn方法返回一个Option[String]。可以使用Option类中的getOrElse方法，这个将在20.6节介绍更多内容
  • findAllIn方法返回一个迭代器，可以直接使用foreach方法遍历。或者toArray方法转换成Array数组

代码:

object String1P6 {

  def main(args: Array[String]): Unit = {
    val numPatter = "[0-9]+".r
    val str : String = "123 Main Stree Suit 101"
    firstReg(str, numPatter)
    allReg(str, numPatter)

    findRegAndOption(str, new Regex("[9]+"))
  }

  def firstReg(str: String, numPattern: Regex) : Unit = {
    numPattern.findFirstIn(str).foreach(println)
    println("end of firstReg")
  }

  def allReg(str: String, numPattern : Regex) : Unit = {
    numPattern.findAllIn(str).foreach(println)
    println("end of allReg")
  }

  def findRegAndOption(str: String, numPattern: Regex) : Unit = {
    println(numPattern.findFirstIn(str).getOrElse("no match"))
  }
}

1.7 字符串中的替换模式

使用正则表达式匹配一段字符串，然后替换它们。注意,String是不可变的，请一定记得把结果赋给一个新的变量

1.7.1 使用String类的方法

  • replaceAll ----- 替换所有匹配的字符串. eg: val result = "123".replaceAll("[0-9]", "x")
  • replaceFirst ----- 替换第一个匹配的字符串. eg: val result = "123".replaceFirst("[0-9]", "x")

1.7.2 使用正则表达式的方法

  • replaceAllIn ----- 替换所有匹配的字符串. eg: val result = regex.replaceAllIn("123 Main Street", "x")
  • replaceFirstIn ----- 替换第一个匹配的字符串. eg: val result = regex.replaceAll("Hello world", "J")

代码:

object String1P6 {

  val originStr : String = "123 Main Street 456"

  def main(args: Array[String]): Unit = {
    val return1 = replaceOfString(originStr)
    println(s"return 1 is ${return1._1}, return 2 is ${return1._2} ")

    val return2 = replaceOfRegex("[0-9]+".r)
    println(s"return 1 is ${return2._1}, return 2 is ${return2._2} ")
  }

  private def replaceOfString(str : String) : (String, String) = {
    val allStr : String = str.replaceAll("[0-9]+", "x")
    val firstStr : String = str.replaceFirst("[0-9]+", "x")
    (allStr, firstStr)
  }

  private def replaceOfRegex(regex : Regex) : (String, String) = {
    val allStr : String = regex.replaceAllIn(originStr, "x")
    val firstStr : String = regex.replaceFirstIn(originStr, "x")
    (allStr, firstStr)
  }
}

1.8 抽取String中模式匹配部分

抽取一个或者多个在字符串中正则匹配到的部分

1.8.1 简单匹配

定义想要抽取的正则表达式，在它们周围加上括号. eg: val pattern = "([0-9]+) ([A-Za-z]+)".r

1.8.2 复杂匹配

通常，可能定义多个正则表达式，用于处理不管用户输入什么，都可以匹配到，所以使用到match-case语法。具体将在3.7节学习

代码:

object String1P8 {

  def main(args: Array[String]): Unit = {
    one("([0-9]+) ([A-Za-z]+)".r, "100 apple")
  }

  def one(pattern : Regex,inputStr : String) : Unit = {
    val pattern(count, fruit) = inputStr
    printf(s"$fruit price is $count")
  }
}

1.9 访问字符串中的一个字符

得到字符串中指定位置的一个字符

  • 使用Java中的charAt方法 ----- "hello".charAt(0)
  • 使用Scala中的Array符号 ----- "hello"(0)

1.10 在String类中添加自定义的方法

在Scala 2.10以后，通过定义一个隐式转换的类，在类里定义一些方法，以实现添加自定义的方法。注意：隐式转换类必须定义在一个类或者对象或者包的内部。请给声明自定义方法时，加上返回类型

代码:

object String1P10 {

  def main(args: Array[String]): Unit = {
    println("ABCDEFT".increment)
    println("  ".asBoolean.toString)
  }

  implicit class StringImprovements(val str: String) {
    def increment : String = str.map(c => (c+1).toChar)
    def asBoolean : Boolean = str match  {
      case "0" | "zero" | "" | " " => false
      case _ => true
    }
  }
}

讨论

隐式转换最大的好处就是：不需要继承自一个现有的类再去添加新的功能。例如，没有必要去创建继承自String类叫作MyString的新类。其工作原理:

  1. 编译器找到一个"ABCDEFT"的字符串常量
  2. 编译器发现要在String上调用increment方法
  3. 因为编译器在String类中找不到可调用的方法，于是开始在当前范围内搜索一个接收String作为参数的隐式转换
  4. 编译器找到StringImprovements类，并在这个类中找到increment方法
thinking_fioa
关注
专栏目录
Scala学习笔记——字符串与数组
tyh1579152915的博客
03-04 767
Scala学习笔记——字符串与数组 文章目录Scala学习笔记——字符串与数组一、字符串1、字符串的拼接与格式化2、字符串的常用方法二、数组1、声明数组的语法格式2、数组的创建与遍历3、多维数组的创建与遍历 一、字符串 在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。 这就意味着你如果修改字符串就会产生一个新的字符串对象。 1、字符串的拼接与格式化 def main(args: Array[String]): Unit = { var str: String = "tyh"
Scala编程实战——第一章 字符串(1)
小二温华
03-21 246
1.1测试字符串的相等性 == scala> val s1="Hello" s1: String = Hello scala> val s1 = "Hello" s1: String = Hello scala> val s2 = "Hello" s2: String = Hello scala> val s3 = "H" + "ello" s3: String ...
Scala的String类方法整合
11-04
Scala语言的字符串类型封装的方法总结。具有大多数的String字符串方法名及其描述
scala 字符串操作 在报文中寻找指定字符串
iris_new的博客
06-09 4220
scala 字符串操作
Spark记录-Scala字符串
weixin_30897079的博客
10-25 296
Scala字符串 在Scala中的字符串和Java中的一样，字符串是一个不可变的对象，也就是一个不能修改的对象。可以修改的对象，如数组，称为可变对象。字符串是非常有用的对象，在本节的最后部分，我们将介绍java.lang.String类的一些重要方法。 1.创建一个字符串 以下是创建一个字符串的代码 - var greeting = "Hello world!"; // 或者 ...
scala怎么检索某个字符_第五章 正则：通吃一切字符串处理
weixin_39608559的博客
11-23 418
简介正则表达式，又称规则表达式，通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。安装内置引擎 无需安装知识正则基础re模块处理字符串与系统内置str类型的函数的区别：re模块可以用规则表达式表示多个参数，同时处理，而且功能更强大...
判断某一个字符串是否存在另一个字符串中
weixin_33824363的博客
12-29 1397
实现这个功能，方法很多。下面Insus.NET列举2个方法：   class Bs { public string String1 { get; set; } public string String2 { get; set; } public void WithContains() { ...
Scala解析Json字符串的实例详解
10-19
在Scala编程中，处理JSON数据是一项常见的任务，用于解析、序列化和操作JSON字符串。本文将详细介绍如何使用`json-smart`库来解析JSON字符串。`json-smart`是一个轻量级的Java库，它提供了高效的JSON解析和生成功能...
邮电学院Scala大数据实时处理——基于Lambda架构的Spark源码
最新发布
03-25
项目概述：邮电学院Scala大数据实时处理——基于Lambda架构的Spark源码实践 本项目为邮电学院假期师资培训的成果，主要采用Scala语言开发，围绕Lambda架构构建了一套实时数据流处理系统。项目包含35个文件，其中...
scala 字符串函数_Scala字符串连接，子字符串，长度函数
从零开始的教程世界
07-10 3749
scala 字符串函数Scala String can be defined as a sequence of characters. Today we will look into String concatenation, substring and some other Scala string functions. Scala字符串可以定义为字符序列。 今天，我们将研究String串联，子...
Scala（一）之“字符串”
GnahzNib的博客
08-28 1万+
Scala中的String类
mysql中如何判定一个字符串在另一个字符串中是否存在
Bennett2251的博客
04-13 3966
find_in_set(str,str1)    判定str是否在str1中有，如果有，则返回其在str1中的位置，如果没有，返回0 eg:select find_in_set('13教',"浏阳基地,耕耘基地,文渊馆,13教,测试基地,耕耘基地"),返回4 这个函数有很大的局限性，他只能判别是否存在于第二个字符串中以逗号为分隔符的，如select find_in_set('13教',"浏阳基
字符串子串的查找
热门推荐
Arcsinsin的学习笔记
09-29 3万+
1. 考虑用标准函数库中 strstr() 函数 包含文件：string.h 函数名: strstr 函数原型：extern char *strstr(char *str1, char *str2); 功能：从字符串str1中查找是否有字符串str2，如果有，从str1中的str2位置起，返回str1中str2起始位置的指针，如果没有，返回null。 返回值：返回该位置的指针，如找不到，
Scala-Scala字符串操作
文文x的博客
06-16 471
package com.scala.BlLx object TestCharType { def main(args: Array[String]): Unit = { var name: String = "wenXin" var age: Int = 18 //(1)字符串，通过+连接 println(name + "今年" + age + "岁") //*用于将一个字符串复制多次拼接 println(name * 3 + "今年" + age +
scala怎么检索某个字符_Scala并发编程
weixin_39593593的博客
11-21 78
我之前总结过一篇 Terry Xiong：Java并发编程学习路线 的文章，可以看到Java本身的多线程开发是挺复杂的，涉及到很多底层的并发组件，例如锁，信号量等，一般来说使用这种方式写出的代码适合底层库的实现，但是对于业务代码，更合适的选择是使用一些并发编程框架，这个在《七周七并发模型》里面也有阐述，这篇文章我的目的是总结一下最近1-2年使用Scala并发编程的感受以及基础的Scala并发知识点...
Scala字符串、数组、集合
lyq7269的博客
07-25 1305
一、Scala字符串 scala字符串实际上就是java中的String，但是scala本身没有String类 创建字符串 创建字符串和创建变量是差不多的操作。 有两种创建方式： //方法一 var str:string= "我是字符串" //方法二 var str="我是也是字符串" 计算字符串长度 计算字符串长度的方法和java中用的方法基本一致str.lebgth() 案例演示： object MyFirst { def main(args: Array[String]): Unit = {
判断字符串中是否包括中文数字字母及其他
weixin_39196883的博客
11-11 872
''' 1、中文字符的编码范围是： u'\u4e00' - u'\u9fa5'; 2、但是跟python3的isalpha()函数（检测字符串中是否只有字符组成）一起判断时，要注意，isalpha()方法判断汉字时也返回True; ''' import importlib import sys import re importlib.reload(sys) def check_contain_chinese(check_str): china_num = 0 str_num = .
获取字符串中指定字符串出现的所有位置
weixin_41690497的博客
09-18 8863
String path = "localhost:8080"; String details = "&lt;p&gt;&lt;img src="/upload/5a52da4dN0a6d04b9.jpg!q701.jpg""&gt;&lt;/p&gt;" StringBuilder sb = new StringBuilde
Scala集合精粹（实现特质Like）
hellojoy的博客
07-27 1168
Controlling complexity is the essence of computer programming. -- Brian Kernigan. 当我第一次阅读Scala集合框架源代码时，众多的特质，类型参数，隐式参数，类型约束扑朔迷离，很难摸清框架设计的精髓。 例如TraversableLike.map方法声明： def map[B, That](f: A =&gt...
scala截取字符串第一个字符
05-17
在 Scala 中，可以使用字符串的 `charAt` 方法来获取字符串中指定位置的字符。要获取字符串的第一个字符，可以使用如下代码： ```scala val str = "hello" val firstChar = str.charAt(0) ``` 这将返回字符串中的第一个字符，即 `'h'`。你也可以使用字符串的 `take` 方法来截取字符串的前几个字符，例如： ```scala val str = "hello" val firstChar = str.take(1) ``` 这将返回字符串的前一个字符，即 `"h"`。注意，`take` 方法返回的是一个新的字符串，而不是单个字符。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值