La syntaxe de base de scala

note

Pour le commentaire scala, en bref, c'est juste une phrase, qui est exactement la même que le commentaire java
.

（1）单行注释：//
（2）多行注释：/* */
（3）文档注释：/**
              *
              */

Exemple de code :

package com.doitedu.demo01
object TestNotes {
 def main(args: Array[String]): Unit = {
 //（1）单行注释：//
 println("涛哥")
 
 //（2）多行注释：/* */
 /*
 println("涛哥")
 println("行哥")
 */
 
 //（3）文档注释：
 /**
 *
 */
 /**
 * println("乃哥")
 * println("雨哥")
 * println("行哥")
 */
   } 
} 

Variables et constantes (points clés)

// 回顾：Java 变量和常量语法
// 变量类型 变量名称 = 初始值 
int a = 10
// final 常量类型 常量名称 = 初始值 
final int b = 20
scala定义变量常量的基本语法
Scala
// var 变量名 [: 变量类型] = 初始值 
var i:Int = 10   variable ：可变的
// val 常量名 [: 常量类型] = 初始值 
val j:Int = 20   value ：值

var variable  可变的   代表声明变量

val  value  值    代表声明常量

Remarque :
• La plupart de nos opérations val dans le processus de programmation consistent à obtenir des valeurs ou à obtenir un objet créé, puis à manipuler les propriétés de l'objet et à modifier rarement cette variable d'objet • val est thread-safe, lorsqu'il est utilisé Plus
efficace
• Utilisez d'abord val, mais utilisez var lorsque la variable doit être modifiée ultérieurement

package com.doitedu.demo02
object TestVar {
 def main(args: Array[String]): Unit = {
 //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
     var age = 18
     age = 30
 //（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言。
// age = "zhangsan" // 错误
 //（3）变量声明时，必须要有初始值
// var name //错误
//（4）在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变量不可改。
 var num1 = 10 // 可变
 val num2 = 20 // 不可变
 num1 = 30 // 正确
 //num2 = 100 //错误，因为 num2 是 val 修饰的
     } 
}


object demo03{
 def main(args: Array[String]): Unit = {
 // p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
 var p1 = new Person()
 p1.name = "zhangsan"
 p1 = null
 // p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变），
但是，p2 的属性是可以变，因为属性并没有用 val 修饰。
 val p2 = new Person()
 p2.name="jinlian"
// p2 = null // 错误的，因为 p2 是 val 修饰的
 } 
}
class Person{
 var name : String = "jinlian"
} 

Pratique :
Duoyi a maintenant lancé une petite salle de classe pour vendre des cours (une petite plateforme e-commerce) :
pour les ventes, faut-il avoir des champs d'attributs :
nom du magasin : Duoyi Education
nom du cours : java Basics, mysql, hadoop... ..
Conférencier : Yuan Ge, Tao Ge, Xing Ge, Xing Ge
Prix du cours : 199 299 399,99
Type de paquet rouge : Achat de paquet rouge pour la première fois, paquet rouge pour les étudiants vétérans
Montant du paquet rouge : 9,9 18,8
Nom de l'activité : Les utilisateurs vétérans achètent encore une fois, les nouveaux utilisateurs achètent pour la première fois, les étudiants recommandent d'acheter
Type d'événement : 6.18, 10.24, 11.11
Intensité de la remise de l'événement : 10 % de réduction, 50 % de réduction, 12 % de réduction
Nom d'utilisateur de l'acheteur : zhangsan, numéro de téléphone de l'utilisateur lisi
 : 18860875775, 18860875776
Position actuelle de l'utilisateur : ingénieur etl, ingénieur en développement de données volumineuses, ingénieur en entrepôt de données e-
mail de l'utilisateur : e-mail
numéro de commande : 111122223333
montant de la commande : 398
code :

package com.doitedu

object demo01{

  /**
   * 店铺名称：多易教育
   * 课程名称：java基础,mysql,hadoop.....
   * 讲课老师：源哥,涛哥,星哥,行哥
   * 课程的价格：199,299,399,99
   * 红包类型: 首次购买红包,老学员红包
   * 红包金额：9.9  18.8
   * 活动名称：老用户再次购买,新用户首次购买,学员推荐购买
   * 活动类型：6.18     10.24  11.11
   * 活动折扣力度：9折   5折   8.8折
   * 购买用户用户名：姜海涛，江一
   * 用户手机号：18860875775，1886087，5776
   * 用户现在的职位：etl工程师，大数据开发工程师，数仓工程师
   * 用户的邮箱：email
   * 订单号：111122223333
   * 订单金额：119.4
   */
  def main(args: Array[String]): Unit = {
    //店铺名称：多易教育
    val shopName = "多易教育"
    //课程名称：java基础,mysql,hadoop.....
    val subjectName = "java基础"
    //讲课老师：源哥,涛哥,星哥,行哥
    val tName = "涛哥"
    //课程的价格：199,299,399,99
    val subjectPrice = 199.00
    //红包类型: 首次购买红包,老学员红包
    val bonusType = "new"
    //红包金额
    val bonus = 9.9
    //活动名称
    val activeName = "老用户再次购买"
    //活动类型：6.18     10.24  11.11
    val activeType = "程序员节"
    //活动折扣力度
    val activeDiscount = 0.6
    //购买用户用户名
    val userName = "haiTao Jiang"
    //用户手机号
    val tel = "13372090488"
    //用户邮箱
    val email = "[email protected]"
    //订单号
    val orderId = "111122223333"
    //订单金额
    val orderAmount = 119.4
  }

}

Conventions de dénomination des identificateurs

La séquence de caractères que Scala utilise pour nommer diverses variables, méthodes, fonctions, etc. est appelée un identifiant. C'est-à-dire que tout
endroit où vous pouvez le nommer s'appelle un identifiant.
Règles de nommage :
la déclaration d'identifiant dans Scala est fondamentalement la même que dans Java, mais les détails vont changer. Il y a trois points en résumé :

1. Commencer par une lettre ou un trait de soulignement, suivis de lettres, de chiffres et d'un trait de soulignement Dans des circonstances normales : des lettres et des traits de soulignement S'accompagnent parfois d'un chiffre
2. Commencer par un opérateur et ne contenir que des opérateurs (+ - / # ! etc.)
3. Toute chaîne entourée de backticks ...., même les mots-clés Scala (39)

• paquet, importation, classe, objet, trait, étend, avec, type, pour
• privé, protégé, abstrait, scellé, final, implicite, paresseux, remplacement
• essayer, attraper, enfin, lancer
• si, sinon, correspondance, cas , do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

Pratique :
Exigences : jugez hello, Hello12, 1hello, hb, xh, h_4, ab, Int, , + -/#!, + -/#!1, if, , ifces noms sont légaux.

object Test01 {
 def main(args: Array[String]): Unit = {
 // （1）以字母或者下划线开头，后接字母、数字、下划线
 var hello: String = "" // ok
 var Hello12: String = "" // ok
 var 1hello: String = "" // error 数字不能开头
 var h-b: String = "" // error 不能用-
 var x h: String = "" // error 不能有空格
 var h_4: String = "" // ok
 var _ab: String = "" // ok
 var Int: String = "" // ok 因为在 Scala 中 Int 是预定义的字符,不是关键字，但不推荐
 var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法println(_)
 //（2）以操作符开头，且只包含操作符（+ - * / # !等）
 var +*-/#! : String = "" // ok
 var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符
 //（3）用反引号`....`包括的任意字符串，即使是 Scala 关键字（39 个）也可以
 var if : String = "" // error 不能用关键字
 var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字
 } 
}

sortie de chaîne

Syntaxe de base :

1. chaîne, concaténée par le signe +
2. Utilisation de printf : chaîne, passer la valeur par %.
3. Modèle de chaîne (chaîne d'interpolation) : obtenir la valeur de la variable par $

Essai de code :

package com.doitedu.demo04
object TestString{
 def main(args: Array[String]): Unit = {
 var name: String = "jinlian"
 var age: Int = 18
 
 //（1）字符串，通过+号连接
 println(name + " " + age)
 
 //可以用$来引用变量，大括号{}可以写也可以不写，如果不写，中间要用空格隔开
//最前面小写的s就是固定写法，写了他相当于就是一个模板字符串，咱们可以用$去引用变量了
println(s"${name}今年${age}岁了")
 
 //（2）printf 用法字符串，通过%传值。 他是不换行的，如果需要换行，那么要用\r\n来写在末尾换行
 printf("name=%s age=%d\r\n",name,age)
 
 val price = 119.99
printf("这个商品的价格是%.2f",price)

 //（3）字符串，通过$引用
//多行字符串，在 Scala中，利用三个双引号包围多行字符串就可以实现。
//输入的内容，带有空格、\t 之类，导致每一行的开始位置不能整洁对齐。
//应用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默认
是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。
val sql =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "zhangSan"
    |and age = 18
    |group by name;
    |""".stripMargin
println(sql )
//如果需要对变量进行运算，那么可以加${}
val sql01 =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "$name"
    |and age = ${age+2}
    |group by name;
    |""".stripMargin
 println(sql01 )
 val s2 = s"name=$name"
 println(s2)
 } 
}

printf中格式化输出的模板
 %d 十进制数字
 %s 字符串
 %c 字符
 %e 指数浮点数
 %f 浮点数
 %i 整数（十进制）
 %o 八进制
 %u 无符号十进制
 %x 十六进制

Type de données (emphase)

Types de base Java : char, byte, short, int, long, float, double, boolean
Type de référence Java : (type d'objet)
Classes wrapper de type de base Java : Character, Byte, Short, Integer, Long, Float, Double,
Boolean Java a les types de base et les types de base ne sont pas de vrais objets.Même si les classes wrapper de type de base sont générées ultérieurement, il existe toujours des types de données de base, de sorte que le langage Java n'est pas vraiment orienté objet.
• La plus grande différence entre les types de données dans scala et les types de données dans java est que les types de données dans scala sont tous des objets, c'est-à-dire qu'il n'y a pas de type de données natif dans scala ! • Les types de données dans scala sont divisés en deux types : AnyVal (type valeur) et
AnyRef (type référence), les deux objets appartiennent à Any, et les deux sont des objets
val age : Int = 23
age est une variable de type valeur Int, et une variable de type valeur appartient également à un objet, la variable d'âge est donc un objet et possède de nombreuses méthodes
. Remarque : les types primitifs et les types de référence n'ont pas d'ancêtre commun en Java.

1. Any : la classe parent de tous les types, similaire à Object en java
2. AnyVal : type numérique (type simple) ==-" correspond au type de données de base en java
3. AnyRef : type de données de référence
4. Null : sous-classe de type référence, similaire à null en java == "Écrivez une classe qui encapsule la valeur de null dans ce Null
5. Unité : Correspond à void en Java, indiquant que la méthode n'a pas de valeur de retour, sa valeur : () == "Parce que pour cet objet, la méthode toString est réécrite
6. Nothing : la sous-classe du type, principalement utilisée lorsqu'une fonction n'a pas de valeur de retour claire, généralement utilisée lorsqu'il y a une exception, indiquant qu'il y a une erreur ici

Tableau détaillé des types de données :

Type d'unité, type Null et type Nothing

type de données	décrire
Unité	N'indique aucune valeur, équivalent à void dans d'autres langages. Utilisé comme type de résultat pour les méthodes qui ne renvoient aucun résultat. L'unité n'a qu'une seule valeur d'instance, écrite sous la forme ().
Nul	null , le type Null n'a qu'une seule valeur d'instance null
Rien	Le type Nothing est au bas de la hiérarchie des classes de Scala ; c'est un sous-type de tout autre type. Lorsqu'une fonction, nous sommes sûrs qu'il n'y a pas de valeur de retour normale, nous pouvons utiliser Nothing pour spécifier le type de retour.Cela a l'avantage que nous pouvons affecter la valeur retournée (exception) à d'autres fonctions ou variables (compatibilité)

conversion de type

Lorsqu'un programme Scala effectue une affectation ou une opération, le type avec moins de précision est automatiquement converti en type numérique avec une plus grande précision, qui
est une conversion de type automatique (conversion implicite). Les types de données sont triés par précision (capacité) :

illustrer:

1. Principe de promotion automatique : lorsqu'il existe plusieurs types d'opérations mixtes de données, le système convertit d'abord automatiquement toutes les données dans le type de données avec une grande précision, puis effectue des calculs.
2. Lors de l'affectation d'un type numérique avec une précision élevée à un type numérique avec une faible précision, une erreur sera signalée, sinon une conversion de type automatique sera effectuée. versInt versDouble
3. Il n'y a pas de conversion automatique entre (byte, short) et char.
4. Byte, short et char peuvent être calculés, et ils sont d'abord convertis en type int pendant le calcul.

Cas de test:

object Test {
 def main(args: Array[String]): Unit = {
 //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
 var n = 1 + 2.0
 println(n) // n 就是 Double
 //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
 var n2 : Double= 1.0
 //var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。
 //（3）（byte，short）和 char 之间不会相互自动转换。
 var n4 : Byte = 1
 //var c1 : Char = n4 //错误
 var n5:Int = n4
 //（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int类型。
 var n6 : Byte = 1
 var c2 : Char = 1
 // var n : Short = n6 + c2 //当 n6 + c2 结果类型就是 int
 // var n7 : Short = 10 + 90 //错误
 } 
}

opérateur

opérateur arithmétique

Code d'essai :

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 25;
    var d = 25;
    println("a + b = " + (a + b) );
    println("a - b = " + (a - b) );
    println("a * b = " + (a * b) );
    println("b / a = " + (b / a) );
    println("b % a = " + (b % a) );
    println("c % a = " + (c % a) );
  }
}

opérateur relationnel

Essai de code :

def main(args: Array[String]) {
  var a = 10;
  var b = 20;
  println("a == b = " + (a == b) );
  println("a != b = " + (a != b) );
  println("a > b = " + (a > b) );
  println("a < b = " + (a < b) );
  println("b >= a = " + (b >= a) );
  println("b <= a = " + (b <= a) );
}

Opérateurs logiques

Essai de code :

val a = true
val b = false

println("a && b = " + (a && b))//false

println("a || b = " + (a || b))//true

println("!(a && b) = " + !(a && b))//true

opérateur d'assignation

Remarque : Il n'y a pas de ++ dans scala -- remplacer += -=

Essai de code :

object Test {
 def main(args: Array[String]): Unit = {
 var r1 = 10
 r1 += 1 // 没有++
 r1 -= 2 // 没有--
 }
}

opérateur au niveau du bit

Code d'essai :

object TestPosition {
 def main(args: Array[String]): Unit = {
 // 测试：1000 << 1 =>10000
 var n1 :Int =8
 n1 = n1 << 1
 println(n1)  //16 
 } 
} 

priorité

contrôle de processus

Le contrôle de flux dans Scala est fondamentalement le même que celui de Java

Boucle de données de plage (To)

grammaire de base

for(i <- 1 to 10){
  println(i)
}

（1）i 表示循环的变量，<- 规定 to 
（2）i 将会从 1-3 循环，前后闭合

Exigence : sortie 5 phrases "hello world"

object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 to 5){
 println("hello  world"+i)
 }
 } 
}

Boucle de données de plage (jusqu'à)

Syntaxe de base :

for(i <- 1 until 5) {
    println(i)
}

（1）这种方式和前面的区别在于 i 是从 1 到 5-1 即[0,5)
（2）即使前闭合后开的范围
练习：
需求：用until输出 5 句 "hello  world"
Scala
object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 until 5+1){
 println("hello  world"+i)
 }
 } 
}

boucle de protection

grammaire de base

for(i <- 1 to 3 if i != 2) {
     println(i)
}

// 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。 
// 代码等价：

for (i <- 1 to 3){
    if (i != 2) {
        print(i + " ")
    } 
}    

// 需求：输出 1 到 5 中，不等于 3 的值
object TestFor {
 def main(args: Array[String]): Unit = {
 for (i <- 1 to 5 if i != 3) {
 println(i + "doit")
 }
 } 
} 

Taille de pas de cycle
Syntaxe de base :
Description : par taille de pas

    for (i <- 1 to 10 by 2) {
     println("i=" + i)
    }

// 需求：输出 1 到 10 以内的所有奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}

结果：
i=1
i=3
i=5
i=7
i=9

Variables d'importation :

Syntaxe de base :

for(i <- 1 to 3; j = 4 - i) {
 println("i=" + i + " j=" + j)
}

Explication :
(1) Lorsqu'il existe plusieurs expressions dans une dérivation for, ajoutez ; pour séparer la logique
(2) Il existe un accord non écrit dans la dérivation for : utilisez des parenthèses lorsque la dérivation for ne contient qu'une seule expression , lorsqu'elle en contient plusieurs expressions, généralement une expression par ligne, et des accolades sont utilisées à la place des parenthèses, comme illustré dans l'
exemple suivant :

for {
 i <- 1 to 3
 j = 4 - i
} {
 println("i=" + i + " j=" + j)
} 
// 等价得代码：
Scala
for (i <- 1 to 3) {
 var j = 4 - i
 println("i=" + i + " j=" + j)
}

valeur de retour de la boucle

Syntaxe de base :

val res = for(i <- 1 to 10) yield i
println(res)
// 说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。

// 练习：需求：将原数据中所有值乘以 2，并把数据返回到一个新的集合中。
object TestFor {
 def main(args: Array[String]): Unit = {
     var res = for(i <-1 to 10) yield {
         i * 2
     }
     println(res)
 } 
}

输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

Imprimer dans l'ordre inverse

Remarque : Si vous souhaitez imprimer un ensemble de données dans l'ordre inverse, vous pouvez utiliser l'inverse.
Exigence : Imprimer 10 à 1 dans l'ordre inverse

for(i <- 1 to 10 reverse){
 println(i)
}

rupture de boucle

Explication de base :
la structure de contrôle intégrée de Scala supprime spécialement break and continue pour mieux s'adapter à la programmation fonctionnelle. Il est recommandé d'utiliser le style fonctionnel pour résoudre les fonctions de break and continue au lieu d'un mot-clé. Scala utilise la structure de contrôle cassable pour implémenter les fonctions d'interruption et de poursuite.

Méthode 1 : Sortir de la boucle de manière anormale

object Demo_while {
  def main(args: Array[String]): Unit = {
    try {
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          throw new RuntimeException
        }
      }
    } catch {
      case e: Exception =>
    }
    println("hello")
  }
}

Méthode 2 : Utilisez la fonction fournie avec Scala pour sortir de la boucle

import scala.util.control.Breaks

object Demo_while {
  def main(args: Array[String]): Unit = {
    Breaks.breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          Breaks.break()
        }
      }
    )
    println("正常结束循环")
  }
}

Omettre les pauses

object Demo_while {
  def main(args: Array[String]): Unit = {
    breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          break()
        }
      }
    )
    println("正常结束循环")
  }
}