Annuaire d'articles
Résumé du chapitre
Spark est un moteur de calcul rapide et polyvalent conçu pour le traitement de données à grande échelle. Il est développé et implémenté par le langage Scala. En ce qui concerne la technologie Big Data, il calcule les données elles-mêmes, et Scala possède à la fois des capacités d'ingénierie de projet d'organisation orientée objet et La fonction de calcul des données et l'intégration étroite de Spark et Scala, ce livre utilisera le langage Scala pour développer des programmes Spark, donc bien apprendre Scala nous aidera à mieux comprendre le framework Spark.
1.2 Syntaxe de base de Scala
1.2.1 Déclarer des valeurs et des variables
Scala a deux types de variables, l'une est une variable déclarée avec le mot-clé var et sa valeur est mutable ; l'autre est une variable déclarée avec le mot-clé val, également appelée constante, et sa valeur est immuable.
- Variables déclarées avec le mot clé var
var myVar:String="Hello" - Variables déclarées avec le mot clé val
val age:Int=10
Il y a quelques points à noter :
- Les variables dans Scala doivent être initialisées lorsqu'elles sont déclarées.
- Les variables déclarées à l'aide de var peuvent être à nouveau affectées à la variable après l'initialisation ;
- La valeur d'une constante déclarée avec val ne peut pas être réaffectée.
Lors de la déclaration d'une variable, nous n'avons pas besoin de donner le type de la variable, car au moment de l'initialisation, le mécanisme d'inférence de type de Scala peut la calculer automatiquement en fonction de la valeur initialisée de la variable.
Le code ci-dessus pour déclarer les variables myVar et age est équivalent au code suivant :
var myVar = "Hello" //使用关键字var声明的变量
val age = 10 //使用关键字val声明的变量
Remarque : lorsque vous utilisez le mot-clé var ou val pour déclarer une variable, le nom de la variable qui suit immédiatement ne peut pas être le même que le mot réservé dans Scala, et le nom de la variable peut commencer par une lettre ou un trait de soulignement, et le nom de la variable est strictement en casse. -sensible.
1.2.2 Types de données
- Tout langage de programmation possède des types de données spécifiques, et Scala ne fait pas exception.
- Contrairement à d'autres langages, toutes les valeurs de Scala ont un type, comprenant des nombres et des fonctions.
La hiérarchie des types de données dans Scala
Comme le montre la figure ci-dessus, Any est le supertype de tous les types, également connu sous le nom de type de niveau supérieur, qui contient deux sous-classes directes, comme suit :
-
AnyVal : indique un type de valeur et les données décrites par le type de valeur sont une valeur qui n'est pas vide, pas un objet. Il prédéfinit 9 types, à savoir Double, Float, Long, Int, Short, Byte, Unit, Char et Boolean. Parmi eux, Unit est un type valeur qui ne représente aucune signification et sa fonction est similaire à void en Java.
-
AnyRef : indique le type de référence. On peut considérer que, à l'exception des valeurs, tous les types héritent d'AnyRef.
Au bas de la hiérarchie des types de données Scala, il existe deux autres types de données, à savoir Nothing et Null, comme suit :
- Rien : un sous-type de tous les types, également appelé type inférieur. Son utilisation prévue est de signaler la fin, comme le lancement d'une exception, la sortie d'un programme ou une boucle infinie.
- Null : sous-type de tous les types de référence, son objectif principal est d'interagir avec d'autres langages JVM et il est rarement utilisé dans le code Scala.
1.2.3 Arithmétique et surcharge d'opérateurs
Les opérateurs arithmétiques (+, -, *, /, %) en Scala fonctionnent de la même manière qu'en Java, tout comme les opérateurs de bits (&, |, >>, <<). Il est particulièrement souligné que ces opérateurs dans Scala sont en réalité des méthodes. Par exemple, a+b est en fait un raccourci pour a.+(b).
Remarque : Scala ne fournit pas les opérateurs ++ et –. Si nous voulons obtenir l'effet d'augmentation ou de diminution, nous pouvons utiliser "+=1" ou "-=1" pour y parvenir.
1.2.4 Énoncés de la structure de contrôle
Dans Scala, les instructions de structure de contrôle incluent des instructions de branchement conditionnelles et des instructions de boucle. Parmi eux, l'instruction de branchement conditionnel inclut l'instruction if, l'instruction if...else, l'instruction if...else if...else et l'instruction imbriquée if...else ; l'instruction de boucle inclut l'instruction for, la boucle while et do. .. while boucle.
- instruction de branchement conditionnelle
- si instruction conditionnelle
if (布尔表达式){
语句块
}
- instruction conditionnelle if-else
if (布尔表达式){
语句块
} else{
语句块
}
- instruction if-else-if-else
if (布尔表达式1){
语句块
} else if(布尔表达式2){
语句块
} else if(布尔表达式3){
语句块
} else {
语句块
}
- instruction imbriquée if-else
if (布尔表达式1){
语句块
if(布尔表达式2){
语句块
}
}else if (布尔表达式3){
语句块
else if (布尔表达式4){
语句块
}
}else{
语句块
}
L'exemple de code est le suivant :
2. Instruction de boucle
L'instruction for de Scala et l'instruction de boucle de Java ont une grande différence de syntaxe. Introduisons l'instruction de boucle for de Scala.
- instruction de boucle for
for(变量<-表达式/数组/集合){
循环语句;
}
Ci-dessous, nous effectuons une boucle de 0 à 9 et imprimons la valeur pour la démonstration du fonctionnement à chaque fois que nous effectuons une boucle. Dans la syntaxe Scala, « 0 à 9 » peut être utilisé pour représenter la plage de 0 à 9, et la plage inclut 9. L'exemple de code est le suivant :
-
Ligne de commande Dos
-
Les résultats sous IDEA
sont les suivants :
0 1 2 3 4 5 6 7 8 9
Scala peut filtrer certains éléments en utilisant l'instruction de jugement if dans l'instruction de boucle for, et plusieurs conditions de filtre sont séparées par des points-virgules. Par exemple, pour générer des nombres pairs supérieurs à 5 dans la plage de 0 à 9, l'exemple de code est le suivant :
-
L'instruction de boucle while
L'instruction de boucle while dans Scala est exactement la même que celle de Java et le format de syntaxe est le suivant : -
tandis que l'instruction
while(布尔表达式){
循环语句;
}
Ci-dessous, nous démontrons l’utilisation de while en imprimant les cas impairs.
Supposons qu'il existe une variable x=1, jugez si elle est inférieure à 10, si c'est le cas, imprimez-la, puis effectuez l'opération +2.
L'exemple de code est le suivant :
- déclaration "faire en attendant"
do{
循环语句;
}while(布尔表达式)
La principale différence entre l'instruction de boucle do...while et l'instruction while est que l'instruction de boucle de l'instruction do...while est exécutée au moins une fois. L'exemple de code est le suivant :
1.2.5 Méthodes et fonctions
En Scala, il possède des méthodes et des fonctions tout comme Java. Une méthode Scala fait partie d'une classe, alors qu'une fonction est un objet qui peut être affecté à une variable. En d’autres termes, les fonctions définies dans une classe sont des méthodes.
Dans Scala, les fonctions peuvent être définies à l'aide d'instructions def et d'instructions val, tandis que les méthodes ne peuvent être définies qu'à l'aide d'instructions def. Les méthodes et fonctions de Scala sont expliquées ci-dessous.
- Méthode
Le format de définition d'une méthode Scala est le suivant :
def functionName ([参数列表]):[return type]={
function body
return [expr]
}
Ce qui suit définit une méthode add pour réaliser l'addition et la sommation de deux nombres. L'exemple de code est le suivant :
def add(a:Int,b:Int):Int={
var sum:Int = 0
sum = a + b
return sum
}
Le format d'un appel de méthode Scala est le suivant :
//没有使用实例的对象调用格式
functionName(参数列表)
//方法使用实例的对象来调用，我们可以使用类似Java的格式（“.”号）
[instance.]functionName(参数列表)
Ensuite, dans la classe Test, définissez une méthode addInt pour réaliser l'addition et la sommation de deux entiers. Ici, nous utilisons "nom de classe. nom de méthode (liste de paramètres)" pour appeler, l'exemple de code est le suivant :
scala> :paste # 多行输入模式的命令
// Entering paste mode (ctrl-D to finish)
object Test{
def addInt(a:Int,b:Int):Int={
var sum:Int =0
sum = a + b
return sum
}
}
// Exiting paste mode, now interpreting. # Ctrl+d结束多行输入模式
defined object Test
scala> Test.addInt(4,5) # 方法调用
res0: Int = 9
- Fonctions
Une fonction dans Scala est un objet qui peut être affecté à une variable.
La syntaxe de définition d'une fonction Scala est la suivante :
val functionName ([参数列表]):[return type]={
function body
return [expr]
}
Ensuite, définissez une fonction addInt pour réaliser l'addition et la sommation de deux entiers. L'exemple de code est le suivant :
scala> val addInt =(a:Int,b:Int) => a+b
addInt: (Int, Int) => Int = <function2>
scala> addInt(6,7)
res1: Int = 13
- Conversion d'une méthode en fonction
Le format de conversion d'une méthode en fonction est le suivant :
val f1 = m _
Dans le format ci-dessus, le nom de la méthode m est suivi d'un espace et d'un trait de soulignement pour indiquer au compilateur de convertir la méthode en fonction au lieu d'appeler la méthode. Ensuite, définissez une méthode m pour convertir la méthode m en fonction. L'exemple de code est le suivant :
scala> def m(x:Int,y:Int):Int=x*y # 方法
m: (x: Int, y: Int)Int
scala> val f = m _
f: (Int, Int) => Int = <function2> # 函数
scala> f(2,3)
res2: Int = 6
Remarque : Le type de valeur de retour de la méthode Scala peut être omis et le compilateur peut le déduire automatiquement, mais pour la méthode récursive, le type de retour doit être spécifié.
Réimprimé à partir de : https://blog.csdn.net/u014727709/article/details/132031799
bienvenue pour commencer, bienvenue pour commenter, bienvenue pour corriger