Scala - Kurzanleitung

Scala, kurz für Scalable Language, ist eine hybride funktionale Programmiersprache. Es wurde von Martin Odersky erstellt. Scala integriert nahtlos die Funktionen objektorientierter und funktionaler Sprachen. Scala ist für die Ausführung auf der Java Virtual Machine kompiliert. Viele bestehende Unternehmen, die für geschäftskritische Anwendungen auf Java angewiesen sind, wenden sich an Scala, um ihre Entwicklungsproduktivität, Anwendungsskalierbarkeit und allgemeine Zuverlässigkeit zu steigern.

Hier haben wir einige Punkte vorgestellt, die Scala zur ersten Wahl für Anwendungsentwickler machen.

Scala ist objektorientiert

Scala ist eine reine objektorientierte Sprache in dem Sinne, dass jeder Wert ein Objekt ist. Typen und Verhalten von Objekten werden durch Klassen und Merkmale beschrieben, die in den folgenden Kapiteln erläutert werden.

Der Unterricht wird erweitert um subclassing und eine flexible mixin-based composition Mechanismus als sauberer Ersatz für Mehrfachvererbung.

Scala ist funktionsfähig

Scala ist auch eine funktionale Sprache in dem Sinne, dass jede Funktion ein Wert und jeder Wert ein Objekt ist, so dass letztendlich jede Funktion ein Objekt ist.

Scala bietet eine einfache Syntax zum Definieren anonymous functions, es unterstützt higher-order functionsermöglicht es Funktionen zu sein nestedund unterstützt currying. Diese Konzepte werden in den folgenden Kapiteln erläutert.

Scala ist statisch typisiert

Im Gegensatz zu einigen anderen statisch typisierten Sprachen (C, Pascal, Rust usw.) erwartet Scala nicht, dass Sie redundante Typinformationen bereitstellen. In den meisten Fällen müssen Sie keinen Typ angeben, und Sie müssen ihn auf keinen Fall wiederholen.

Scala läuft auf der JVM

Scala wird in Java-Bytecode kompiliert, der von der Java Virtual Machine (JVM) ausgeführt wird. Dies bedeutet, dass Scala und Java eine gemeinsame Laufzeitplattform haben. Sie können problemlos von Java nach Scala wechseln.

Der Scala-Compiler kompiliert Ihren Scala-Code in Java-Byte-Code, der dann vom 'scala' Befehl. Das 'scala'Befehl ist ähnlich dem java Befehl, indem es Ihren kompilierten Scala-Code ausführt.

Scala kann Java-Code ausführen

Mit Scala können Sie alle Klassen des Java SDK sowie Ihre eigenen benutzerdefinierten Java-Klassen oder Ihre bevorzugten Java Open Source-Projekte verwenden.

Scala kann Concurrent & Synchronize verarbeiten

Mit Scala können Sie allgemeine Programmiermuster effektiv ausdrücken. Es reduziert die Anzahl der Zeilen und hilft dem Programmierer, typsicher zu codieren. Sie können Codes unveränderlich schreiben, wodurch Parallelität und Parallelität (Synchronisieren) einfach angewendet werden können.

Scala gegen Java

Scala verfügt über eine Reihe von Funktionen, die sich vollständig von Java unterscheiden. Einige davon sind -

  • Alle Typen sind Objekte
  • Typinferenz
  • Verschachtelte Funktionen
  • Funktionen sind Objekte
  • Unterstützung für domänenspezifische Sprache (DSL)
  • Traits
  • Closures
  • Parallelitätsunterstützung inspiriert von Erlang

Scala Web Frameworks

Scala wird überall und vor allem in Webanwendungen für Unternehmen eingesetzt. Sie können einige der beliebtesten Scala-Webframeworks überprüfen -

  • Das Lift Framework

  • Das Play-Framework

  • Das Bowler-Framework

Scala kann auf jedem UNIX- oder Windows-basierten System installiert werden. Bevor Sie mit der Installation von Scala auf Ihrem Computer beginnen, muss Java 1.8 oder höher auf Ihrem Computer installiert sein.

Führen Sie die folgenden Schritte aus, um Scala zu installieren.

Schritt 1: Überprüfen Sie Ihre Java-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.

Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.

Plattform Befehl Beispielausgabe
Windows

Öffnen Sie die Befehlskonsole und geben Sie - ein

\>java –version

Java-Version "1.8.0_31"

Java (TM) SE-Laufzeit

Umgebung (Build 1.8.0_31-b31)

Java Hotspot (TM) 64-Bit-Server

VM (Build 25.31-b07, gemischter Modus)

Linux

Öffnen Sie das Befehlsterminal und geben Sie - ein

$java –version

Java-Version "1.8.0_31"

Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.8.10.4.el6_4-x86_64).

Öffnen Sie die JDK 64-Bit-Server-VM (Build 25.31-b07, gemischter Modus).

Wir gehen davon aus, dass auf den Lesern dieses Tutorials Java SDK Version 1.8.0_31 auf ihrem System installiert ist.

Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunter http://www.oracle.com/technetwork/java/javase/downloads/index.html und installieren Sie es.

Schritt 2: Legen Sie Ihre Java-Umgebung fest

Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,

Sr.Nr. Plattform & Beschreibung
1

Windows

Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60

2

Linux

Exportieren Sie JAVA_HOME = / usr / local / java-current

Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.

Sr.Nr. Plattform & Beschreibung
1

Windows

Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen PATH an.

2

Linux

Export PATH = $ PATH: $ JAVA_HOME / bin /

Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.

Schritt 3: Installieren Sie Scala

Sie können Scala von herunterladen http://www.scala-lang.org/downloads. Zum Zeitpunkt des Schreibens dieses Tutorials habe ich 'scala-2.11.5-installer.jar' heruntergeladen. Stellen Sie sicher, dass Sie über Administratorrechte verfügen, um fortzufahren. Führen Sie nun den folgenden Befehl an der Eingabeaufforderung aus:

Plattform Befehl & Ausgabe Beschreibung
Windows

\> java –jar scala-2.11.5-installer.jar \>

Dieser Befehl zeigt einen Installationsassistenten an, der Sie zur Installation von Scala auf Ihrem Windows-Computer führt. Während der Installation wird nach einer Lizenzvereinbarung gefragt. Akzeptieren Sie diese einfach und fragen Sie nach einem Pfad, in dem Scala installiert wird. Ich habe den Standardpfad "C: \ Programme \ Scala" ausgewählt. Sie können einen geeigneten Pfad nach Ihren Wünschen auswählen.

Linux

Command - -

$ java –jar scala-2.9.0.1-installer.jar

Output - -

Willkommen zur Installation von Scala 2.9.0.1!

Die Homepage ist bei - http://Scala-lang.org/

Drücken Sie 1, um fortzufahren, 2, um zu beenden, 3, um erneut anzuzeigen

1 ................................................

[Beginn des Auspackens]

[Verarbeitungspaket: Installation des Softwarepakets (1/1)]

[Auspacken beendet]

[Konsoleninstallation abgeschlossen]

Während der Installation wird eine Lizenzvereinbarung angefordert, um Typ 1 zu akzeptieren, und es wird nach einem Pfad gefragt, in dem Scala installiert wird. Ich habe / usr / local / share eingegeben. Sie können einen geeigneten Pfad auswählen.

Öffnen Sie abschließend eine neue Eingabeaufforderung und geben Sie ein Scala -versionund drücken Sie die Eingabetaste. Sie sollten Folgendes sehen -

Plattform Befehl Ausgabe
Windows

\> Scala-Version

Scala Code Runner Version 2.11.5 - Copyright 2002-2013, LAMP / EPFL

Linux

$ scala -version

Scala Code Runner Version 2.9.0.1 - Copyright 2002-2013, LAMP / EPFL

Wenn Sie ein gutes Verständnis für Java haben, ist es für Sie sehr einfach, Scala zu lernen. Der größte syntaktische Unterschied zwischen Scala und Java besteht darin, dass das ';' Das Zeilenendezeichen ist optional.

Wenn wir ein Scala-Programm betrachten, kann es als eine Sammlung von Objekten definiert werden, die über das Aufrufen der Methoden des jeweils anderen kommunizieren. Lassen Sie uns nun kurz untersuchen, was Klassen-, Objekt-, Methoden- und Instanzvariablen bedeuten.

  • Object- Objekte haben Zustände und Verhaltensweisen. Ein Objekt ist eine Instanz einer Klasse. Beispiel - Ein Hund hat Zustände - Farbe, Name, Rasse sowie Verhalten - wedeln, bellen und essen.

  • Class - Eine Klasse kann als Vorlage / Blaupause definiert werden, die die Verhaltensweisen / Zustände beschreibt, die sich auf die Klasse beziehen.

  • Methods- Eine Methode ist im Grunde ein Verhalten. Eine Klasse kann viele Methoden enthalten. Es ist in Methoden, in denen die Logik geschrieben, Daten manipuliert und alle Aktionen ausgeführt werden.

  • Fields- Jedes Objekt verfügt über einen eindeutigen Satz von Instanzvariablen, die als Felder bezeichnet werden. Der Status eines Objekts wird durch die diesen Feldern zugewiesenen Werte erstellt.

  • Closure - A. closure ist eine Funktion, deren Rückgabewert vom Wert einer oder mehrerer außerhalb dieser Funktion deklarierter Variablen abhängt.

  • Traits- Ein Merkmal kapselt Methoden- und Felddefinitionen, die dann durch Mischen in Klassen wiederverwendet werden können. Merkmale werden verwendet, um Objekttypen zu definieren, indem die Signatur der unterstützten Methoden angegeben wird.

Erstes Scala-Programm

Wir können ein Scala-Programm in zwei Modi ausführen: einer ist interactive mode und ein anderer ist script mode.

Interaktiver Modus

Öffnen Sie die Eingabeaufforderung und öffnen Sie Scala mit dem folgenden Befehl.

\>scala

Wenn Scala in Ihrem System installiert ist, wird die folgende Ausgabe angezeigt:

Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.

Geben Sie den folgenden Text rechts von der Scala-Eingabeaufforderung ein und drücken Sie die Eingabetaste -

scala> println("Hello, Scala!");

Es wird das folgende Ergebnis erzeugt -

Hello, Scala!

Skriptmodus

Verwenden Sie die folgenden Anweisungen, um ein Scala-Programm im Skriptmodus zu schreiben. Öffnen Sie den Editor und fügen Sie den folgenden Code hinzu.

Beispiel

object HelloWorld {
   /* This is my first java program.  
   * This will print 'Hello World' as the output
   */
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

Speichern Sie die Datei als - HelloWorld.scala.

Öffnen Sie das Eingabeaufforderungsfenster und wechseln Sie in das Verzeichnis, in dem die Programmdatei gespeichert ist. Das 'scalacDer Befehl 'wird zum Kompilieren des Scala-Programms verwendet und generiert einige Klassendateien im aktuellen Verzeichnis. Einer von ihnen wird gerufenHelloWorld.class. Dies ist ein Bytecode, der auf Java Virtual Machine (JVM) mit 'ausgeführt wird.scala' Befehl.

Verwenden Sie den folgenden Befehl, um Ihr Scala-Programm zu kompilieren und auszuführen.

\> scalac HelloWorld.scala
\> scala HelloWorld

Ausgabe

Hello, World!

Grundlegende Syntax

Im Folgenden sind die grundlegenden Syntaxen und Codierungskonventionen in der Scala-Programmierung aufgeführt.

  • Case Sensitivity - Scala unterscheidet zwischen Groß- und Kleinschreibung, dh Kennung Hello und hello hätte in Scala eine andere Bedeutung.

  • Class Names- Bei allen Klassennamen sollte der erste Buchstabe in Großbuchstaben geschrieben sein. Wenn mehrere Wörter verwendet werden, um einen Namen für die Klasse zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.

    Example - Klasse MyFirstScalaClass.

  • Method Names- Alle Methodennamen sollten mit einem Kleinbuchstaben beginnen. Wenn mehrere Wörter verwendet werden, um den Namen der Methode zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.

    Example - def myMethodName ()

  • Program File Name- Der Name der Programmdatei sollte genau mit dem Objektnamen übereinstimmen. Wenn Sie die Datei speichern, sollten Sie sie unter dem Objektnamen speichern (bei Scala wird zwischen Groß- und Kleinschreibung unterschieden) und anhängen..scala'bis zum Ende des Namens. (Wenn der Dateiname und der Objektname nicht übereinstimmen, wird Ihr Programm nicht kompiliert.)

    Example- Angenommen, 'HelloWorld' ist der Objektname. Dann sollte die Datei als 'HelloWorld.scala' gespeichert werden.

  • def main(args: Array[String]) - Die Verarbeitung des Scala-Programms beginnt mit der main () -Methode, die in jedem Scala-Programm obligatorisch ist.

Scala-Kennungen

Alle Scala-Komponenten erfordern Namen. Namen, die für Objekte, Klassen, Variablen und Methoden verwendet werden, werden als Bezeichner bezeichnet. Ein Schlüsselwort kann nicht als Bezeichner verwendet werden, und bei Bezeichnern wird zwischen Groß- und Kleinschreibung unterschieden. Scala unterstützt vier Arten von Bezeichnern.

Alphanumerische Bezeichner

Eine alphanumerische Kennung beginnt mit einem Buchstaben oder einem Unterstrich, auf den weitere Buchstaben, Ziffern oder Unterstriche folgen können. Das Zeichen '$' ist ein reserviertes Schlüsselwort in Scala und sollte nicht in Bezeichnern verwendet werden.

Folgende sind legal alphanumeric identifiers - -

age, salary, _value,  __1_value

Folgende sind illegal identifiers - -

$salary, 123abc, -salary

Operator-IDs

Eine Operator-ID besteht aus einem oder mehreren Operatorzeichen. Operatorzeichen sind druckbare ASCII-Zeichen wie +,:,?, ~ Oder #.

Im Folgenden finden Sie rechtliche Betreiberkennungen -

+ ++ ::: <?> :>

Der Scala-Compiler "entwirrt" intern Operator-IDs, um sie in legale Java-IDs mit eingebetteten $ -Zeichen umzuwandeln. Zum Beispiel würde der Bezeichner: -> intern als dargestellt$colon$minus $ größer.

Gemischte Kennungen

Eine gemischte Kennung besteht aus einer alphanumerischen Kennung, gefolgt von einem Unterstrich und einer Operatorkennung.

Es folgen legale gemischte Kennungen -

unary_+,  myvar_=

Hier definiert unary_ + als Methodenname einen unären + Operator und myvar_ = als Methodenname einen Zuweisungsoperator (Operatorüberladung).

Literale Bezeichner

Eine Literal-ID ist eine beliebige Zeichenfolge, die in Back-Ticks (`...`) eingeschlossen ist.

Es folgen rechtliche wörtliche Kennungen -

`x` `<clinit>` `yield`

Scala Schlüsselwörter

Die folgende Liste zeigt die reservierten Wörter in Scala. Diese reservierten Wörter dürfen nicht als Konstante, Variable oder andere Bezeichnernamen verwendet werden.

abstrakt Fall Fang Klasse
def tun sonst erweitert
falsch Finale schließlich zum
für einige wenn implizit importieren
faul Spiel Neu Null
Objekt überschreiben Paket Privat
geschützt Rückkehr versiegelt Super
diese werfen Merkmal Versuchen
wahr Art val Var
während mit Ausbeute  
- - :: = =>
<- <: <% >:
# @

Kommentare in Scala

Scala unterstützt einzeilige und mehrzeilige Kommentare, die Java sehr ähnlich sind. Mehrzeilige Kommentare können verschachtelt sein, müssen jedoch ordnungsgemäß verschachtelt sein. Alle in einem Kommentar verfügbaren Zeichen werden vom Scala-Compiler ignoriert.

object HelloWorld {
   /* This is my first java program.  
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */
   def main(args: Array[String]) {
      // Prints Hello World
      // This is also an example of single line comment.
      println("Hello, world!") 
   }
}

Leerzeilen und Leerzeichen

Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und Scala ignoriert sie vollständig. Token können durch Leerzeichen und / oder Kommentare getrennt werden.

Newline-Zeichen

Scala ist eine zeilenorientierte Sprache, in der Anweisungen durch Semikolons (;) oder Zeilenumbrüche abgeschlossen werden können. Ein Semikolon am Ende einer Anweisung ist normalerweise optional. Sie können eine eingeben, wenn Sie möchten, müssen dies jedoch nicht, wenn die Anweisung von selbst in einer einzelnen Zeile angezeigt wird. Andererseits ist ein Semikolon erforderlich, wenn Sie mehrere Anweisungen in eine einzelne Zeile schreiben. Die folgende Syntax enthält die Verwendung mehrerer Anweisungen.

val s = "hello"; println(s)

Scala-Pakete

Ein Paket ist ein benanntes Codemodul. Das Dienstprogramm Lift lautet beispielsweise net.liftweb.util. Die Paketdeklaration ist die erste Zeile ohne Kommentar in der Quelldatei wie folgt:

package com.liftcode.stuff

Scala-Pakete können importiert werden, damit im aktuellen Kompilierungsbereich auf sie verwiesen werden kann. Die folgende Anweisung importiert den Inhalt des scala.xml-Pakets -

import scala.xml._

Sie können eine einzelne Klasse und ein einzelnes Objekt, z. B. HashMap, aus dem Paket scala.collection.mutable importieren.

import scala.collection.mutable.HashMap

Sie können mehr als eine Klasse oder ein Objekt aus einem einzelnen Paket importieren, z. B. TreeMap und TreeSet aus dem Paket scala.collection.immutable.

import scala.collection.immutable.{TreeMap, TreeSet}

Dynamisch anwenden

Ein Markermerkmal, das dynamische Aufrufe ermöglicht. Instanzen x dieses Merkmals ermöglichen Methodenaufrufe x.meth (args) für beliebige Methodennamen meth und Argumentlistenargumente sowie Feldzugriffe x.field für beliebige Feldnamenfelder. Diese Funktion wird in Scala-2.10 eingeführt.

Wenn ein Aufruf von x nicht nativ unterstützt wird (dh wenn die Typprüfung fehlschlägt), wird er gemäß den folgenden Regeln neu geschrieben:

foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)

Scala hat dieselben Datentypen wie Java, denselben Speicherbedarf und dieselbe Genauigkeit. In der folgenden Tabelle finden Sie Details zu allen in Scala verfügbaren Datentypen.

Sr.Nr. Datentyp & Beschreibung
1

Byte

8-Bit-Wert mit Vorzeichen. Bereich von -128 bis 127

2

Short

16 Bit vorzeichenbehafteter Wert. Bereich -32768 bis 32767

3

Int

32-Bit-Wert mit Vorzeichen. Bereich -2147483648 bis 2147483647

4

Long

64-Bit-Wert mit Vorzeichen. -9223372036854775808 bis 9223372036854775807

5

Float

32-Bit-Float mit einfacher Genauigkeit nach IEEE 754

6

Double

64-Bit-Float mit doppelter Genauigkeit nach IEEE 754

7

Char

16-Bit-Unicode-Zeichen ohne Vorzeichen. Bereich von U + 0000 bis U + FFFF

8

String

Eine Folge von Zeichen

9

Boolean

Entweder das wörtliche wahr oder das wörtliche falsch

10

Unit

Entspricht keinem Wert

11

Null

Null oder leere Referenz

12

Nothing

Der Subtyp jedes anderen Typs; enthält keine Werte

13

Any

Der Supertyp eines beliebigen Typs; Jedes Objekt ist vom Typ Beliebig

14

AnyRef

Der Supertyp eines beliebigen Referenztyps

Alle oben aufgeführten Datentypen sind Objekte. Es gibt keine primitiven Typen wie in Java. Dies bedeutet, dass Sie Methoden auf einem Int, Long usw. aufrufen können.

Scala Basic Literals

Die Regeln, die Scala für Literale verwendet, sind einfach und intuitiv. In diesem Abschnitt werden alle grundlegenden Scala-Literale erläutert.

Integrale Literale

Ganzzahlige Literale sind normalerweise vom Typ Int oder vom Typ Long, wenn ein Suffix L oder l folgt. Hier sind einige ganzzahlige Literale -

0
035
21 
0xFFFFFFFF 
0777L

Gleitkomma-Literal

Gleitkomma-Literale sind vom Typ Float, gefolgt von einem Gleitkomma-Suffix F oder f, andernfalls vom Typ Double. Hier sind einige Gleitkomma-Literale -

0.0 
1e30f 
3.14159f 
1.0e100
.1

Boolesche Literale

Die booleschen Literale true und false sind Mitglieder vom Typ Boolean.

Symbol Literale

Ein Symbolliteral 'x ist eine Abkürzung für den Ausdruck scala.Symbol("x"). Symbol ist eine Fallklasse, die wie folgt definiert ist.

package scala
final case class Symbol private (name: String) {
   override def toString: String = "'" + name
}

Zeichenliterale

Ein Zeichenliteral ist ein einzelnes Zeichen in Anführungszeichen. Das Zeichen ist entweder ein druckbares Unicode-Zeichen oder wird durch eine Escape-Sequenz beschrieben. Hier sind einige Zeichenliterale -

'a' 
'\u0041'
'\n'
'\t'

String-Literale

Ein String-Literal ist eine Folge von Zeichen in doppelten Anführungszeichen. Die Zeichen sind entweder druckbare Unicode-Zeichen oder werden durch Escape-Sequenzen beschrieben. Hier sind einige String-Literale -

"Hello,\nWorld!"
"This string contains a \" character."

Mehrzeilige Saiten

Ein mehrzeiliges Zeichenfolgenliteral ist eine Folge von Zeichen, die in dreifachen Anführungszeichen "" ... "" "eingeschlossen sind. Die Zeichenfolge ist willkürlich, außer dass sie nur ganz am Ende drei oder mehr aufeinanderfolgende Anführungszeichen enthalten darf.

Zeichen müssen nicht unbedingt druckbar sein. Zeilenumbrüche oder andere Steuerzeichen sind ebenfalls zulässig. Hier ist ein mehrzeiliges String-Literal -

"""the present string
spans three
lines."""

Nullwerte

Der Nullwert ist vom Typ scala.Nullund ist somit mit jedem Referenztyp kompatibel. Es bezeichnet einen Referenzwert, der sich auf ein spezielles "Null" -Objekt bezieht.

Escape-Sequenzen

Die folgenden Escape-Sequenzen werden in Zeichen- und Zeichenfolgenliteralen erkannt.

Escape-Sequenzen Unicode Beschreibung
\ b \ u0008 Rücktaste BS
\ t \ u0009 horizontale Lasche HT
\ n \ u000c Formfeed FF
\ f \ u000c Formfeed FF
\ r \ u000d Wagenrücklauf CR
"" \ u0022 doppeltes Anführungszeichen "
\ ' \ u0027 einfaches Anführungszeichen.
\\ \ u005c Backslash \

Ein Zeichen mit einem Unicode zwischen 0 und 255 kann auch durch ein Oktal-Escape dargestellt werden, dh durch einen Backslash '\', gefolgt von einer Folge von bis zu drei Oktalzeichen. Das folgende Beispiel zeigt einige Escape-Zeichen -

Beispiel

object Test {
   def main(args: Array[String]) {
      println("Hello\tWorld\n\n" );
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Ausgabe

Hello   World

Variablen sind nichts anderes als reservierte Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren.

Basierend auf dem Datentyp einer Variablen weist der Compiler Speicher zu und entscheidet, was im reservierten Speicher gespeichert werden kann. Durch Zuweisen verschiedener Datentypen zu Variablen können Sie daher Ganzzahlen, Dezimalstellen oder Zeichen in diesen Variablen speichern.

Variable Aussage

Scala hat eine andere Syntax zum Deklarieren von Variablen. Sie können als Wert definiert werden, dh als Konstante oder als Variable. Hier wird myVar mit dem Schlüsselwort var deklariert. Es ist eine Variable, die den Wert ändern kann, und dies wird aufgerufenmutable variable. Im Folgenden finden Sie die Syntax zum Definieren einer Variablen mithilfe vonvar Schlüsselwort -

Syntax

var myVar : String = "Foo"

Hier wird myVal mit dem Schlüsselwort val deklariert. Dies bedeutet, dass es sich um eine Variable handelt, die nicht geändert werden kann, und die aufgerufen wirdimmutable variable. Im Folgenden finden Sie die Syntax zum Definieren einer Variablen mit dem Schlüsselwort val:

Syntax

val myVal : String = "Foo"

Variable Datentypen

Der Typ einer Variablen wird nach dem Variablennamen und vor dem Gleichheitszeichen angegeben. Sie können jeden Typ von Scala-Variablen definieren, indem Sie den Datentyp wie folgt angeben:

Syntax

val or val VariableName : DataType = [Initial Value]

Wenn Sie einer Variablen keinen Anfangswert zuweisen, gilt dieser wie folgt:

Syntax

var myVar :Int;
val myVal :String;

Variable Typinferenz

Wenn Sie einer Variablen einen Anfangswert zuweisen, kann der Scala-Compiler den Typ der Variablen anhand des ihr zugewiesenen Werts ermitteln. Dies wird als Inferenz vom Variablentyp bezeichnet. Daher können Sie diese Variablendeklarationen folgendermaßen schreiben:

Syntax

var myVar = 10;
val myVal = "Hello, Scala!";

Hier ist myVar standardmäßig vom Typ Int und myVal wird zur Variablen vom Typ String.

Mehrere Aufgaben

Scala unterstützt mehrere Aufgaben. Wenn ein Codeblock oder eine Methode ein Tupel zurückgibt (Tuple- Enthält eine Sammlung von Objekten unterschiedlichen Typs.) Das Tupel kann einer Val-Variablen zugewiesen werden. [Note - Wir werden Tupel in den folgenden Kapiteln studieren.]

Syntax

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

Und die Typinferenz macht es richtig -

Syntax

val (myVar1, myVar2) = Pair(40, "Foo")

Beispielprogramm

Das folgende Beispielprogramm erläutert den Prozess der Variablendeklaration in Scala. Dieses Programm deklariert vier Variablen - zwei Variablen werden mit Typdeklaration definiert und die restlichen zwei sind ohne Typdeklaration.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var myVar :Int = 10;
      val myVal :String = "Hello Scala with datatype declaration.";
      var myVar1 = 20;
      val myVal1 = "Hello Scala new without datatype declaration.";
      
      println(myVar); println(myVal); println(myVar1); 
      println(myVal1);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.

Variabler Umfang

Variablen in Scala können je nach Verwendungsort drei verschiedene Bereiche haben. Sie können als Felder, als Methodenparameter und als lokale Variablen existieren. Nachfolgend finden Sie die Details zu den einzelnen Bereichstypen.

Felder

Felder sind Variablen, die zu einem Objekt gehören. Auf die Felder kann von jeder Methode im Objekt aus zugegriffen werden. Auf Felder kann auch außerhalb des Objekts zugegriffen werden, je nachdem, mit welchen Zugriffsmodifikatoren das Feld deklariert ist. Objektfelder können sowohl veränderbare als auch unveränderliche Typen sein und mit beiden definiert werdenvar oder val.

Methodenparameter

Methodenparameter sind Variablen, mit denen der Wert innerhalb einer Methode übergeben wird, wenn die Methode aufgerufen wird. Auf Methodenparameter kann nur innerhalb der Methode zugegriffen werden. Auf die übergebenen Objekte kann jedoch auch von außen zugegriffen werden, wenn Sie von außerhalb der Methode auf das Objekt verweisen. Methodenparameter sind immer unveränderlich, die durch definiert sindval Stichwort.

Lokale Variablen

Lokale Variablen sind Variablen, die innerhalb einer Methode deklariert sind. Auf lokale Variablen kann nur innerhalb der Methode zugegriffen werden. Die von Ihnen erstellten Objekte können jedoch der Methode entkommen, wenn Sie sie von der Methode zurückgeben. Lokale Variablen können sowohl veränderbare als auch unveränderliche Typen sein und mit beiden definiert werdenvar oder val.

In diesem Kapitel erfahren Sie, wie Sie Klassen und Objekte in der Scala-Programmierung verwenden. Eine Klasse ist eine Blaupause für Objekte. Sobald Sie eine Klasse definiert haben, können Sie mit dem Schlüsselwort Objekte aus dem Klassenplan erstellennew. Über das Objekt können Sie alle Funktionen der definierten Klasse nutzen.

Das folgende Diagramm zeigt die Klasse und das Objekt anhand eines Beispiels für einen Klassenschüler, das die Elementvariablen (Name und Rollennummer) und die Elementmethoden (setName () und setRollNo ()) enthält. Schließlich sind alle Mitglieder der Klasse. Klasse ist eine Blaupause und Objekte sind hier echt. In der folgenden Abbildung ist Student eine Klasse und Harini, John und Maria sind die Objekte der Student-Klasse. Diese haben Namen und Rollennummer.

Grundklasse

Es folgt eine einfache Syntax zum Definieren einer Basisklasse in Scala. Diese Klasse definiert zwei Variablenx und y und eine Methode: move, die keinen Wert zurückgibt. Klassenvariablen werden aufgerufen, Felder der Klasse und Methoden werden Klassenmethoden genannt.

Der Klassenname fungiert als Klassenkonstruktor, der eine Reihe von Parametern annehmen kann. Der obige Code definiert zwei Konstruktorargumente:xc und yc;; Sie sind beide im ganzen Körper der Klasse sichtbar.

Syntax

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

Wie bereits in diesem Kapitel erwähnt, können Sie Objekte mit einem Schlüsselwort erstellen new und dann können Sie auf Klassenfelder und Methoden zugreifen, wie unten im Beispiel gezeigt -

Beispiel

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 20
Point y location : 30

Eine Klasse erweitern

Sie können eine Scala-Basisklasse erweitern und eine geerbte Klasse auf dieselbe Weise wie in Java entwerfen (verwenden) extends Schlüsselwort), aber es gibt zwei Einschränkungen: Das Überschreiben von Methoden erfordert die override Schlüsselwort und nur die primaryDer Konstruktor kann Parameter an den Basiskonstruktor übergeben. Lassen Sie uns unsere obige Klasse erweitern und eine weitere Klassenmethode hinzufügen.

Beispiel

Nehmen wir ein Beispiel für zwei Klassen. Point-Klasse (wie oben) und Location-Klasse ist eine geerbte Klasse mit dem Schlüsselwort extens. So ein 'extendsDie Klausel 'hat zwei Auswirkungen: Sie bewirkt, dass die Location-Klasse alle nicht privaten Mitglieder von der Point-Klasse erbt, und der Typ Location wird zu einem Subtyp des Typs Point- Klasse. Hier heißt also die Point-Klassesuperclassund die Klasse Location wird aufgerufensubclass. Das Erweitern einer Klasse und das Erben aller Funktionen einer übergeordneten Klasse wird aufgerufeninheritance Scala erlaubt jedoch die Vererbung nur von einer Klasse.

Note - Methoden move () Methode in Punktklasse und move() method in Location class Überschreiben Sie nicht die entsprechenden Definitionen von move, da es sich um unterschiedliche Definitionen handelt (z. B. verwenden die ersteren zwei Argumente, während die letzteren drei Argumente verwenden).

Versuchen Sie das folgende Beispielprogramm, um die Vererbung zu implementieren.

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 20
Point y location : 30
Point z location : 20

Implizite Klassen

Implizite Klassen ermöglichen implizite Konversationen mit dem primären Konstruktor der Klasse, wenn sich die Klasse im Gültigkeitsbereich befindet. Implizite Klasse ist eine Klasse, die mit dem Schlüsselwort 'implizit' gekennzeichnet ist. Diese Funktion wird in Scala 2.10 eingeführt.

Syntax- Das Folgende ist die Syntax für implizite Klassen. Hier befindet sich die implizite Klasse immer im Objektbereich, in dem alle Methodendefinitionen zulässig sind, da die implizite Klasse keine Klasse der obersten Ebene sein kann.

Syntax

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

Beispiel

Nehmen wir ein Beispiel für eine implizite Klasse mit dem Namen IntTimesmit der Methode times (). Dies bedeutet, dass times () eine Schleifentransaktion enthält, die die angegebene Anweisung so oft ausführt, wie wir sie angeben. Nehmen wir an, die angegebene Anweisung lautet "4 mal println (" Hallo ")", was bedeutet, dass die println ("" Hallo ") - Anweisung 4 mal ausgeführt wird.

Das folgende ist das Programm für das gegebene Beispiel. In diesem Beispiel werden zwei Objektklassen verwendet (Ausführen und Demo), sodass diese beiden Klassen wie folgt in verschiedenen Dateien mit ihren jeweiligen Namen gespeichert werden müssen.

Run.scala - Speichern Sie das folgende Programm in Run.scala.

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala - Speichern Sie das folgende Programm in Demo.scala.

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

Die folgenden Befehle werden zum Kompilieren und Ausführen dieser beiden Programme verwendet.

Befehl

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

Ausgabe

Hello
Hello
Hello
Hello

Note - -

  • Implizite Klassen müssen in einer anderen Klasse / einem anderen Objekt / einer anderen Eigenschaft definiert werden (nicht in der obersten Ebene).

  • Implizite Klassen dürfen in ihrem Konstruktor nur ein nicht implizites Argument verwenden.

  • Implizite Klassen dürfen keine Methoden, Elemente oder Objekte im Gültigkeitsbereich sein, die denselben Namen wie die implizite Klasse haben.

Singleton-Objekte

Scala ist objektorientierter als Java, da wir in Scala keine statischen Mitglieder haben können. Stattdessen hat Scalasingleton objects. Ein Singleton ist eine Klasse, die nur eine Instanz haben kann, dh Object. Sie erstellen Singleton mit dem Schlüsselwortobjectanstelle des Klassenschlüsselworts. Da Sie ein Singleton-Objekt nicht instanziieren können, können Sie keine Parameter an den primären Konstruktor übergeben. Sie haben bereits alle Beispiele mit Singleton-Objekten gesehen, bei denen Sie die Hauptmethode von Scala aufgerufen haben.

Es folgt dasselbe Beispielprogramm zum Implementieren von Singleton.

Beispiel

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 10
Point y location : 20

Dieses Kapitel führt Sie durch die Scala-Zugriffsmodifikatoren. Mitglieder von Paketen, Klassen oder Objekten können mit den Zugriffsmodifikatoren privat und geschützt gekennzeichnet werden. Wenn wir keines dieser beiden Schlüsselwörter verwenden, wird der Zugriff als öffentlich angenommen. Diese Modifikatoren beschränken den Zugriff auf die Mitglieder auf bestimmte Codebereiche. Um einen Zugriffsmodifikator zu verwenden, fügen Sie sein Schlüsselwort in die Definition der Mitglieder eines Pakets, einer Klasse oder eines Objekts ein, wie im folgenden Abschnitt gezeigt wird.

Private Mitglieder

Ein privates Mitglied ist nur innerhalb der Klasse oder des Objekts sichtbar, das die Elementdefinition enthält.

Es folgt das Beispielcode-Snippet zur Erläuterung des privaten Mitglieds -

Beispiel

class Outer {
   class Inner {
      private def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // Error: f is not accessible
}

In Scala der Zugang (neues Inneres). f () ist illegal, da f in Inner als privat deklariert ist und der Zugriff nicht innerhalb der Klasse Inner erfolgt. Im Gegensatz dazu ist der erste Zugriff auf f in der Klasse Innermost in Ordnung, da dieser Zugriff im Hauptteil der Klasse Inner enthalten ist. Java würde beide Zugriffe zulassen, da eine äußere Klasse auf private Mitglieder ihrer inneren Klassen zugreifen kann.

Geschützte Mitglieder

Auf ein geschütztes Mitglied kann nur von Unterklassen der Klasse zugegriffen werden, in der das Mitglied definiert ist.

Im Folgenden finden Sie das Beispielcode-Snippet zur Erläuterung des geschützten Mitglieds:

Beispiel

package p {
   class Super {
      protected def f() { println("f") }
   }
   
   class Sub extends Super {
      f()
   }
   
   class Other {
      (new Super).f() // Error: f is not accessible
   }
}

Der Zugriff auf f in der Klasse Sub ist in Ordnung, da f in der Klasse 'Super' als geschützt deklariert ist und die Klasse 'Sub' eine Unterklasse von Super ist. Im Gegensatz dazu ist der Zugriff auf f in der Klasse 'Other' nicht zulässig, da die Klasse 'Other' nicht von der Klasse 'Super' erbt. In Java wäre der letztere Zugriff weiterhin zulässig, da sich die Klasse 'Other' im selben Paket befindet wie die Klasse 'Sub'.

Öffentliche Mitglieder

Im Gegensatz zu privaten und geschützten Mitgliedern ist es nicht erforderlich, ein öffentliches Schlüsselwort für öffentliche Mitglieder anzugeben. Es gibt keinen expliziten Modifikator für öffentliche Mitglieder. Auf solche Mitglieder kann von überall aus zugegriffen werden.

Das folgende Beispiel-Code-Snippet erklärt das öffentliche Mitglied:

Beispiel

class Outer {
   class Inner {
      def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // OK because now f() is public
}

Schutzumfang

Zugriffsmodifikatoren in Scala können durch Qualifikationsmerkmale erweitert werden. Ein Modifikator der Form privat [X] oder geschützt [X] bedeutet, dass der Zugriff "bis" X privat oder geschützt ist, wobei X ein umschließendes Paket, eine Klasse oder ein Singleton-Objekt bezeichnet.

Betrachten Sie das folgende Beispiel -

Beispiel

package society {
   package professional {
      class Executive {
         private[professional] var workDetails = null
         private[society] var friends = null
         private[this] var secrets = null

         def help(another : Executive) {
            println(another.workDetails)
            println(another.secrets) //ERROR
         }
      }
   }
}

Note - die folgenden Punkte aus dem obigen Beispiel -

  • Variable workDetails sind für jede Klasse innerhalb des beiliegenden Pakets professional zugänglich.

  • Variable Freunde sind für jede Klasse innerhalb der einschließenden Paketgesellschaft zugänglich.

  • Auf Variablengeheimnisse kann nur für das implizite Objekt innerhalb der Instanzmethoden zugegriffen werden (this).

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Scala ist reich an integrierten Operatoren und bietet die folgenden Arten von Operatoren:

  • Rechenzeichen
  • Vergleichsoperatoren
  • Logische Operatoren
  • Bitweise Operatoren
  • Zuweisungsoperatoren

In diesem Kapitel werden die arithmetischen, relationalen, logischen, bitweisen, Zuweisungs- und anderen Operatoren nacheinander untersucht.

Rechenzeichen

Die folgenden arithmetischen Operatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -

Beispiele anzeigen

Operator Beschreibung Beispiel
+ Fügt zwei Operanden hinzu A + B ergibt 30
- - Subtrahiert den zweiten Operanden vom ersten A - B ergibt -10
* * Multipliziert beide Operanden A * B ergibt 200
/. Teilt den Zähler durch den De-Zähler B / A ergibt 2
%. Der Moduloperator findet den Rest nach Division einer Zahl durch eine andere B% A ergibt 0

Vergleichsoperatoren

Die folgenden Vergleichsoperatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -

Beispiele anzeigen

Operator Beschreibung Beispiel
== Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. (A == B) ist nicht wahr.
! = Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. (A! = B) ist wahr.
> Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (A> B) ist nicht wahr.
< Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (A <B) ist wahr.
> = Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (A> = B) ist nicht wahr.
<= Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (A <= B) ist wahr.

Logische Operatoren

Die folgenden logischen Operatoren werden von der Scala-Sprache unterstützt. Angenommen, Variable A hält 1 und Variable B hält 0, dann -

Beispiele anzeigen

Operator Beschreibung Beispiel
&& Es heißt logischer UND-Operator. Wenn beide Operanden nicht Null sind, wird die Bedingung wahr. (A && B) ist falsch.
|| Es heißt logischer ODER-Operator. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr. (A || B) ist wahr.
! Es heißt Logical NOT Operator. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false. ! (A && B) ist wahr.

Bitweise Operatoren

Der bitweise Operator bearbeitet Bits und führt eine bitweise Operation durch. Die Wahrheitstabellen für &, | und ^ lauten wie folgt:

p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

Angenommen, A = 60; und B = 13; jetzt im Binärformat werden sie wie folgt sein -

A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

Die von der Scala-Sprache unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Angenommen, Variable A hält 60 und Variable B hält 13, dann -

Beispiele anzeigen

Operator Beschreibung Beispiel
& Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. (A & B) ergibt 12, was 0000 1100 ist
| Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. (A | B) ergibt 61, was 0011 1101 ist
^ Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. (A ^ B) ergibt 49, was 0011 0001 ist
~ Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits. (~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist.
<< Binärer Linksschaltoperator. Die Bitpositionen des Werts der linken Operanden werden um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. Ein << 2 ergibt 240, was 1111 0000 ist
>> Binärer Rechtsschieber. Die Bitpositionen des linken Operandenwerts werden um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. Eine >> 2 ergibt 15, was 1111 ist
>>> Verschieben Sie den Nullfüllungsoperator nach rechts. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben, und verschobene Werte werden mit Nullen gefüllt. Eine >>> 2 ergibt 15, was 0000 1111 ist

Zuweisungsoperatoren

Es gibt folgende Zuweisungsoperatoren, die von der Scala-Sprache unterstützt werden:

Beispiele anzeigen

Operator Beschreibung Beispiel
= Einfacher Zuweisungsoperator, Weist Werte von Operanden auf der rechten Seite dem Operanden auf der linken Seite zu C = A + B weist C den Wert von A + B zu
+ = UND-Zuweisungsoperator hinzufügen. Er fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu C + = A entspricht C = C + A.
- = Subtrahieren UND Zuweisungsoperator, subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu C - = A entspricht C = C - A.
* = Multiplizieren Sie den UND-Zuweisungsoperator. Er multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu C * = A entspricht C = C * A.
/ = UND-Zuweisungsoperator teilen. Er teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu C / = A entspricht C = C / A.
% = Modul- UND Zuweisungsoperator. Der Modul wird mit zwei Operanden verwendet und das Ergebnis dem linken Operanden zugewiesen C% = A entspricht C = C% A.
<< = Linksverschiebung UND Zuweisungsoperator C << = 2 ist dasselbe wie C = C << 2
>> = Rechtsverschiebung UND Zuweisungsoperator C >> = 2 ist dasselbe wie C = C >> 2
& = Bitweiser UND-Zuweisungsoperator C & = 2 ist dasselbe wie C = C & 2
^= bitwise exclusive OR and assignment operator C ^= 2 is same as C = C ^ 2
|= bitwise inclusive OR and assignment operator C |= 2 is same as C = C | 2

Vorrang der Betreiber in Scala

Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator -

Zum Beispiel ist x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.

Schauen Sie sich die folgende Tabelle an. Operatoren mit der höchsten Priorität werden oben in der Tabelle und Operatoren mit der niedrigsten Priorität unten angezeigt. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.

Kategorie Operator Assoziativität
Postfix () [] Links nach rechts
Einstellig ! ~ Rechts nach links
Multiplikativ * /% Links nach rechts
Zusatzstoff + - Links nach rechts
Verschiebung >> >>> << Links nach rechts
Relational >> = << = Links nach rechts
Gleichberechtigung ==! = Links nach rechts
Bitweises UND & Links nach rechts
Bitweises XOR ^ Links nach rechts
Bitweises ODER | Links nach rechts
Logisches UND && Links nach rechts
Logisches ODER || Links nach rechts
Zuordnung = + = - = * = / =% = >> = << = & = ^ = | = Rechts nach links
Komma , Links nach rechts

Dieses Kapitel führt Sie durch die bedingten Konstruktionsanweisungen in der Scala-Programmierung. Es folgt die allgemeine Form einer typischen IF ... ELSE-Struktur für die Entscheidungsfindung in den meisten Programmiersprachen.

Flussdiagramm

Das Folgende ist ein Flussdiagramm für die bedingte Anweisung.

if-Anweisung

Die 'if'-Anweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.

Syntax

Die Syntax einer if-Anweisung lautet wie folgt.

if(Boolean_expression) {
   // Statements will execute if the Boolean expression is true
}

Wenn der Boolesche Ausdruck true ergibt, wird der Codeblock im if-Ausdruck ausgeführt. Wenn nicht, wird der erste Codesatz nach dem Ende des 'if'-Ausdrucks (nach der schließenden geschweiften Klammer) ausgeführt.

Versuchen Sie das folgende Beispielprogramm, um bedingte Ausdrücke (wenn Ausdruck) in der Scala-Programmiersprache zu verstehen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var x = 10;

      if( x < 20 ){
         println("This is if statement");
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

This is if statement

If-else-Anweisung

Auf eine 'if'-Anweisung kann eine optionale else- Anweisung folgen , die ausgeführt wird, wenn der Boolesche Ausdruck false ist.

Syntax

Die Syntax eines if ... else lautet -

if(Boolean_expression){
   //Executes when the Boolean expression is true
} else{
   //Executes when the Boolean expression is false
}

Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (if-else-Anweisung) in der Scala-Programmiersprache zu verstehen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x < 20 ){
         println("This is if statement");
      } else {
         println("This is else statement");
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

This is else statement

If-else-if-else-Anweisung

Auf eine 'if'-Anweisung kann eine optionale' else if ... else' -Anweisung folgen , die sehr nützlich ist, um verschiedene Bedingungen mit einer einzelnen if ... else if-Anweisung zu testen.

Bei der Verwendung von if-, else if, else-Anweisungen sind nur wenige Punkte zu beachten.

  • Ein 'wenn' kann null oder eins haben und es muss nach jedem anderen wenn kommen.

  • Ein 'Wenn' kann null bis viele andere Wenn haben und sie müssen vor dem Anderen stehen.

  • Sobald ein anderer erfolgreich ist, wird keiner der verbleibenden anderen, wenn oder sonst, getestet.

Syntax

Das Folgende ist die Syntax eines 'if ... else if ... else' wie folgt:

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
   //Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
   //Executes when the Boolean expression 3 is true
} else {
   //Executes when the none of the above condition is true.
}

Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (if-else-if-else-Anweisung) in der Programmiersprache Scala zu verstehen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("Value of X is 10");
      } else if( x == 20 ){
         println("Value of X is 20");
      } else if( x == 30 ){
         println("Value of X is 30");
      } else{
         println("This is else statement");
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Value of X is 30

Verschachtelte if-else-Anweisung

Es ist immer legal zu nisten if-else Anweisungen, was bedeutet, dass Sie eine verwenden können if oder else-if Aussage in einem anderen if oder else-if Erklärung.

Syntax

Die Syntax für ein verschachteltes if-else lautet wie folgt:

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
   
   if(Boolean_expression 2){
      //Executes when the Boolean expression 2 is true
   }
}

Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (verschachtelte if-Anweisung) in der Programmiersprache Scala zu verstehen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var x = 30;
      var y = 10;
      
      if( x == 30 ){
         if( y == 10 ){
            println("X = 30 and Y = 10");
         }
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

X = 30 and Y = 10

Dieses Kapitel führt Sie durch die Regelungsstrukturen in Scala-Programmiersprachen.

Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:

Flussdiagramm

Die Programmiersprache Scala bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen. Klicken Sie auf die folgenden Links in der Tabelle, um deren Details zu überprüfen.

Sr.Nr. Schleifentyp & Beschreibung
1

while loop

Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.

2

do-while loop

Wie eine while-Anweisung, nur dass sie die Bedingung am Ende des Schleifenkörpers testet.

3

for loop

Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet.

Schleifensteuerungsanweisungen

Schleifensteueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört. Als solches unterstützt Scala nichtbreak oder continueAnweisung wie Java, aber ab Scala Version 2.8 gibt es eine Möglichkeit, die Schleifen zu brechen. Klicken Sie auf die folgenden Links, um die Details zu überprüfen.

Sr.Nr. Steueranweisung & Beschreibung
1

break statement

Beendet die loop Anweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife.

Die Endlosschleife

Eine Schleife wird zu einer Endlosschleife, wenn eine Bedingung niemals falsch wird. Wenn Sie Scala verwenden, wird diewhile Schleife ist der beste Weg, um eine Endlosschleife zu implementieren.

Das folgende Programm implementiert eine Endlosschleife.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var a = 10;
      
      // An infinite loop.
      while( true ){
         println( "Value of a: " + a );
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Wenn Sie den obigen Code ausführen, wird er in einer Endlosschleife ausgeführt, die Sie durch Drücken der Tasten Strg + C beenden können.

Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….

Eine Funktion ist eine Gruppe von Anweisungen, die eine Aufgabe ausführen. Sie können Ihren Code in separate Funktionen aufteilen. Wie Sie Ihren Code auf verschiedene Funktionen aufteilen, liegt bei Ihnen. Logischerweise erfolgt die Aufteilung normalerweise so, dass jede Funktion eine bestimmte Aufgabe ausführt.

Scala hat sowohl Funktionen als auch Methoden und wir verwenden die Begriffe Methode und Funktion mit einem kleinen Unterschied austauschbar. Eine Scala-Methode ist Teil einer Klasse, die einen Namen, eine Signatur, optional einige Anmerkungen und einen Bytecode enthält, wobei eine Funktion in Scala ein vollständiges Objekt ist, das einer Variablen zugewiesen werden kann. Mit anderen Worten, eine Funktion, die als Mitglied eines Objekts definiert ist, wird als Methode bezeichnet.

Eine Funktionsdefinition kann an einer beliebigen Stelle in einer Quelldatei angezeigt werden, und Scala ermöglicht verschachtelte Funktionsdefinitionen, dh Funktionsdefinitionen in anderen Funktionsdefinitionen. Der wichtigste zu beachtende Punkt ist, dass der Name der Scala-Funktion Zeichen wie +, ++, ~, &, -, -, \, /,: usw. enthalten kann.

Funktionserklärungen

Eine Scala-Funktionsdeklaration hat die folgende Form:

def functionName ([list of parameters]) : [return type]

Methoden werden implizit als abstrakt deklariert, wenn Sie das Gleichheitszeichen und den Methodenkörper nicht verwenden.

Funktionsdefinitionen

Eine Scala-Funktionsdefinition hat die folgende Form:

Syntax

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

Hier, return type kann ein beliebiger gültiger Scala-Datentyp sein und list of parameterswird eine Liste von Variablen sein, die durch Komma getrennt sind, und eine Liste von Parametern und Rückgabetypen sind optional. Sehr ähnlich zu Java, areturnDie Anweisung kann zusammen mit einem Ausdruck verwendet werden, falls die Funktion einen Wert zurückgibt. Es folgt die Funktion, die zwei Ganzzahlen addiert und deren Summe zurückgibt -

Syntax

object add {
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

Eine Funktion, die nichts zurückgibt, kann a zurückgeben Unit das ist gleichbedeutend mit voidin Java und zeigt an, dass die Funktion nichts zurückgibt. Die Funktionen, die in Scala nichts zurückgeben, werden Prozeduren genannt.

Syntax

Hier ist die Syntax -

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

Funktionen aufrufen

Scala bietet eine Reihe syntaktischer Variationen zum Aufrufen von Methoden. Das Folgende ist die Standardmethode zum Aufrufen einer Methode:

functionName( list of parameters )

Wenn eine Funktion mit einer Instanz des Objekts aufgerufen wird, verwenden wir die Java-ähnliche Punktnotation wie folgt:

[instance.]functionName( list of parameters )

Versuchen Sie das folgende Beispielprogramm, um dieselbe Funktion zu definieren und dann aufzurufen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " + addInt(5,7) );
   }
   
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Returned Value : 12

Scala-Funktionen sind das Herzstück der Scala-Programmierung. Deshalb wird Scala als funktionale Programmiersprache angenommen. Im Folgenden finden Sie einige wichtige Konzepte für Scala-Funktionen, die von einem Scala-Programmierer verstanden werden sollten.

Funktionen Call-by-Name Funktionen mit benannten Argumenten
Funktion mit variablen Argumenten Rekursionsfunktionen
Standardparameterwerte Funktionen höherer Ordnung
Verschachtelte Funktionen Anonyme Funktionen
Teilweise angewandte Funktionen Currying-Funktionen

EIN closure ist eine Funktion, deren Rückgabewert vom Wert einer oder mehrerer außerhalb dieser Funktion deklarierter Variablen abhängt.

Der folgende Code mit anonymer Funktion.

val multiplier = (i:Int) => i * 10

Hier ist die einzige im Funktionskörper verwendete Variable i * 10 i, die als Parameter für die Funktion definiert ist. Versuchen Sie den folgenden Code -

val multiplier = (i:Int) => i * factor

Es gibt zwei freie Variablen im Multiplikator: i und factor. Einer von ihnen, i, ist ein formaler Parameter für die Funktion. Daher wird es bei jedem Aufruf des Multiplikators an einen neuen Wert gebunden. Jedoch,factorist kein formaler Parameter, was ist das dann? Fügen wir noch eine Codezeile hinzu.

var factor = 3
val multiplier = (i:Int) => i * factor

Jetzt factorhat einen Verweis auf eine Variable außerhalb der Funktion, jedoch im umschließenden Bereich. Die Funktionsreferenzenfactorund liest jedes Mal seinen aktuellen Wert. Wenn eine Funktion keine externen Referenzen hat, wird sie trivial über sich selbst geschlossen. Es ist kein externer Kontext erforderlich.

Versuchen Sie das folgende Beispielprogramm.

Beispiel

object Demo {
   def main(args: Array[String]) {
      println( "multiplier(1) value = " +  multiplier(1) )
      println( "multiplier(2) value = " +  multiplier(2) )
   }
   var factor = 3
   val multiplier = (i:Int) => i * factor
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

multiplier(1) value = 3
multiplier(2) value = 6

Dieses Kapitel führt Sie durch die Scala-Saiten. In Scala wie in Java ist eine Zeichenfolge ein unveränderliches Objekt, dh ein Objekt, das nicht geändert werden kann. Andererseits werden Objekte, die wie Arrays geändert werden können, als veränderbare Objekte bezeichnet. Strings sind sehr nützliche Objekte. Im Rest dieses Abschnitts stellen wir wichtige Methoden von vorjava.lang.String Klasse.

String erstellen

Der folgende Code kann verwendet werden, um einen String zu erstellen -

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

Immer wenn der Compiler auf ein Zeichenfolgenliteral im Code stößt, erstellt er ein Zeichenfolgenobjekt mit dem Wert "Hallo Welt!". Das Schlüsselwort String kann auch in einer alternativen Deklaration angegeben werden, wie oben gezeigt.

Versuchen Sie das folgende Beispielprogramm.

Beispiel

object Demo {
   val greeting: String = "Hello, world!"

   def main(args: Array[String]) {
      println( greeting )
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Hello, world!

Wie bereits erwähnt, ist die String-Klasse unveränderlich. Einmal erstelltes String-Objekt kann nicht geändert werden. Wenn viele Änderungen an Zeichenfolgen vorgenommen werden müssen, verwenden Sie die in Scala! Verfügbare String Builder-Klasse.

String-Länge

Methoden zum Abrufen von Informationen zu einem Objekt werden als Zugriffsmethoden bezeichnet. Eine Zugriffsmethode, die mit Zeichenfolgen verwendet werden kann, ist die length () -Methode, die die Anzahl der im Zeichenfolgenobjekt enthaltenen Zeichen zurückgibt.

Verwenden Sie das folgende Codesegment, um die Länge einer Zeichenfolge zu ermitteln:

Beispiel

object Demo {
   def main(args: Array[String]) {
      var palindrome = "Dot saw I was Tod";
      var len = palindrome.length();
      
      println( "String Length is : " + len );
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

String Length is : 17

Verketten von Strings

Die String-Klasse enthält eine Methode zum Verketten von zwei Strings -

string1.concat(string2);

Dies gibt eine neue Zeichenfolge zurück, die Zeichenfolge1 ist, und am Ende wird Zeichenfolge2 hinzugefügt. Sie können die concat () -Methode auch mit String-Literalen verwenden, wie in -

"My name is ".concat("Zara");

Zeichenfolgen werden häufiger mit dem Operator + verkettet, wie in -

"Hello," + " world" + "!"

Was zu -

"Hello, world!"

Die folgenden Codezeilen zum Ermitteln der Zeichenfolgenlänge.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var str1 = "Dot saw I was ";
      var str2 =  "Tod";
      
      println("Dot " + str1 + str2);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Dot Dot saw I was Tod

Formatzeichenfolgen erstellen

Sie haben die Methoden printf () und format (), um Ausgaben mit formatierten Zahlen zu drucken. Die String-Klasse verfügt über eine äquivalente Klassenmethode, format (), die ein String-Objekt anstelle eines PrintStream-Objekts zurückgibt.

Probieren Sie das folgende Beispielprogramm aus, das die Methode printf () verwendet:

Beispiel

object Demo {
   def main(args: Array[String]) {
      var floatVar = 12.456
      var intVar = 2000
      var stringVar = "Hello, Scala!"
      
      var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
      
      println(fs)
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

The value of the float variable is 12.456000, 
while the value of the integer variable is 2000, 
and the string is Hello, Scala!()

String-Interpolation

Die String-Interpolation ist die neue Methode zum Erstellen von Strings in der Programmiersprache Scala. Diese Funktion unterstützt die Versionen von Scala-2.10 und höher. String-Interpolation: Der Mechanismus zum direkten Einbetten von Variablenreferenzen in das Prozess-String-Literal.

Es gibt drei Arten (Interpolatoren) von Implementierungen in der String-Interpolation.

Der 's' String Interpolator

Das Literal 's' ermöglicht die Verwendung von Variablen direkt bei der Verarbeitung einer Zeichenfolge, wenn Sie 's' voranstellen. Jede String-Variable mit in einem Bereich, mit der in einem String verwendet werden kann. Das Folgende sind die verschiedenen Verwendungen des String-Interpolators von 's'.

Das folgende Beispielcode-Snippet für die Implementierung des Interpolators 's' beim Anhängen der String-Variablen ($ name) an einen normalen String (Hello) in der println-Anweisung.

val name = “James”
println(s “Hello, $name”) //output: Hello, James

String-Interpolater können auch beliebige Ausdrücke verarbeiten. Das folgende Codefragment zum Verarbeiten eines Strings (1 + 1) mit einem beliebigen Ausdruck ($ {1 + 1}) unter Verwendung des String-Interpolators 's'. Jeder beliebige Ausdruck kann in '$ {}' eingebettet werden.

println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2

Probieren Sie das folgende Beispielprogramm zur Implementierung des Interpolators aus.

Beispiel

object Demo {
   def main(args: Array[String]) {
      val name = "James"
      
      println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}")
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Hello, James
1 + 1 = 2

Der 'f'-Interpolator

Der Literal-Interpolator 'f' ermöglicht das Erstellen eines formatierten Strings, ähnlich wie printf in der Sprache C. Bei Verwendung des Interpolators 'f' sollte auf alle Variablenreferenzen das von folgenprintf Stilformatbezeichner wie% d,% i,% f usw.

Nehmen wir ein Beispiel für das Anhängen eines Gleitkommawerts (Höhe = 1,9d) und einer Zeichenfolgenvariablen (Name = „James“) an eine normale Zeichenfolge. Der folgende Codeausschnitt zur Implementierung des Interpolators 'f'. Hier$name%s to print (String variable) James and $Höhe% 2.2f zum Drucken (Gleitkommawert) 1,90.

val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall

Es ist typsicher (dh) die Variablenreferenz und der folgende Formatbezeichner sollten übereinstimmen, andernfalls wird ein Fehler angezeigt. Der Interpolator 'f' verwendet die in Java verfügbaren Dienstprogramme zum Formatieren von Zeichenfolgen (Formatspezifizierer). Standardmäßig gibt es nach der Variablenreferenz kein% -Zeichen. Es wird als% s (String) angenommen.

'roher' Interpolator

Der 'rohe' Interpolator ähnelt dem 's'-Interpolator, außer dass er kein Entweichen von Literalen innerhalb einer Zeichenfolge ausführt. Die folgenden Codeausschnitte in einer Tabelle unterscheiden sich in der Verwendung von 's'- und' raw'-Interpolatoren. Bei Ausgaben von 's' Nutzung '\ n' Effekten als neue Zeile und bei Ausgabe von 'roher' Nutzung wirkt sich '\ n' nicht aus. Es wird die gesamte Zeichenfolge mit Escape-Buchstaben gedruckt.

Verwendung des Interpolators 'rohe' Interpolatorverwendung

Program - -

object Demo {
   def main(args: Array[String]) {
      println(s"Result = \n a \n b")
   }
}

Program - -

object Demo {
   def main(args: Array[String]) {
      println(raw"Result = \n a \n b")
   }
}

Output - -

Result =
a
b

Output - -

Result = \n a \n b

String-Methoden

Es folgt die Liste der von definierten Methoden java.lang.String Klasse und kann direkt in Ihren Scala-Programmen verwendet werden -

Sr.Nr. Methoden mit Beschreibung
1

char charAt(int index)

Gibt das Zeichen am angegebenen Index zurück.

2

int compareTo(Object o)

Vergleicht diesen String mit einem anderen Objekt.

3

int compareTo(String anotherString)

Vergleicht zwei Zeichenfolgen lexikografisch.

4

int compareToIgnoreCase(String str)

Vergleicht zwei Zeichenfolgen lexikografisch und ignoriert dabei Fallunterschiede.

5

String concat(String str)

Verkettet die angegebene Zeichenfolge mit dem Ende dieser Zeichenfolge.

6

boolean contentEquals(StringBuffer sb)

Gibt nur dann true zurück, wenn dieser String dieselbe Zeichenfolge wie der angegebene StringBuffer darstellt.

7

static String copyValueOf(char[] data)

Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt.

8

static String copyValueOf(char[] data, int offset, int count)

Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt.

9

boolean endsWith(String suffix)

Testet, ob diese Zeichenfolge mit dem angegebenen Suffix endet.

10

boolean equals(Object anObject)

Vergleicht diese Zeichenfolge mit dem angegebenen Objekt.

11

boolean equalsIgnoreCase(String anotherString)

Vergleicht diesen String mit einem anderen String und ignoriert dabei die Überlegungen zur Groß- und Kleinschreibung.

12

byte getBytes()

Codiert diesen String mit dem Standardzeichensatz der Plattform in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array.

13

byte[] getBytes(String charsetName)

Codiert diesen String mithilfe des benannten Zeichensatzes in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array.

14

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Kopiert Zeichen aus dieser Zeichenfolge in das Zielzeichenarray.

15

int hashCode()

Gibt einen Hash-Code für diese Zeichenfolge zurück.

16

int indexOf(int ch)

Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück.

17

int indexOf(int ch, int fromIndex)

Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück und startet die Suche am angegebenen Index.

18

int indexOf(String str)

Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück.

19

int indexOf(String str, int fromIndex)

Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück, beginnend mit dem angegebenen Index.

20

String intern()

Gibt eine kanonische Darstellung für das Zeichenfolgenobjekt zurück.

21

int lastIndexOf(int ch)

Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück.

22

int lastIndexOf(int ch, int fromIndex)

Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück und sucht ab dem angegebenen Index rückwärts.

23

int lastIndexOf(String str)

Gibt den Index innerhalb dieser Zeichenfolge des Auftretens der angegebenen Teilzeichenfolge ganz rechts zurück.

24

int lastIndexOf(String str, int fromIndex)

Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens der angegebenen Teilzeichenfolge zurück und sucht ab dem angegebenen Index rückwärts.

25

int length()

Gibt die Länge dieser Zeichenfolge zurück.

26

boolean matches(String regex)

Gibt an, ob diese Zeichenfolge mit dem angegebenen regulären Ausdruck übereinstimmt.

27

boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len)

Testet, ob zwei Zeichenfolgenbereiche gleich sind.

28

boolean regionMatches(int toffset, String other, int offset, int len)

Testet, ob zwei Zeichenfolgenbereiche gleich sind.

29

String replace(char oldChar, char newChar)

Gibt eine neue Zeichenfolge zurück, die sich aus dem Ersetzen aller Vorkommen von oldChar in dieser Zeichenfolge durch newChar ergibt.

30

String replaceAll(String regex, String replacement

Ersetzt jeden Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz.

31

String replaceFirst(String regex, String replacement)

Ersetzt den ersten Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz.

32

String[] split(String regex)

Teilt diese Zeichenfolge um Übereinstimmungen des angegebenen regulären Ausdrucks.

33

String[] split(String regex, int limit)

Teilt diese Zeichenfolge um Übereinstimmungen des angegebenen regulären Ausdrucks.

34

boolean startsWith(String prefix)

Testet, ob diese Zeichenfolge mit dem angegebenen Präfix beginnt.

35

boolean startsWith(String prefix, int toffset)

Testet, ob diese Zeichenfolge mit dem angegebenen Präfix beginnt, das mit einem angegebenen Index beginnt.

36

CharSequence subSequence(int beginIndex, int endIndex)

Gibt eine neue Zeichenfolge zurück, die eine Teilsequenz dieser Folge ist.

37

String substring(int beginIndex)

Gibt eine neue Zeichenfolge zurück, die eine Teilzeichenfolge dieser Zeichenfolge ist.

38

String substring(int beginIndex, int endIndex)

Gibt eine neue Zeichenfolge zurück, die eine Teilzeichenfolge dieser Zeichenfolge ist.

39

char[] toCharArray()

Konvertiert diese Zeichenfolge in ein neues Zeichenarray.

40

String toLowerCase()

Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des Standardgebietsschemas in Kleinbuchstaben.

41

String toLowerCase(Locale locale)

Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des angegebenen Gebietsschemas in Kleinbuchstaben.

42

String toString()

Dieses Objekt (das bereits eine Zeichenfolge ist!) Wird selbst zurückgegeben.

43

String toUpperCase()

Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des Standardgebietsschemas in Großbuchstaben.

44

String toUpperCase(Locale locale)

Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des angegebenen Gebietsschemas in Großbuchstaben.

45

String trim()

Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachfolgende Leerzeichen weggelassen werden.

46

static String valueOf(primitive data type x)

Gibt die Zeichenfolgendarstellung des übergebenen Datentyparguments zurück.

Scala bietet eine Datenstruktur, die array, in dem eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe gespeichert wird. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Oft ist es jedoch sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.

Anstatt einzelne Variablen wie Nummer 0, Nummer 1, ... und Nummer 99 zu deklarieren, deklarieren Sie eine Array-Variable wie Zahlen und verwenden Zahlen [0], Zahlen [1] und ..., Zahlen [99] zur Darstellung einzelne Variablen. In diesem Lernprogramm wird erläutert, wie Sie Array-Variablen deklarieren, Arrays erstellen und Arrays mithilfe indizierter Variablen verarbeiten. Der Index des ersten Elements eines Arrays ist die Zahl Null und der Index des letzten Elements ist die Gesamtzahl der Elemente minus Eins.

Array-Variablen deklarieren

Um ein Array in einem Programm zu verwenden, müssen Sie eine Variable deklarieren, die auf das Array verweist, und Sie müssen den Array-Typ angeben, auf den die Variable verweisen kann.

Das Folgende ist die Syntax zum Deklarieren einer Array-Variablen.

Syntax

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

Hier wird z als Array von Strings deklariert, die bis zu drei Elemente enthalten können. Werte können einzelnen Elementen zugewiesen werden oder Zugriff auf einzelne Elemente erhalten. Dies kann mithilfe von Befehlen wie den folgenden erfolgen:

Befehl

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Hier zeigt das letzte Beispiel, dass der Index im Allgemeinen ein beliebiger Ausdruck sein kann, der eine ganze Zahl ergibt. Es gibt noch eine Möglichkeit, ein Array zu definieren:

var z = Array("Zara", "Nuha", "Ayan")

Das folgende Bild zeigt ein Array myList. Hier,myList enthält zehn Doppelwerte und die Indizes liegen zwischen 0 und 9.

Arrays verarbeiten

Bei der Verarbeitung von Array-Elementen verwenden wir häufig Schleifensteuerungsstrukturen, da alle Elemente in einem Array vom gleichen Typ sind und die Größe des Arrays bekannt ist.

Im Folgenden finden Sie ein Beispielprogramm zum Erstellen, Initialisieren und Verarbeiten von Arrays.

Beispiel

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      
      println("Max is " + max);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala unterstützt verschiedene Array-Operationen nicht direkt und bietet verschiedene Methoden zum Verarbeiten von Arrays in jeder Dimension. Wenn Sie die verschiedenen Methoden verwenden möchten, ist der Import erforderlichArray._ Paket.

Mehrdimensionale Arrays

Es gibt viele Situationen, in denen Sie mehrdimensionale Arrays definieren und verwenden müssten (dh Arrays, deren Elemente Arrays sind). Beispielsweise sind Matrizen und Tabellen Beispiele für Strukturen, die als zweidimensionale Arrays realisiert werden können.

Das folgende Beispiel zeigt die Definition eines zweidimensionalen Arrays:

var myMatrix = ofDim[Int](3,3)

Dies ist ein Array mit drei Elementen, von denen jedes ein Array von Ganzzahlen mit drei Elementen ist.

Versuchen Sie das folgende Beispielprogramm, um ein mehrdimensionales Array zu verarbeiten:

Beispiel

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

0 1 2
0 1 2
0 1 2

Arrays verketten

Versuchen Sie das folgende Beispiel, in dem die concat () -Methode verwendet wird, um zwei Arrays zu verketten. Sie können mehr als ein Array als Argumente an die Methode concat () übergeben.

Beispiel

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Array mit Bereich erstellen

Verwendung der range () -Methode zum Generieren eines Arrays, das eine Folge ansteigender Ganzzahlen in einem bestimmten Bereich enthält. Sie können das letzte Argument als Schritt verwenden, um die Sequenz zu erstellen. Wenn Sie kein letztes Argument verwenden, wird der Schritt als 1 angenommen.

Let us take an example of creating an array of range (10, 20, 2): It means creating an array with elements between 10 and 20 and range difference 2. Elements in the array are 10, 12, 14, 16, and 18.

Another example: range (10, 20). Here range difference is not given so by default it assumes 1 element. It create an array with the elements in between 10 and 20 with range difference 1. Elements in the array are 10, 11, 12, 13, …, and 19.

The following example program shows how to create an array with ranges.

Example

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Scala Array Methods

Following are the important methods, which you can use while playing with array. As shown above, you would have to import Array._ package before using any of the mentioned methods. For a complete list of methods available, please check official documentation of Scala.

Sr.No Methods with Description
1

def apply( x: T, xs: T* ): Array[T]

Creates an array of T objects, where T can be Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean.

2

def concat[T]( xss: Array[T]* ): Array[T]

Concatenates all arrays into a single array.

3

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit

Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length).

4

def empty[T]: Array[T]

Returns an array of length 0

5

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]

Returns an array containing repeated applications of a function to a start value.

6

def fill[T]( n: Int )(elem: => T): Array[T]

Returns an array that contains the results of some element computation a number of times.

7

def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]

Returns a two-dimensional array that contains the results of some element computation a number of times.

8

def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T]

Returns an array containing repeated applications of a function to a start value.

9

def ofDim[T]( n1: Int ): Array[T]

Creates array with given dimensions.

10

def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]

Creates a 2-dimensional array

11

def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]

Creates a 3-dimensional array

12

def range( start: Int, end: Int, step: Int ): Array[Int]

Returns an array containing equally spaced values in some integer interval.

13

def range( start: Int, end: Int ): Array[Int]

Returns an array containing a sequence of increasing integers in a range.

14

def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]

Returns an array containing values of a given function over a range of integer values starting from 0.

15

def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]

Returns a two-dimensional array containing values of a given function over ranges of integer values starting from 0.

Scala has a rich set of collection library. Collections are containers of things. Those containers can be sequenced, linear sets of items like List, Tuple, Option, Map, etc. The collections may have an arbitrary number of elements or be bounded to zero or one element (e.g., Option).

Collections may be strict or lazy. Lazy collections have elements that may not consume memory until they are accessed, like Ranges. Additionally, collections may be mutable (the contents of the reference can change) or immutable (the thing that a reference refers to is never changed). Note that immutable collections may contain mutable items.

For some problems, mutable collections work better, and for others, immutable collections work better. When in doubt, it is better to start with an immutable collection and change it later if you need mutable ones.

This chapter throws light on the most commonly used collection types and most frequently used operations over those collections.

Sr.No Collections with Description
1

Scala Lists

Scala's List[T] is a linked list of type T.

2

Scala Sets

A set is a collection of pairwise different elements of the same type.

3

Scala Maps

A Map is a collection of key/value pairs. Any value can be retrieved based on its key.

4

Scala Tuples

Unlike an array or list, a tuple can hold objects with different types.

5

Scala Options

Option[T] provides a container for zero or one element of a given type.

6

Scala Iterators

An iterator is not a collection, but rather a way to access the elements of a collection one by one.

A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.

Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.

A trait definition looks just like a class definition except that it uses the keyword trait. The following is the basic example syntax of trait.

Syntax

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

This trait consists of two methods isEqual and isNotEqual. Here, we have not given any implementation for isEqual where as another method has its implementation. Child classes extending a trait can give implementation for the un-implemented methods. So a trait is very similar to what we have abstract classes in Java.

Let us assume an example of trait Equal contain two methods isEqual() and isNotEqual(). The trait Equal contain one implemented method that is isEqual() so when user defined class Point extends the trait Equal, implementation to isEqual() method in Point class should be provided.

Here it is required to know two important method of Scala, which are used in the following example.

  • obj.isInstanceOf [Point] To check Type of obj and Point are same are not.

  • obj.asInstanceOf [Point] means exact casting by taking the object obj type and returns the same obj as Point type.

Try the following example program to implement traits.

Example

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
   var x: Int = xc
   var y: Int = yc
   
   def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}

object Demo {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

true
false
true

Value classes and Universal Traits

Value classes are new mechanism in Scala to avoid allocating runtime objects. It contains a primary constructor with exactly one val parameter. It contains only methods (def) not allowed var, val, nested classes, traits, or objects. Value class cannot be extended by another class. This can be possible by extending your value class with AnyVal. The typesafety of custom datatypes without the runtime overhead.

Let us take an examples of value classes Weight, Height, Email, Age, etc. For all these examples it is not required to allocate memory in the application.

A value class not allowed to extend traits. To permit value classes to extend traits, universal traits are introduced which extends for Any.

Example

trait Printable extends Any {
   def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable

object Demo {
   def main(args: Array[String]) {
      val w = new Wrapper(3)
      w.print() // actually requires instantiating a Wrapper instance
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

It will give you the hash code of Wrapper class.

Wrapper@13

When to Use Traits?

There is no firm rule, but here are few guidelines to consider −

  • If the behavior will not be reused, then make it a concrete class. It is not reusable behavior after all.

  • If it might be reused in multiple, unrelated classes, make it a trait. Only traits can be mixed into different parts of the class hierarchy.

  • If you want to inherit from it in Java code, use an abstract class.

  • If you plan to distribute it in compiled form, and you expect outside groups to write classes inheriting from it, you might lean towards using an abstract class.

  • If efficiency is very important, lean towards using a class.

Der Mustervergleich ist nach Funktionswerten und Schließungen das am zweithäufigsten verwendete Merkmal von Scala. Scala bietet eine hervorragende Unterstützung für den Mustervergleich bei der Verarbeitung der Nachrichten.

Eine Musterübereinstimmung enthält eine Folge von Alternativen, die jeweils mit dem Schlüsselwort beginnen case. Jede Alternative beinhaltet apattern und eine oder mehrere expressions, die ausgewertet wird, wenn das Muster übereinstimmt. Ein Pfeilsymbol => trennt das Muster von den Ausdrücken.

Probieren Sie das folgende Beispielprogramm aus, das zeigt, wie Sie mit einem ganzzahligen Wert übereinstimmen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      println(matchTest(3))
   }
   
   def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

many

Der Block mit den case-Anweisungen definiert eine Funktion, die Ganzzahlen Zeichenfolgen zuordnet. Das Schlüsselwort match bietet eine bequeme Möglichkeit, eine Funktion (wie die obige Mustervergleichsfunktion) auf ein Objekt anzuwenden.

Probieren Sie das folgende Beispielprogramm aus, das einen Wert mit Mustern verschiedener Typen vergleicht.

Beispiel

object Demo {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
   }
   
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

2
many
one

Abgleich mit Fallklassen

Das case classessind spezielle Klassen, die beim Mustervergleich mit Fallausdrücken verwendet werden. Syntaktisch sind dies Standardklassen mit einem speziellen Modifikator:case.

Versuchen Sie Folgendes: Es handelt sich um ein einfaches Beispiel für den Mustervergleich mit der Fallklasse.

Beispiel

object Demo {
   def main(args: Array[String]) {
      val alice = new Person("Alice", 25)
      val bob = new Person("Bob", 32)
      val charlie = new Person("Charlie", 32)
   
      for (person <- List(alice, bob, charlie)) {
         person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) => println(
               "Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   case class Person(name: String, age: Int)
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

Durch Hinzufügen des case-Schlüsselworts fügt der Compiler automatisch eine Reihe nützlicher Funktionen hinzu. Das Schlüsselwort schlägt eine Zuordnung zu Fallausdrücken beim Mustervergleich vor.

Zunächst konvertiert der Compiler die Konstruktorargumente automatisch in unveränderliche Felder (vals). Das Schlüsselwort val ist optional. Wenn Sie veränderbare Felder möchten, verwenden Sie das Schlüsselwort var. Unsere Konstruktorargumentlisten sind jetzt kürzer.

Zweitens implementiert der Compiler automatisch equals, hashCode, und toStringMethoden für die Klasse, die die als Konstruktorargumente angegebenen Felder verwenden. Wir brauchen also keine eigenen toString () -Methoden mehr.

Schließlich auch der Körper von Person Klasse wird leer, weil es keine Methoden gibt, die wir definieren müssen!

In diesem Kapitel wird erläutert, wie Scala reguläre Ausdrücke unterstützt Regex Klasse im Paket scala.util.matching verfügbar.

Versuchen Sie das folgende Beispielprogramm, in dem wir versuchen, das Wort herauszufinden Scala aus einer Aussage.

Beispiel

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = "Scala".r
      val str = "Scala is Scalable and cool"
      
      println(pattern findFirstIn str)
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Some(Scala)

Wir erstellen einen String und rufen den auf r( )Methode darauf. Scala konvertiert den String implizit in einen RichString und ruft diese Methode auf, um eine Instanz von Regex abzurufen. Um eine erste Übereinstimmung des regulären Ausdrucks zu finden, rufen Sie einfach die auffindFirstIn()Methode. Wenn wir nicht nur das erste Vorkommen finden möchten, sondern alle Vorkommen des übereinstimmenden Wortes finden möchten, können wir das verwendenfindAllIn( ) Methode und falls in der Zielzeichenfolge mehrere Scala-Wörter verfügbar sind, wird eine Sammlung aller übereinstimmenden Wörter zurückgegeben.

Sie können die Methode mkString () verwenden, um die resultierende Liste zu verketten, und Sie können eine Pipe (|) verwenden, um kleine und große Groß- und Kleinschreibung von Scala zu durchsuchen, und Sie können verwenden Regex Konstruktor statt oder r() Methode zum Erstellen eines Musters.

Versuchen Sie das folgende Beispielprogramm.

Beispiel

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("(S|s)cala")
      val str = "Scala is scalable and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Scala,scala

Wenn Sie passenden Text ersetzen möchten, können wir verwenden replaceFirstIn( ) das erste Spiel zu ersetzen oder replaceAllIn( ) alle Vorkommen zu ersetzen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      val pattern = "(S|s)cala".r
      val str = "Scala is scalable and cool"
      
      println(pattern replaceFirstIn(str, "Java"))
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Java is scalable and cool

Reguläre Ausdrücke bilden

Scala erbt seine Syntax für reguläre Ausdrücke von Java, das wiederum die meisten Funktionen von Perl erbt. Hier sind nur einige Beispiele, die als Auffrischung ausreichen sollten -

In der folgenden Tabelle sind alle in Java verfügbaren Metazeichen-Syntax für reguläre Ausdrücke aufgeführt.

Unterausdruck Streichhölzer
^ Entspricht dem Zeilenanfang.
$ Entspricht dem Zeilenende.
. Entspricht einem einzelnen Zeichen außer Zeilenumbruch. Mit der Option m kann auch der Zeilenumbruch abgeglichen werden.
[...] Entspricht einem einzelnen Zeichen in Klammern.
[^ ...] Entspricht einem einzelnen Zeichen, das nicht in Klammern steht
\\EIN Anfang der gesamten Saite
\\ z Ende der gesamten Zeichenfolge
\\ Z. Ende der gesamten Zeichenfolge mit Ausnahme des zulässigen Abschlussabschlusses.
Re* Entspricht 0 oder mehr Vorkommen des vorhergehenden Ausdrucks.
re + Entspricht 1 oder mehr der vorherigen Sache
Re? Entspricht 0 oder 1 Vorkommen des vorhergehenden Ausdrucks.
re {n} Entspricht genau n Vorkommen des vorhergehenden Ausdrucks.
re {n,} Entspricht n oder mehr Vorkommen des vorhergehenden Ausdrucks.
re {n, m} Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks.
a | b Entspricht entweder a oder b.
(Re) Gruppiert reguläre Ausdrücke und merkt sich übereinstimmenden Text.
(?: re) Gruppiert reguläre Ausdrücke, ohne sich an übereinstimmenden Text zu erinnern.
(?> re) Entspricht einem unabhängigen Muster ohne Rückverfolgung.
\\ w Entspricht Wortzeichen.
\\ W. Entspricht Nichtwortzeichen.
\\ s Entspricht dem Leerzeichen. Entspricht [\ t \ n \ r \ f].
\\ S. Entspricht Nicht-Leerzeichen.
\\ d Entspricht den Ziffern. Entspricht [0-9].
\\ D. Entspricht nicht-stelligen.
\\EIN Entspricht dem Stringanfang.
\\ Z. Entspricht dem Ende der Zeichenfolge. Wenn eine neue Zeile vorhanden ist, stimmt sie kurz vor der neuen Zeile überein.
\\ z Entspricht dem Ende der Zeichenfolge.
\\G Spielpunkt, an dem das letzte Spiel beendet wurde.
\\ n Rückverweis auf Erfassungsgruppennummer "n"
\\ b Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht der Rücktaste (0x08) in Klammern.
\\ B. Entspricht Nichtwortgrenzen.
\\ n, \\ t usw. Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw.
\\ Q. Escape (Zitat) alle Zeichen bis zu \\ E.
\\ E. Beendet das mit \\ Q begonnene Zitat

Beispiele für reguläre Ausdrücke

Beispiel Beschreibung
. Entspricht einem beliebigen Zeichen außer Newline
[Rr] uby Match "Ruby" oder "Ruby"
reibe [ihr] Match "Rubin" oder "Rube"
[aeiou] Passen Sie einen beliebigen Kleinbuchstaben an
[0-9] Entspricht einer beliebigen Ziffer. das gleiche wie [0123456789]
[az] Passen Sie einen beliebigen ASCII-Kleinbuchstaben an
[AZ] Passen Sie einen beliebigen ASCII-Großbuchstaben an
[a-zA-Z0-9] Passen Sie zu einem der oben genannten Punkte
[^ aeiou] Passen Sie etwas anderes als einen Kleinbuchstaben an
[^ 0-9] Ordnen Sie etwas anderes als eine Ziffer zu
\\ d Entspricht einer Ziffer: [0-9]
\\ D. Entspricht einer nichtstelligen Zahl: [^ 0-9]
\\ s Entspricht einem Leerzeichen: [\ t \ r \ n \ f]
\\ S. Nicht-Leerzeichen abgleichen: [^ \ t \ r \ n \ f]
\\ w Entspricht einem einzelnen Wortzeichen: [A-Za-z0-9_]
\\ W. Entspricht einem Nichtwortzeichen: [^ A-Za-z0-9_]
Rubin? Match "rub" oder "ruby": das y ist optional
Rubin* Match "rub" plus 0 oder mehr ys
Rubin + Match "rub" plus 1 oder mehr ys
\\ d {3} Passen Sie genau 3 Ziffern an
\\ d {3,} Entspricht 3 oder mehr Ziffern
\\ d {3,5} Passen Sie 3, 4 oder 5 Ziffern an
\\ D \\ d + Keine Gruppe: + wiederholt \\ d
(\\ D \\ d) + / Gruppiert: + wiederholt \\ D \ d Paar
([Rr] uby (,)?) + Match "Ruby", "Ruby, Ruby, Ruby" usw.

Note- dass jeder Backslash zweimal in der obigen Zeichenfolge erscheint. Dies liegt daran, dass in Java und Scala ein einzelner Backslash ein Escape-Zeichen in einem Zeichenfolgenliteral ist und kein reguläres Zeichen, das in der Zeichenfolge angezeigt wird. Anstelle von '\' müssen Sie also '\\' schreiben, um einen einzelnen Backslash in der Zeichenfolge zu erhalten.

Versuchen Sie das folgende Beispielprogramm.

Beispiel

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("abl[ae]\\d+")
      val str = "ablaw is able1 and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

able1

Die Ausnahmen von Scala funktionieren wie Ausnahmen in vielen anderen Sprachen wie Java. Anstatt einen Wert auf normale Weise zurückzugeben, kann eine Methode durch Auslösen einer Ausnahme beendet werden. Scala hat jedoch keine Ausnahmen überprüft.

Wenn Sie Ausnahmen behandeln möchten, verwenden Sie einen try {...} catch {...} -Block wie in Java, außer dass der catch-Block Matching verwendet, um die Ausnahmen zu identifizieren und zu behandeln.

Ausnahmen werfen

Das Auslösen einer Ausnahme sieht genauso aus wie in Java. Sie erstellen ein Ausnahmeobjekt und werfen es dann mit demthrow Schlüsselwort wie folgt.

throw new IllegalArgumentException

Ausnahmen fangen

Scala ermöglicht es Ihnen try/catch eine Ausnahme in einem einzelnen Block und führen Sie dann einen Mustervergleich mit ihm durch caseBlöcke. Versuchen Sie das folgende Beispielprogramm, um Ausnahmen zu behandeln.

Beispiel

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Missing file exception

Das Verhalten davon try-catchAusdruck ist der gleiche wie in anderen Sprachen mit Ausnahmen. Der Body wird ausgeführt, und wenn er eine Ausnahme auslöst, jeweilscatch Klausel wird der Reihe nach versucht.

Die Endklausel

Sie können einen Ausdruck mit einem umschließen finallyKlausel, wenn Sie möchten, dass Code ausgeführt wird, unabhängig davon, wie der Ausdruck beendet wird. Versuchen Sie das folgende Programm.

Beispiel

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Missing file exception
Exiting finally...

Ein Extraktor in Scala ist ein Objekt mit einer Methode namens unapplyals eines seiner Mitglieder. Der Zweck dieser nicht angewendeten Methode besteht darin, einen Wert abzugleichen und auseinanderzunehmen. Oft definiert das Extraktorobjekt auch eine duale Methodeapply für Gebäudewerte, aber dies ist nicht erforderlich.

Beispiel

Nehmen wir ein Beispiel für ein Objekt, das beides definiert apply und unapplyMethoden. Die Methode apply hat dieselbe Bedeutung wie immer: Sie verwandelt Test in ein Objekt, das auf Argumente in Klammern angewendet werden kann, genauso wie eine Methode angewendet wird. Sie können also Test ("Zara", "gmail.com") schreiben, um die Zeichenfolge "[email protected]" zu erstellen.

Das unapply Methode ist, was Test Klasse in eine verwandelt extractor und es kehrt den Bauprozess von um apply. Wenn "Apply" zwei Zeichenfolgen verwendet und daraus eine E-Mail-Adresszeichenfolge bildet, nimmt "Unapply" eine E-Mail-Adresse und gibt möglicherweise zwei Zeichenfolgen zurück: dieuser und die domain der Adresse.

Das unapplymuss auch den Fall behandeln, in dem die angegebene Zeichenfolge keine E-Mail-Adresse ist. Aus diesem Grund gibt unapply einen Optionstyp über Zeichenfolgenpaare zurück. Das Ergebnis ist entwederSome (user, domain)Wenn die Zeichenfolge str eine E-Mail-Adresse mit den angegebenen Benutzer- und Domänenteilen ist, oder Keine, wenn str keine E-Mail-Adresse ist. Hier sind einige Beispiele wie folgt.

Syntax

unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None

Das folgende Beispielprogramm zeigt ein Extraktionsobjekt für E-Mail-Adressen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      println ("Apply method : " + apply("Zara", "gmail.com"));
      println ("Unapply method : " + unapply("[email protected]"));
      println ("Unapply method : " + unapply("Zara Ali"));
   }
   
   // The injection method (optional)
   def apply(user: String, domain: String) = {
      user +"@"+ domain
   }

   // The extraction method (mandatory)
   def unapply(str: String): Option[(String, String)] = {
      val parts = str split "@"
      
      if (parts.length == 2){
         Some(parts(0), parts(1)) 
      } else {
         None
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None

Mustervergleich mit Extraktoren

Wenn auf eine Instanz einer Klasse Klammern mit einer Liste von null oder mehr Parametern folgen, ruft der Compiler die auf applyMethode auf dieser Instanz. Wir können anwenden sowohl in Objekten als auch in Klassen definieren.

Wie oben erwähnt, ist der Zweck der unapplyMethode ist es, einen bestimmten Wert zu extrahieren, den wir suchen. Es macht den umgekehrten Vorgangapplytut. Beim Vergleichen eines Extraktorobjekts mit demmatch Aussage der unapply Methode wird automatisch ausgeführt.

Versuchen Sie das folgende Beispielprogramm.

Beispiel

object Demo {
   def main(args: Array[String]) {
      val x = Demo(5)
      println(x)

      x match {
         case Demo(num) => println(x+" is bigger two times than "+num)
         
         //unapply is invoked
         case _ => println("i cannot calculate")
      }
   }
   def apply(x: Int) = x*2
   def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

10
10 is bigger two times than 5

Scala ist offen für die Verwendung von Java-Objekten und java.io.File ist eines der Objekte, die in der Scala-Programmierung zum Lesen und Schreiben von Dateien verwendet werden können.

Das folgende Beispielprogramm beschreibt das Schreiben in eine Datei.

Beispiel

import java.io._

object Demo {
   def main(args: Array[String]) {
      val writer = new PrintWriter(new File("test.txt" ))

      writer.write("Hello Scala")
      writer.close()
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Es wird eine Datei mit dem Namen erstellt Demo.txtim aktuellen Verzeichnis, in dem sich das Programm befindet. Das Folgende ist der Inhalt dieser Datei.

Ausgabe

Hello Scala

Lesen einer Zeile über die Befehlszeile

Manchmal müssen Sie Benutzereingaben vom Bildschirm lesen und dann mit der weiteren Verarbeitung fortfahren. Das folgende Beispielprogramm zeigt Ihnen, wie Sie Eingaben von der Befehlszeile lesen.

Beispiel

object Demo {
   def main(args: Array[String]) {
      print("Please enter your input : " )
      val line = Console.readLine
      
      println("Thanks, you just typed: " + line)
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Please enter your input : Scala is great
Thanks, you just typed: Scala is great

Dateiinhalt lesen

Das Lesen aus Dateien ist wirklich einfach. Sie können Scala verwendenSourceKlasse und ihr Begleitobjekt zum Lesen von Dateien. Das folgende Beispiel zeigt Ihnen, wie Sie lesen können"Demo.txt" Datei, die wir zuvor erstellt haben.

Beispiel

import scala.io.Source

object Demo {
   def main(args: Array[String]) {
      println("Following is the content read:" )

      Source.fromFile("Demo.txt" ).foreach { 
         print 
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Following is the content read:
Hello Scala