Scala-quick-guide

提供：Dev Guides
移動先:案内、検索

Scala-概要

Scalaは、Scalable Languageの略で、ハイブリッド関数型プログラミング言語です。 Martin Oderskyが作成しました。 Scalaは、オブジェクト指向言語と機能言語の機能をスムーズに統合します。 Scalaは、Java仮想マシンで実行するようにコンパイルされています。 ビジネスに不可欠なアプリケーションをJavaに依存している多くの既存企業は、開発の生産性、アプリケーションのスケーラビリティ、および全体的な信頼性を高めるためにScalaに注目しています。

ここでは、Scalaをアプリケーション開発者の最初の選択肢にするいくつかのポイントを紹介しました。

Scalaはオブジェクト指向です

Scalaは、すべての値がオブジェクトであるという意味で、純粋なオブジェクト指向言語です。 オブジェクトのタイプと動作は、後続の章で説明するクラスと特性によって説明されます。

クラスは、複数の継承を完全に置き換える subclassing と柔軟な* mixinベースの構成*メカニズムによって拡張されます。

Scalaは機能的です

Scalaは、すべての関数が値であり、すべての値がオブジェクトであるという意味で関数型言語でもあるため、最終的にはすべての関数がオブジェクトです。

Scalaは、*匿名関数*を定義するための軽量な構文を提供し、*高階関数*をサポートし、関数を*入れ子*にし、*カリー*をサポートします。 これらの概念については、以降の章で説明します。

Scalaは静的に型付けされます

Scalaは、他の静的に型付けされた言語（C、Pascal、Rustなど）とは異なり、冗長な型情報の提供を期待していません。 ほとんどの場合、タイプを指定する必要はありません。また、タイプを繰り返す必要はありません。

ScalaはJVMで実行されます

Scalaは、Java仮想マシン（JVM）によって実行されるJavaバイトコードにコンパイルされます。 これは、ScalaとJavaに共通のランタイムプラットフォームがあることを意味します。 JavaからScalaに簡単に移行できます。

Scalaコンパイラーは、ScalaコードをJavaバイトコードにコンパイルし、「 scala 」コマンドで実行できます。 ' scala 'コマンドは、コンパイルされたScalaコードを実行するという点で、 java コマンドに似ています。

ScalaはJavaコードを実行できます

Scalaを使用すると、Java SDKのすべてのクラスと、独自のカスタムJavaクラス、またはお気に入りのJavaオープンソースプロジェクトを使用できます。

Scalaは並行処理と同期処理を実行できます

Scalaを使用すると、一般的なプログラミングパターンを効果的に表現できます。 行数を減らし、プログラマーが型保証された方法でコーディングできるようにします。 これにより、不変の方法でコードを記述できるため、並行性と並列処理（同期）を簡単に適用できます。

Scala対Java

Scalaには、Javaとはまったく異なる一連の機能があります。 これらのいくつかは-

  • すべてのタイプはオブジェクトです
  • 型推論
  • 入れ子関数
  • 関数はオブジェクトです
  • ドメイン固有言語（DSL）のサポート
  • 特性
  • クロージャ
  • Erlangに触発された同時実行性のサポート

Scala Webフレームワーク

Scalaはあらゆる場所で使用されており、重要なのはエンタープライズWebアプリケーションです。 最も人気のあるScala Webフレームワークのいくつかを確認できます-

Scala-環境設定

Scalaは、任意のUNIXフレーバーまたはWindowsベースのシステムにインストールできます。 マシンへのScalaのインストールを開始する前に、コンピューターにJava 1.8以降がインストールされている必要があります。

以下の手順に従ってScalaをインストールします。

ステップ1：Javaインストールの確認

まず、システムにJava Software Development Kit（SDK）をインストールする必要があります。 これを確認するには、作業しているプラ​​ットフォームに応じて、次の2つのコマンドのいずれかを実行します。

Javaインストールが適切に行われている場合、Javaインストールの現在のバージョンと仕様が表示されます。 サンプル出力を次の表に示します。

Platform Command Sample Output
Windows

Open Command Console and type −

  • \> java –version*

a

Javaバージョン「1.8.0_31」

Java（TM）SEランタイム

環境（ビルド1.8.0_31-b31）

Java Hotspot（TM）64ビットサーバー

VM（ビルド25.31-b07、混合モード）

Linux

Open Command terminal and type −

  • $ java –version*

a

Javaバージョン「1.8.0_31」

JDKランタイム環境を開く（rhel-2.8.10.4.el6_4-x86_64）

JDK 64ビットサーバーVMを開きます（ビルド25.31-b07、混合モード）

このチュートリアルの読者は、システムにJava SDKバージョン1.8.0_31がインストールされていることを前提としています。

Java SDKがない場合は、http：//www.oracle.com/technetwork/java/javase/downloads/indexlから現在のバージョンをダウンロードしてインストールしてください。

ステップ2：Java環境を設定する

Javaがマシンにインストールされているベースディレクトリの場所を指すように、環境変数JAVA_HOMEを設定します。 例えば、

Sr.No Platform & Description
1

Windows

JAVA_HOMEをC：\ ProgramFiles \ java \ jdk1.7.0_60に設定します

2

Linux

JAVA_HOME =/usr/local/java-currentをエクスポート

Javaコンパイラの場所の完全パスをシステムパスに追加します。

Sr.No Platform & Description
1

Windows

文字列「C：\ Program Files \ Java \ jdk1.7.0_60 \ bin」をシステム変数PATHの最後に追加します。

2

Linux

PATH = $ PATH：$ JAVA_HOME/bin/をエクスポートします

上記で説明したように、コマンドプロンプトからコマンド java -version を実行します。

ステップ3：Scalaをインストールする

Scalaはhttp://www.scala-lang.org/download/[http://www.scala-lang.org/downloads]からダウンロードできます。 このチュートリアルを書いている時点で、「scala-2.11.5-installer.jar」をダウンロードしました。 続行するには管理者権限があることを確認してください。 今、コマンドプロンプトで次のコマンドを実行します-

Platform Command & Output Description
Windows \>java –jar scala-2.11.5-installer.jar\> This command will display an installation wizard, which will guide you to install Scala on your windows machine. During installation, it will ask for license agreement, simply accept it and further it will ask a path where Scala will be installed. I selected default given path “C:\Program Files\Scala”, you can select a suitable path as per your convenience.
Linux

Command −

$ java –jar scala-2.9.0.1-installer.jar

出力-

Scala 2.9.0.1のインストールへようこそ！

ホームページは-http://scala-lang.org/[http://Scala-lang.org/]にあります

1を押して続行し、2を押して終了し、3を押して再表示します

1 …​…​…​…​…​…​…​…​…​…​…​…​…​…​…​…​

{空} [開梱開始]

{空} [パッケージの処理：ソフトウェアパッケージのインストール（1/1）]

{空} [開梱完了]

{空} [コンソールのインストール完了]

During installation, it will ask for license agreement, to accept it type 1 and it will ask a path where Scala will be installed. I entered /usr/local/share, you can select a suitable path as per your convenience.

最後に、新しいコマンドプロンプトを開き、 Scala -version と入力してEnterキーを押します。 次が表示されるはずです-

Platform Command Output
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

Scala-基本的な構文

Javaについて十分に理解していれば、Scalaを簡単に学ぶことができます。 ScalaとJavaの構文上の最大の違いは、「;」行末文字はオプションです。

Scalaプログラムを考えると、お互いのメソッドを呼び出して通信するオブジェクトのコレクションとして定義できます。 ここで、クラス、オブジェクト、メソッド、およびインスタンス変数の意味を簡単に見てみましょう。

  • オブジェクト-オブジェクトには状態と動作があります。 オブジェクトはクラスのインスタンスです。 例-犬には、色、名前、品種、および行動-振る、える、食べるという状態があります。
  • クラス-クラスは、そのクラスに関連する動作/状態を説明するテンプレート/設計図として定義できます。
  • メソッド-メソッドは基本的に動作です。 クラスには多くのメソッドを含めることができます。 ロジックが書き込まれ、データが操作され、すべてのアクションが実行されるのはメソッドです。
  • フィールド-各オブジェクトには、フィールドと呼ばれるインスタンス変数の一意のセットがあります。 オブジェクトの状態は、これらのフィールドに割り当てられた値によって作成されます。
  • Closure - closure は関数であり、その戻り値はこの関数の外部で宣言された1つ以上の変数の値に依存します。
  • Traits -トレイトはメソッドとフィールドの定義をカプセル化し、それらをクラスに混ぜて再利用できます。 特性は、サポートされているメソッドのシグネチャを指定することにより、オブジェクトタイプを定義するために使用されます。

最初のScalaプログラム

Scalaプログラムは2つのモードで実行できます。1つは*インタラクティブモード*で、もう1つは*スクリプトモード*です。

インタラクティブモード

コマンドプロンプトを開き、次のコマンドを使用してScalaを開きます。 

\>scala

Scalaがシステムにインストールされている場合、次の出力が表示されます- 

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

Scalaプロンプトの右側に次のテキストを入力し、Enterキーを押します- 

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

それは次の結果を生成します- 

Hello, Scala!

スクリプトモード

スクリプトモードでScalaプログラムを作成するには、以下の手順を使用します。 メモ帳を開き、次のコードを追加します。

例

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
   }
}
  • HelloWorld.scala としてファイルを保存します。

コマンドプロンプトウィンドウを開き、プログラムファイルが保存されているディレクトリに移動します。 「 scalac 」コマンドを使用してScalaプログラムをコンパイルすると、現在のディレクトリにいくつかのクラスファイルが生成されます。 それらの1つは HelloWorld.class と呼ばれます。 これは、「 scala 」コマンドを使用してJava仮想マシン（JVM）で実行されるバイトコードです。

次のコマンドを使用して、Scalaプログラムをコンパイルおよび実行します。 

\> scalac HelloWorld.scala
\> scala HelloWorld

出力

Hello, World!

基本的な構文

以下は、Scalaプログラミングの基本的な構文とコーディング規則です。

  • 大文字と小文字の区別-Scalaは大文字と小文字を区別します。つまり、識別子 Hello と hello はScalaでは異なる意味を持ちます。
  • クラス名-すべてのクラス名について、最初の文字は大文字でなければなりません。 複数の単語を使用してクラスの名前を形成する場合、各内側の単語の最初の文字は大文字にする必要があります。 + 例-クラスMyFirstScalaClass。
  • メソッド名-すべてのメソッド名は小文字で始まる必要があります。 複数の単語を使用してメソッドの名前を形成する場合、各内側の単語の最初の文字は大文字にする必要があります。 + 例-def myMethodName（）
  • プログラムファイル名-プログラムファイルの名前はオブジェクト名と完全に一致する必要があります。 ファイルを保存するときは、オブジェクト名（Scalaでは大文字と小文字が区別されることに注意してください）を使用して保存し、名前の末尾に「 .scala 」を追加する必要があります。 （ファイル名とオブジェクト名が一致しない場合、プログラムはコンパイルされません）。 + 例-「HelloWorld」がオブジェクト名であると仮定します。 次に、ファイルを「HelloWorld.scala」として保存する必要があります。
  • * def main（args：Array [String]）*-Scalaプログラムの処理は、すべてのScalaプログラムの必須部分であるmain（）メソッドから始まります。

Scala識別子

すべてのScalaコンポーネントには名前が必要です。 オブジェクト、クラス、変数、およびメソッドに使用される名前は識別子と呼ばれます。 キーワードは識別子として使用できず、識別子は大文字と小文字が区別されます。 Scalaは4種類の識別子をサポートしています。

英数字識別子

英数字の識別子は、文字またはアンダースコアで始まり、その後にさらに文字、数字、またはアンダースコアを続けることができます。 '$'文字はScalaで予約されているキーワードであり、識別子には使用しないでください。

以下は、*法的英数字識別子*です- 

age, salary, _value,  __1_value

以下は*不正な識別子*です- 

$salary, 123abc, -salary

オペレーター識別子

オペレーターIDは、1つ以上のオペレーター文字で構成されます。 演算子文字は、+、：、？、〜、＃などの印刷可能なASCII文字です。

以下は正当なオペレーター識別子です- 

&plus; &plus;&plus; ::: <?> :>

Scalaコンパイラは、内部で演算子識別子を「マングル」して、$文字が埋め込まれた正当なJava識別子に変換します。 たとえば、識別子：→は内部的に$ colon $ minus $ greaterとして表されます。

混合識別子

混合識別子は、英数字の識別子で構成され、その後にアンダースコアと演算子識別子が続きます。

以下は、有効な混合識別子です- 

unary_&plus;,  myvar_=

ここで、単項演算子メソッド名として使用すると、単項＆plus;が定義されます。メソッド名として使用されるoperatorとmyvar_ =は、代入演算子（演算子のオーバーロード）を定義します。

リテラル識別子

リテラル識別子は、バックティック（ `で囲まれた任意の文字列です。 . . `).

以下は正当なリテラル識別子です- 

`x` `<clinit>` `yield`

Scalaキーワード

次のリストは、Scalaの予約語を示しています。 これらの予約語は、定数、変数、またはその他の識別子名として使用できません。

abstract case catch class
def do else extends
false final finally for
forSome if implicit import
lazy match new Null
object override package private
protected return sealed super
this throw trait Try
true type val Var
while with yield  
- : = ⇒
← <: <% >:
# @

Scalaのコメント

Scalaは、Javaと非常によく似た単一行および複数行のコメントをサポートしています。 複数行のコメントはネストできますが、適切にネストする必要があります。 コメント内で使用可能なすべての文字は、Scalaコンパイラーによって無視されます。 

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!")
   }
}

空白行と空白

コメントが含まれる可能性のある空白のみを含む行は空白行と呼ばれ、Scalaは完全に無視します。 トークンは、空白文字やコメントで区切ることができます。

改行文字

Scalaは行指向の言語で、ステートメントはセミコロン（;）または改行で終了できます。 通常、ステートメントの最後のセミコロンはオプションです。 必要に応じて1つ入力できますが、ステートメントが1行に単独で表示される場合は入力する必要はありません。 一方、1行に複数のステートメントを記述する場合はセミコロンが必要です。 以下の構文は、複数のステートメントの使用法です。 

val s = "hello"; println(s)

Scalaパッケージ

パッケージは、コードの名前付きモジュールです。 たとえば、Liftユーティリティパッケージはnet.liftweb.utilです。 パッケージ宣言は、次のようにソースファイルの最初の非コメント行です- 

package com.liftcode.stuff

現在のコンパイルスコープで参照できるように、Scalaパッケージをインポートできます。 次のステートメントは、scala.xmlパッケージの内容をインポートします- 

import scala.xml._

あなたは、単一のクラスとオブジェクト、例えばscala.collection.mutableパッケージからHashMapをインポートすることができます- 

import scala.collection.mutable.HashMap

あなたは、例えば、scala.collection.immutableパッケージからTreeMapとTreeSetなど、単一のパッケージから複数のクラスまたはオブジェクトをインポートすることができます- 

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

ダイナミックを適用

動的呼び出しを可能にするマーカー特性。 この特性のインスタンスxは、任意のメソッド名methおよび引数リストargsのメソッド呼び出しx.meth（args）、および任意のフィールド名フィールドのフィールドアクセスx.fieldを許可します。 この機能はScala-2.10で導入されました。

呼び出しがxによってネイティブにサポートされていない場合（つまり、 型チェックが失敗した場合）、それは次のルールに従って書き換えられます- 

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-データ型

ScalaはJavaと同じデータ型を持ち、同じメモリフットプリントと精度を持っています。 以下は、Scalaで利用可能なすべてのデータ型に関する詳細を示す表です-

Sr.No Data Type & Description
1

Byte

8ビットの符号付き値。 -128〜127の範囲

2

Short

16ビットの符号付き値。 範囲-32768〜32767

3

Int

32ビットの符号付き値。 -2147483648から2147483647の範囲

4

Long

64ビットの符号付き値。 -9223372036854775808から9223372036854775807まで

5

Float

32ビットIEEE 754単精度浮動小数点

6

Double

64ビットIEEE 754倍精度浮動小数点

7

Char

16ビットの符号なしUnicode文字。 U + 0000からU + FFFFの範囲

8

String

Charsのシーケンス

9

Boolean

リテラルtrueまたはリテラルfalse

10

Unit

値なしに対応

11

Null

nullまたは空の参照

12

Nothing

他のすべてのタイプのサブタイプ。値が含まれていません

13

Any

任意のタイプのスーパータイプ。すべてのオブジェクトは_Any_タイプです

14

AnyRef

参照型のスーパータイプ

上記のデータ型はすべてオブジェクトです。 Javaのようなプリミティブ型はありません。 つまり、Int、Longなどでメソッドを呼び出すことができます。

Scala Basicリテラル

Scalaがリテラルに使用するルールはシンプルで直感的です。 このセクションでは、すべての基本的なScalaリテラルについて説明します。

積分リテラル

整数リテラルは通常、Int型、またはLまたはl接尾辞が続くLong型です。 ここにいくつかの整数リテラルがあります- 

0
035
21
0xFFFFFFFF
0777L

浮動小数点リテラル

浮動小数点リテラルは、その後に浮動小数点型の接尾辞Fまたはfが続く場合はFloat型であり、そうでない場合はDouble型です。 ここにいくつかの浮動小数点リテラルがあります- 

0.0
1e30f
3.14159f
1.0e100
.1

ブールリテラル

ブールリテラル true および false は、ブール型のメンバーです。

シンボルリテラル

シンボルリテラル 'xは、式* scala.Symbol（ "x"）*の省略形です。 Symbolは、次のように定義されるケースクラスです。 

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

文字リテラル

文字リテラルは、引用符で囲まれた単一の文字です。 文字は、印刷可能なUnicode文字であるか、エスケープシーケンスで記述されています。 ここにいくつかの文字リテラルがあります- 

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

文字列リテラル

文字列リテラルは、二重引用符で囲まれた一連の文字です。 文字は、印刷可能なUnicode文字であるか、エスケープシーケンスで記述されています。 ここにいくつかの文字列リテラルがあります- 

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

複数行の文字列

複数行の文字列リテラルは、三重引用符 "" "で囲まれた一連の文字です…​ """. 文字のシーケンスは任意です。ただし、最後にのみ3つ以上の連続する引用文字が含まれる場合があります。

文字は必ずしも印刷可能である必要はありません。改行またはその他の制御文字も許可されます。 これは複数行の文字列リテラルです- 

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

ヌル値

null値は scala.Null 型であるため、すべての参照型と互換性があります。 これは、特別な「ヌル」オブジェクトを参照する参照値を示します。

エスケープシーケンス

次のエスケープシーケンスは、文字および文字列リテラルで認識されます。

Escape Sequences Unicode Description
\b \u0008 backspace BS
\t \u0009 horizontal tab HT
\n \u000c formfeed FF
\f \u000c formfeed FF
\r \u000d carriage return CR
\" \u0022 double quote "
\' \u0027 single quote .
\\ \u005c backslash \

0から255までのUnicodeの文字は、8進数のエスケープ、つまり、バックスラッシュ「\」の後に最大3文字の8進数の文字列が続くことによっても表されます。 以下は、いくつかのエスケープシーケンス文字を表示する例です-

例

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

上記のコードをコンパイルして実行すると、次の結果が生成されます-

出力

Hello   World

Scala-変数

変数は、値を保存するために予約されたメモリの場所に他なりません。 これは、変数を作成するときに、メモリ内にスペースを確保することを意味します。

変数のデータ型に基づいて、コンパイラはメモリを割り当て、予約メモリに格納できるものを決定します。 したがって、異なるデータ型を変数に割り当てることにより、これらの変数に整数、小数、または文字を格納できます。

可変宣言

Scalaには、変数を宣言するための異なる構文があります。 値、つまり定数または変数として定義できます。 ここでは、キーワードvarを使用してmyVarが宣言されています。 値を変更できる変数であり、これは*可変変数*と呼ばれます。 以下は、 var キーワードを使用して変数を定義する構文です-

構文

var myVar : String = "Foo"

ここでは、キーワードvalを使用してmyValが宣言されています。 これは、変更できない変数であり、*不変変数*と呼ばれることを意味します。 以下は、valキーワードを使用して変数を定義する構文です-

構文

val myVal : String = "Foo"

可変データ型

変数のタイプは、変数名の後、等号の前に指定されます。 次のようにデータ型に言及することにより、Scala変数の任意の型を定義できます-

構文

val or val VariableName : DataType = [Initial Value]

あなたが変数に初期値を割り当てない場合、それは次のように有効です-

構文

var myVar :Int;
val myVal :String;

可変型推論

初期値を変数に割り当てると、Scalaコンパイラーは、割り当てられた値に基づいて変数のタイプを判別できます。 これは、変数型推論と呼ばれます。 したがって、次のようにこれらの変数宣言を書くことができます-

構文

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

ここで、デフォルトでは、myVarはInt型になり、myValはString型変数になります。

複数の割り当て

Scalaは複数の割り当てをサポートしています。 コードブロックまたはメソッドがタプル（タプル-さまざまなタイプのオブジェクトのコレクションを保持する）を返す場合、タプルをval変数に割り当てることができます。 [注-後続の章でタプルを学習します。]

構文

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

そして、型推論はそれを正しくします-

構文

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

サンプルプログラム

以下は、Scalaでの変数宣言のプロセスを説明するサンプルプログラムです。 このプログラムは4つの変数を宣言します。2つの変数は型宣言で定義され、残りの2つは型宣言なしで定義されます。

例

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);
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

可変スコープ

Scalaの変数は、使用される場所に応じて3つの異なるスコープを持つことができます。 フィールド、メソッドのパラメーター、ローカル変数として存在できます。 以下は、各タイプのスコープに関する詳細です。

フィールド

フィールドは、オブジェクトに属する変数です。 フィールドは、オブジェクト内のすべてのメソッド内からアクセスできます。 フィールドは、フィールドが宣言されているアクセス修飾子に応じて、オブジェクトの外部からもアクセスできます。 オブジェクトフィールドは、可変型と不変型の両方にすることができ、 var または val のいずれかを使用して定義できます。

メソッドのパラメーター

メソッドパラメータは変数であり、メソッドが呼び出されたときにメソッド内で値を渡すために使用されます。 メソッドのパラメーターはメソッドの内部からのみアクセスできますが、メソッドの外部からオブジェクトへの参照がある場合、渡されたオブジェクトは外部からアクセスできます。 val キーワードで定義されるメソッドパラメータは常に不変です。

ローカル変数

ローカル変数は、メソッド内で宣言された変数です。 ローカル変数はメソッド内からのみアクセスできますが、作成したオブジェクトは、メソッドから返されるとメソッドをエスケープする場合があります。 ローカル変数は、可変型と不変型の両方にすることができ、 var または val を使用して定義できます。

Scala-クラスとオブジェクト

この章では、Scalaプログラミングでクラスとオブジェクトを使用する方法について説明します。 クラスはオブジェクトの青写真です。 クラスを定義したら、キーワード new を使用してクラスブループリントからオブジェクトを作成できます。 オブジェクトを通じて、定義されたクラスのすべての機能を使用できます。

次の図は、クラス変数とオブジェクトメソッド（setName（）とsetRollNo（））を含むクラスstudentの例を使用して、クラスとオブジェクトを示しています。 最後に、すべてがクラスのメンバーです。 クラスは青写真であり、オブジェクトはここにあります。 次の図では、Studentはクラスであり、Harini、John、およびMariaはStudentクラスのオブジェクトです。これらは名前とロール番号を持っています。

スカラクラスとオブジェクト

基本クラス

以下は、Scalaで基本クラスを定義する簡単な構文です。 このクラスは、2つの変数 x および y とメソッドを定義します： move は値を返しません。 クラス変数が呼び出され、クラスおよびメソッドのフィールドはクラスメソッドと呼ばれます。

クラス名は、多くのパラメーターを受け取ることができるクラスコンストラクターとして機能します。 上記のコードは、2つのコンストラクター引数 xc および yc を定義しています。これらは両方ともクラスの本体全体に表示されます。

構文

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

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

この章で前述したように、キーワード new を使用してオブジェクトを作成し、次に例に示すようにクラスフィールドとメソッドにアクセスできます-

例

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 &plus; dx
      y = y &plus; dy
      println ("Point x location : " &plus; x);
      println ("Point y location : " &plus; y);
   }
}

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Point x location : 20
Point y location : 30

クラスを拡張する

基本Scalaクラスを拡張し、Javaで行うのと同じ方法で継承クラスを設計できます（ extends キーワードを使用）が、2つの制限があります：メソッドのオーバーライドには override キーワードが必要で、 primary コンストラクターは、パラメーターをベースコンストラクターに渡すことができます。 上記のクラスを拡張して、もう1つのクラスメソッドを追加しましょう。

例

Pointクラス（上記と同じ例）の2つのクラスの例を取り上げましょう。Locationクラスはextendsキーワードを使用して継承されたクラスです。 このような「 extends 」句には2つの効果があります。LocationクラスにPointクラスからすべての非プライベートメンバーを継承させ、_Location_型を_Point_クラス型のサブタイプにします。 したがって、ここではPointクラスは superclass と呼ばれ、クラス_Location_は subclass と呼ばれます。 クラスを拡張し、親クラスのすべての機能を継承することを*継承*と呼びますが、Scalaでは1つのクラスのみからの継承を許可しています。

注-Pointクラスのmove（）メソッドとLocationクラスの* move（）メソッドは、異なる定義であるため、対応するmoveの定義をオーバーライドしません（たとえば、前者は2つの引数を取り、後者は3つの引数を取ります） ）。

次のプログラム例を試して、継承を実装してください。 

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 &plus; dx
      y = y &plus; dy
      println ("Point x location : " &plus; x);
      println ("Point y location : " &plus; 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 &plus; dx
      y = y &plus; dy
      z = z &plus; dz
      println ("Point x location : " &plus; x);
      println ("Point y location : " &plus; y);
      println ("Point z location : " &plus; 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);
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

暗黙のクラス

暗黙のクラスは、クラスがスコープ内にあるときに、クラスのプライマリコンストラクターとの暗黙の会話を許可します。 暗黙クラスは、「暗黙」キーワードでマークされたクラスです。 この機能はScala 2.10で導入されました。

構文-暗黙的なクラスの構文は次のとおりです。 ここで、暗黙クラスは最上位クラスになることができないため、すべてのメソッド定義が許可されるオブジェクトスコープに常に暗黙クラスがあります。

構文

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

例

times（）メソッドを使用した IntTimes という名前の暗黙的なクラスの例を見てみましょう。 times（）には、指定されたステートメントを指定した回数実行するループトランザクションが含まれることを意味します。 指定されたステートメントが「4回println（「Hello」）」であると仮定して、println（「「Hello」）ステートメントが4回実行されることを意味します。

以下は、指定された例のプログラムです。 この例では、2つのオブジェクトクラス（実行とデモ）が使用されるため、次のように、これら2つのクラスをそれぞれの名前で異なるファイルに保存する必要があります。 

*Run.scala* -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* -次のプログラムをDemo.scalaに保存します。
import Run._

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

これらの2つのプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

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

出力

Hello
Hello
Hello
Hello

注-

  • 暗黙のクラスは、別のクラス/オブジェクト/トレイト（トップレベルではない）内で定義する必要があります。
  • 暗黙的なクラスは、コンストラクターで1つの非暗黙的な引数のみを取ることができます。
  • 暗黙のクラスは、暗黙のクラスと同じ名前のスコープ、メソッド、メンバー、またはオブジェクトであってはなりません。

シングルトンオブジェクト

Scalaは静的メンバーを持つことができないため、ScalaはJavaよりもオブジェクト指向です。 代わりに、Scalaには*シングルトンオブジェクト*があります。 シングルトンは、1つのインスタンス（オブジェクト）のみを持つことができるクラスです。 classキーワードの代わりにキーワード object を使用してシングルトンを作成します。 シングルトンオブジェクトをインスタンス化できないため、パラメーターをプライマリコンストラクターに渡すことはできません。 Scalaのmainメソッドを呼び出したシングルトンオブジェクトを使用したすべての例を見てきました。

以下は、シングルトンを実装する同じプログラム例です。

例

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 &plus; dx
      y = y &plus; dy
   }
}

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Point x location : 10
Point y location : 20

Scala-アクセス修飾子

この章では、Scalaアクセス修飾子について説明します。 パッケージ、クラス、またはオブジェクトのメンバーには、アクセス修飾子privateおよびprotectedのラベルを付けることができます。これら2つのキーワードのいずれも使用していない場合、アクセスはパブリックと見なされます。 これらの修飾子は、メンバーへのアクセスを特定のコード領域に制限します。 アクセス修飾子を使用するには、次のセクションで説明するように、パッケージ、クラス、またはオブジェクトのメンバーの定義にそのキーワードを含めます。

プライベートメンバー

プライベートメンバーは、メンバー定義を含むクラスまたはオブジェクト内でのみ表示されます。

以下は、プライベートメンバーを説明するためのサンプルコードスニペットです-

例

class Outer {
   class Inner {
      private def f() { println("f") }

      class InnerMost {
         f()//OK
      }
   }
   (new Inner).f()//Error: f is not accessible
}

Scalaでは、アクセス（新しい内部）。 fはInnerでprivateと宣言されており、アクセスはInnerクラス内からではないため、f（）は不正です。 対照的に、Innermostクラスのfへの最初のアクセスはOKです。そのアクセスはInnerクラスの本体に含まれているためです。 Javaは、外部クラスが内部クラスのプライベートメンバーにアクセスできるため、両方のアクセスを許可します。

保護されたメンバー

保護されたメンバーは、そのメンバーが定義されているクラスのサブクラスからのみアクセスできます。

以下は、保護されたメンバーを説明するためのコードスニペットの例です-

例

package p {
   class Super {
      protected def f() { println("f") }
   }

   class Sub extends Super {
      f()
   }

   class Other {
      (new Super).f()//Error: f is not accessible
   }
}

fが「スーパー」クラスで保護されていると宣言され、「サブ」クラスがスーパーのサブクラスであるため、クラスSubのfへのアクセスは問題ありません。 対照的に、クラス「その他」はクラス「スーパー」から継承しないため、「その他」クラスのfへのアクセスは許可されません。 Javaでは、「その他」クラスは「サブ」クラスと同じパッケージにあるため、後者のアクセスは引き続き許可されます。

公開メンバー

プライベートメンバーや保護メンバーとは異なり、パブリックメンバーにパブリックキーワードを指定する必要はありません。 パブリックメンバーには明示的な修飾子はありません。 そのようなメンバーには、どこからでもアクセスできます。

以下は、パブリックメンバーを説明するためのサンプルコードスニペットです-

例

class Outer {
   class Inner {
      def f() { println("f") }

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

保護の範囲

Scalaのアクセス修飾子は修飾子で拡張できます。 private [X]またはprotected [X]という形式の修飾子は、アクセスがプライベートであるか、「X」まで保護されていることを意味します。Xは、パッケージ、クラス、またはシングルトンオブジェクトを囲みます。

次の例を考慮してください-

例

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
         }
      }
   }
}

注-上記の例からの次のポイント-

  • 変数workDetailsは、パッケージの専門家内のどのクラスからもアクセスできます。
  • 多様な友人は、包囲するパッケージ社会内のどのクラスからもアクセスできます。
  • 可変シークレットは、インスタンスメソッド内の暗黙オブジェクト（this）でのみアクセス可能です。

Scala-オペレーター

演算子は、特定の数学的または論理的な操作を実行するようコンパイラーに指示する記号です。 Scalaは組み込みの演算子が豊富であり、次の種類の演算子を提供します-

  • 算術演算子
  • 関係演算子
  • 論理演算子
  • ビット演算子
  • 割り当て演算子

この章では、算術、関係、論理、ビット単位、割り当て、およびその他の演算子を1つずつ調べます。

算術演算子

次の算術演算子は、Scala言語でサポートされています。 たとえば、変数Aが10を保持し、変数Bが20を保持すると仮定します-

リンク：/scala/scala_arithmatic_operators [例を表示]

Operator Description Example
PLUS Adds two operands A PLUS B will give 30
- Subtracts second operand from the first A - B will give -10
* Multiplies both operands A* B will give 200
/ Divides numerator by de-numerator B/A will give 2
% Modulus operator finds the remainder after division of one number by another B % A will give 0

関係演算子

次の関係演算子はScala言語でサポートされています。 たとえば、変数Aが10を保持し、変数Bが20を保持すると仮定します-

link：/scala/scala_relational_operators [例を表示]

Operator Description Example
== Checks if the values of two operands are equal or not, if yes then condition becomes true. (A == B) is not true.
!= Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. (A != B) is true.
> Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. (A > B) is not true.
< Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. (A < B) is true.
>= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. (A >= B) is not true.
⇐ Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. (A ⇐ B) is true.

論理演算子

次の論理演算子はScala言語でサポートされています。 たとえば、変数Aが1を保持し、変数Bが0を保持すると仮定します-

リンク：/scala/scala_logical_operators [例を表示]

Operator Description Example
&& It is called Logical AND operator. If both the operands are non zero then condition becomes true. (A && B) is false.
It is called Logical OR Operator. If any of the two operands is non zero then condition becomes true. (A
B) is true. ! It is called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.

ビット演算子

ビットごとの演算子はビットに対して機能し、ビットごとの演算を実行します。 ＆、|、および^の真理値表は次のとおりです-

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

A = 60であると仮定します。およびB = 13;今バイナリ形式では、次のようになります- 

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

Scala言語でサポートされているビット単位の演算子を次の表にリストします。 変数Aが60を保持し、変数Bが13を保持すると仮定します-

リンク：/scala/scala_bitwise_operators [例を表示]

Operator Description Example
& Binary AND Operator copies a bit to the result if it exists in both operands. (A & B) will give 12, which is 0000 1100
Binary OR Operator copies a bit if it exists in either operand.
(A B) will give 61, which is 0011 1101 ^
Binary XOR Operator copies the bit if it is set in one operand but not both. (A ^ B) will give 49, which is 0011 0001 ~
Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. (~A ) will give -61, which is 1100 0011 in 2’s complement form due to a signed binary number. <<
Binary Left Shift Operator. The bit positions of the left operands value is moved left by the number of bits specified by the right operand. A << 2 will give 240, which is 1111 0000 >>
Binary Right Shift Operator. The Bit positions of the left operand value is moved right by the number of bits specified by the right operand. A >> 2 will give 15, which is 1111 >>>

割り当て演算子

Scala言語でサポートされている次の代入演算子があります-

リンク：/scala/scala_assignment_operators [例を表示]

Operator Description Example
= Simple assignment operator, Assigns values from right side operands to left side operand C = A PLUS B will assign value of A PLUS B into C
PLUS= Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand C PLUS= A is equivalent to C = C PLUS A
-= Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand C -= A is equivalent to C = C - A
*= Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand C *= A is equivalent to C = C *A
/= Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand C/= A is equivalent to C = C/A
%= Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand C %= A is equivalent to C = C % A
<⇐ Left shift AND assignment operator C <⇐ 2 is same as C = C << 2
>>= Right shift AND assignment operator C >>= 2 is same as C = C >> 2
&= Bitwise AND assignment operator C &= 2 is same as 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

Scalaでの演算子の優先順位

演算子の優先順位は、式内の用語のグループ化を決定します。 これは、式の評価方法に影響します。 特定の演算子は、他の演算子よりも優先順位が高くなっています。たとえば、乗算演算子は加算演算子よりも優先順位が高い-

たとえば、x = 7 + 3* 2;ここでは、演算子*の優先順位が+よりも高いため、xには20ではなく13が割り当てられます。したがって、最初に3 * 2で乗算され、7に加算されます。

次の表をご覧ください。 優先順位が最も高い演算子が表の上部に表示され、優先順位が最も低い演算子が下部に表示されます。 式内では、優先順位の高い演算子が最初に評価されます。

Category Operator Associativity
Postfix () [] Left to right
Unary ! ~ Right to left
Multiplicative */% Left to right
Additive + - Left to right
Shift >> >>> << Left to right
Relational > >= < ⇐ Left to right
Equality == != Left to right
Bitwise AND & Left to right
Bitwise XOR ^ Left to right
Bitwise OR
Left to right Logical AND &&
Left to right Logical OR
Left to right
Assignment = += -=* =/= %= >>= <⇐ &= ^= =
Right to left Comma ,

Scala-IF ELSEステートメント

この章では、Scalaプログラミングの条件付き構築ステートメントについて説明します。 以下は、ほとんどのプログラミング言語で見られる典型的な意思決定IF …​ ELSE構造の一般的な形式です。

フローチャート

以下は、条件ステートメントのフローチャート図です。

Scala IF …​ ELSE構造

ifステートメント

「if」ステートメントは、ブール式とそれに続く1つ以上のステートメントで構成されます。

構文

「if」ステートメントの構文は次のとおりです。 

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

ブール式がtrueと評価された場合、「if」式内のコードブロックが実行されます。 そうでない場合、「if」式の終了後（閉じ中括弧の後）の最初のコードセットが実行されます。

次のサンプルプログラムを試して、Scalaプログラミング言語の条件式（if式）を理解してください。

例

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

This is if statement

If-elseステートメント

「if」ステートメントの後にオプションの_else_ステートメントを続けることができます。これは、ブール式がfalseの場合に実行されます。

構文

if …​ elseの構文は- 

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

次のプログラム例を試して、Scalaプログラミング言語の条件ステートメント（if- elseステートメント）を理解してください。

例

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

This is else statement

If-else-if-elseステートメント

「if」ステートメントの後にオプションの「else if …​ else」ステートメントを続けることができます。これは、単一のif …​ else ifステートメントを使用してさまざまな条件をテストするのに非常に便利です。

if、else if、elseステートメントを使用する場合、留意すべき点はほとんどありません。

  • 「if」には、0個または1個のelseを含めることができ、else ifの後に来る必要があります。
  • 「if」には、他のifを0個以上含めることができ、それらはelseの前に来る必要があります。
  • else ifが成功すると、else ifまたはelseの残りはテストされません。

構文

「if …​ else if …​ else」の構文は次のとおりです- 

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.
}

Scalaプログラミング言語の条件ステートメント（if- else- if- elseステートメント）を理解するには、次のサンプルプログラムを試してください。

例

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");
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Value of X is 30

ネストされたif-elseステートメント

*if-else* ステートメントをネストすることは常に有効です。つまり、1つの *if* または *else-if* ステートメントを別の *if* または *else-if* ステートメント内で使用できます。

構文

ネストされたif-elseの構文は次のとおりです- 

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

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

次のプログラム例を試して、Scalaプログラミング言語の条件ステートメント（ネストされたifステートメント）を理解してください。

例

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");
         }
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

X = 30 and Y = 10

Scala-ループ文

この章では、Scalaプログラミング言語のループ制御構造について説明します。

コードのブロックを数回実行する必要がある場合があります。 一般に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。

プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。

ループステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。ほとんどのプログラミング言語では、ループステートメントの一般的な形式は次のとおりです-

フローチャート

ループアーキテクチャ

Scalaプログラミング言語は、ループ要件を処理するために次のタイプのループを提供します。 表の次のリンクをクリックして、詳細を確認します。

Sr.No Loop Type & Description
1

while loop

特定の条件が真の間、ステートメントまたはステートメントのグループを繰り返します。 ループ本体を実行する前に条件をテストします。

2

do-while loop

whileステートメントと似ていますが、ループ本体の最後で条件をテストします。

3

for loop

一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。

ループ制御ステートメント

ループ制御ステートメントは、通常のシーケンスから実行を変更します。 実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。 このようなScalaは、Javaのように break または continue ステートメントをサポートしていませんが、Scalaバージョン2.8以降では、ループを解除する方法があります。 詳細を確認するには、次のリンクをクリックしてください。

Sr.No Control Statement & Description
1

break statement

  • loop* ステートメントを終了し、ループの直後のステートメントに実行を転送します。

無限ループ

条件が決して偽にならない場合、ループは無限ループになります。 Scalaを使用している場合、 while ループが無限ループを実装する最良の方法です。

次のプログラムは、無限ループを実装しています。

例

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

     //An infinite loop.
      while( true ){
         println( "Value of a: " &plus; a );
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

上記のコードを実行すると、無限ループに入り、Ctrl＆plus;を押して終了できます。 Cキー。 

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

Scala-関数

関数は、タスクを実行するステートメントのグループです。 コードを別々の機能に分割できます。 コードを異なる機能に分割する方法はユーザー次第ですが、論理的には、通常、各機能が特定のタスクを実行するように分割されます。

Scalaには関数とメソッドの両方があり、メソッドと関数という用語はわずかな違いを除いて同じ意味で使用しています。 Scalaメソッドは、名前、署名、オプションで注釈、およびバイトコードを含むクラスの一部であり、Scalaの関数として変数に割り当てることができる完全なオブジェクトです。 つまり、あるオブジェクトのメンバーとして定義されている関数は、メソッドと呼ばれます。

関数定義はソースファイルのどこにでも表示でき、Scalaはネストされた関数定義、つまり他の関数定義内の関数定義を許可します。 最も重要な注意点は、Scala関数の名前に＆plus;、＆plus;＆plus;、〜、＆、-、-、-、\、/、:などの文字を含めることができることです。

関数宣言

Scalaの関数宣言には次の形式があります- 

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

等号とメソッド本体を使用しない場合、メソッドは_abstract_として暗黙的に宣言されます。

関数定義

Scala関数の定義には次の形式があります-

構文

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

ここで、 return type は有効なScalaデータ型で、 list of parameters はコンマで区切られた変数のリストであり、パラメーターと戻り値のタイプのリストはオプションです。 Javaと非常によく似ており、関数が値を返す場合、式とともに return ステートメントを使用できます。 以下は、2つの整数を追加し、それらの合計を返す関数です-

構文

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

何も返さない関数は、Javaの void と同等の Unit を返すことができ、関数が何も返さないことを示します。 Scalaで何も返さない関数は、プロシージャと呼ばれます。

構文

ここに構文があります- 

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

関数を呼び出す

Scalaは、メソッドを呼び出すための多くの構文バリエーションを提供します。 以下は、メソッドを呼び出す標準的な方法です- 

functionName( list of parameters )

オブジェクトのインスタンスを使用して関数が呼び出されている場合、次のようにJavaに似たドット表記を使用します- 

[instance.]functionName( list of parameters )

次のプログラム例を試して、同じ関数を定義して呼び出します。

例

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " &plus; addInt(5,7) );
   }

   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a &plus; b

      return sum
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Returned Value : 12

Scala関数はScalaプログラミングの中心であり、そのためScalaは関数型プログラミング言語として想定されています。 以下は、Scalaプログラマーが理解すべきScala関数に関連する重要な概念です。

Functions Call-by-Name Functions with Named Arguments
Function with Variable Arguments Recursion Functions
Default Parameter Values Higher-Order Functions
Nested Functions Anonymous Functions
Partially Applied Functions Currying Functions

Scala-クロージャー

*closure* は関数であり、その戻り値は、この関数の外部で宣言された1つ以上の変数の値に依存します。

匿名関数を使用した次のコード。 

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

ここで、関数本体で使用される唯一の変数i* 10は、関数のパラメーターとして定義されているiです。 次のコードを試してください- 

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

乗数には、 i と factor の2つの自由変数があります。 その1つであるiは、関数の正式なパラメーターです。 したがって、乗数が呼び出されるたびに新しい値にバインドされます。 ただし、 factor は正式なパラメーターではありませんが、これは何ですか？ もう1行コードを追加しましょう。 

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

これで、 factor には、関数の外側であるが外側のスコープ内の変数への参照があります。 関数は factor を参照し、そのたびに現在の値を読み取ります。 関数に外部参照がない場合、関数はそれ自体で簡単に閉じられます。 外部コンテキストは必要ありません。

次のプログラム例を試してください。

例

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

Scala-ストリング

この章では、Scala Stringsについて説明します。 Javaのように、Scalaでは、文字列は不変オブジェクト、つまり変更できないオブジェクトです。 一方、配列などの変更可能なオブジェクトは、可変オブジェクトと呼ばれます。 文字列は非常に便利なオブジェクトです。このセクションの残りの部分では、 java.lang.String クラスの重要なメソッドを紹介します。

文字列を作成する

次のコードは、文字列を作成するために使用することができます- 

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

コンパイラは、コード内で文字列リテラルを検出するたびに、その値（この場合は「Hello world！」）でStringオブジェクトを作成します。 上記のように、代替宣言で文字列キーワードを指定することもできます。

次のプログラム例を試してください。

例

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Hello, world!

前述のように、Stringクラスは不変です。 一度作成された文字列オブジェクトは変更できません。 文字列に多くの変更を加える必要がある場合は、Scala！で利用可能な文字列ビルダークラスを使用してください。

ストリングの長さ

オブジェクトに関する情報を取得するために使用されるメソッドは、アクセサメソッドと呼ばれます。 文字列で使用できるアクセサメソッドの1つは、文字列オブジェクトに含まれる文字数を返すlength（）メソッドです。

文字列の長さを見つけるために、次のコードセグメントを使用します-

例

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

      println( "String Length is : " &plus; len );
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

String Length is : 17

文字列の連結

文字列クラスには、2つの文字列を連結するためのメソッドが含まれています- 

string1.concat(string2);

これは、最後にstring2が追加されたstring1である新しい文字列を返します。 次のように、文字列リテラルでconcat（）メソッドを使用することもできます- 

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

文字列は、一般的に＆plus;と連結されます。演算子- 

"Hello," &plus; " world" &plus; "!"

その結果- 

"Hello, world!"

文字列の長さを見つけるための次のコード行。

例

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

      println("Dot " &plus; str1 &plus; str2);
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Dot Dot saw I was Tod

フォーマット文字列の作成

フォーマットされた数値で出力を印刷するには、printf（）およびformat（）メソッドがあります。 Stringクラスには、PrintStreamオブジェクトではなくStringオブジェクトを返す同等のクラスメソッドformat（）があります。

printf（）メソッドを利用する次のサンプルプログラムを試してください-

例

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)
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

文字列補間

文字列補間は、Scalaプログラミング言語で文字列を作成する新しい方法です。 この機能は、Scala-2.10以降のバージョンをサポートしています。 文字列補間：変数文字列をプロセス文字列リテラルに直接埋め込むメカニズム。

文字列補間には、3つのタイプ（補間器）の実装があります。

「s」文字列インターポレーター

リテラル「s」を使用すると、「s」を先頭に追加するときに、文字列の処理で変数を直接使用できます。 Stringで使用できるスコープ内のString変数。 以下は、「s」文字列補間のさまざまな使用法です。

printlnステートメントで通常の文字列（Hello）に文字列変数（$ name）を追加する際の「s」補間の実装に関する次のコードスニペットの例。 

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

文字列補間は、任意の式を処理することもできます。 「s」文字列補間を使用して、任意の式（$ \ {1 + 1}）で文字列（1 + 1）を処理するための次のコードスニペット。 任意の式を「$ \ {}」に埋め込むことができます。 

println(s “1 &plus; 1 = ${1 &plus; 1}”)//output: 1 &plus; 1 = 2

「s」補間器を実装する次のプログラム例を試してください。

例

object Demo {
   def main(args: Array[String]) {
      val name = "James"

      println(s"Hello, $name")
      println(s"1 &plus; 1 = ${1 &plus; 1}")
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Hello, James
1 &plus; 1 = 2

「f」補間器

リテラル 'f’補間により、C言語のprintfに似たフォーマットされた文字列を作成できます。 「f」補間を使用している間は、すべての変数参照の後に printf スタイルの書式指定子（％d、％i、％fなど）を続ける必要があります。

浮動小数点値（高さ= 1.9d）と文字列変数（name =“ James”）を通常の文字列に追加する例を見てみましょう。 「f」インターポレーターを実装する次のコードスニペット。 ここで、印刷する$ name％s（文字列変数）Jamesと印刷する$ height％2.2f（浮動小数点値）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

タイプセーフです（つまり）変数参照と後続の書式指定子が一致する必要があります。一致しないとエラーが表示されます。 「f」補間器は、Javaで使用可能な文字列形式ユーティリティ（形式指定子）を使用します。 デフォルトでは、変数参照の後に％文字はありません。 ％s（文字列）と見なされます。

「生」補間器

「生」補間は、文字列内のリテラルのエスケープを実行しないことを除いて、「s」補間と似ています。 次の表のコードスニペットは、「s」および「raw」補間の使用法が異なります。 「s」の使用の出力では「\ n」の効果は改行として、「生」の使用の出力では「\ n」の効果はありません。 エスケープ文字を含む完全な文字列を出力します。

‘s’ interpolator usage ‘raw’ interpolator usage
  • Program *−
object Demo {
   def main(args: Array[String]) {
      println(s"Result = \n a \n b")
   }
}

a

  • プログラム*-

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

a

出力-

[source,result,notranslate] ---- Result = a b ----

a

出力-

[source,result,notranslate] ---- Result = \n a \n b ----

文字列メソッド

以下は java.lang.String クラスで定義されているメソッドのリストであり、Scalaプログラムで直接使用できます-

Sr.No Methods with Description
1

char charAt(int index)

指定されたインデックスにある文字を返します。

2

int compareTo(Object o)

この文字列を別のオブジェクトと比較します。

3

int compareTo(String anotherString)

2つの文字列を辞書式に比較します。

4

int compareToIgnoreCase(String str)

大文字と小文字の違いを無視して、2つの文字列を辞書式に比較します。

5

String concat(String str)

指定された文字列をこの文字列の末尾に連結します。

6

boolean contentEquals(StringBuffer sb)

このStringが指定されたStringBufferと同じ文字シーケンスを表す場合にのみtrueを返します。

7

static String copyValueOf(char[] data)

指定された配列内の文字シーケンスを表す文字列を返します。

8

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

指定された配列内の文字シーケンスを表す文字列を返します。

9

boolean endsWith(String suffix)

この文字列が指定されたサフィックスで終わるかどうかをテストします。

10

boolean equals(Object anObject)

この文字列を指定されたオブジェクトと比較します。

11

boolean equalsIgnoreCase(String anotherString)

この文字列を別の文字列と比較し、大文字と小文字の区別を無視します。

12

byte getBytes()

プラットフォームのデフォルトの文字セットを使用してこの文字列をバイトのシーケンスにエンコードし、結果を新しいバイト配列に格納します。

13

byte[] getBytes(String charsetName)

名前付き文字セットを使用してこの文字列をバイトのシーケンスにエンコードし、結果を新しいバイト配列に格納します。

14

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

この文字列からコピー先の文字配列に文字をコピーします。

15

int hashCode()

この文字列のハッシュコードを返します。

16

int indexOf(int ch)

この文字列内で、指定された文字が最初に現れるインデックスを返します。

17

int indexOf(int ch, int fromIndex)

この文字列内で指定された文字が最初に出現した位置のインデックスを返し、指定されたインデックスから検索を開始します。

18

int indexOf(String str)

この文字列内で、指定された部分文字列が最初に現れるインデックスを返します。

19

int indexOf(String str, int fromIndex)

指定されたインデックスで始まる、指定された部分文字列の最初の出現のこの文字列内のインデックスを返します。

20

String intern()

文字列オブジェクトの正規表現を返します。

21

int lastIndexOf(int ch)

この文字列内で、指定された文字が最後に出現するインデックスを返します。

22

int lastIndexOf(int ch, int fromIndex)

この文字列内で指定された文字の最後の出現のインデックスを返し、指定されたインデックスから逆方向に検索します。

23

int lastIndexOf(String str)

この文字列内で、指定された部分文字列の右端の出現のインデックスを返します。

24

int lastIndexOf(String str, int fromIndex)

この文字列内で、指定された部分文字列の最後の出現のインデックスを返します。指定されたインデックスから逆方向に検索します。

25

int length()

この文字列の長さを返します。

26

boolean matches(String regex)

この文字列が指定された正規表現と一致するかどうかを判断します。

27

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

2つの文字列領域が等しいかどうかをテストします。

28

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

2つの文字列領域が等しいかどうかをテストします。

29

String replace(char oldChar, char newChar)

この文字列内のすべてのoldCharをnewCharで置き換えた結果の新しい文字列を返します。

30

String replaceAll(String regex, String replacement

与えられた正規表現にマッチするこの文字列の各部分文字列を与えられた文字列に置き換えます。

31

String replaceFirst(String regex, String replacement)

指定された正規表現に一致するこの文字列の最初の部分文字列を指定された置換に置き換えます。

32

String[] split(String regex)

この文字列を、指定された正規表現の一致で分割します。

33

String[] split(String regex, int limit)

この文字列を、指定された正規表現の一致で分割します。

34

boolean startsWith(String prefix)

この文字列が指定されたプレフィックスで始まるかどうかをテストします。

35

boolean startsWith(String prefix, int toffset)

この文字列が、指定されたインデックスで始まる指定されたプレフィックスで始まるかどうかをテストします。

36

CharSequence subSequence(int beginIndex, int endIndex)

このシーケンスのサブシーケンスである新しい文字シーケンスを返します。

37

String substring(int beginIndex)

この文字列の部分文字列である新しい文字列を返します。

38

String substring(int beginIndex, int endIndex)

この文字列の部分文字列である新しい文字列を返します。

39

char[] toCharArray()

この文字列を新しい文字配列に変換します。

40

String toLowerCase()

デフォルトのロケールの規則を使用して、この文字列のすべての文字を小文字に変換します。

41

String toLowerCase(Locale locale)

指定されたロケールのルールを使用して、この文字列のすべての文字を小文字に変換します。

42

String toString()

このオブジェクト（すでに文字列です！）自体が返されます。

43

String toUpperCase()

デフォルトのロケールの規則を使用して、このストリング内のすべての文字を大文字に変換します。

44

String toUpperCase(Locale locale)

指定されたロケールのルールを使用して、この文字列のすべての文字を大文字に変換します。

45

String trim()

文字列のコピーを返します。先頭と末尾の空白は省略されます。

46

static String valueOf(primitive data type x)

渡されたデータ型引数の文字列表現を返します。

Scala-配列

Scalaには、同じタイプの要素の固定サイズの順次コレクションを格納する array というデータ構造が用意されています。 配列はデータのコレクションを格納するために使用されますが、配列を同じタイプの変数のコレクションと考える方が便利な場合がよくあります。

number0、number1、…​、number99などの個々の変数を宣言する代わりに、numbersなどの1つの配列変数を宣言し、numbers [0]、numbers [1]、…​、numbers [99]を使用して表現します個々の変数。 このチュートリアルでは、配列変数の宣言、配列の作成、およびインデックス付き変数を使用した配列の処理方法を紹介します。 配列の最初の要素のインデックスは数字のゼロであり、最後の要素のインデックスは要素の総数から1を引いたものです。

配列変数の宣言

プログラムで配列を使用するには、配列を参照する変数を宣言し、変数が参照できる配列のタイプを指定する必要があります。

以下は、配列変数を宣言するための構文です。

構文

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

or

var z = new Array[String](3)

ここで、zは、最大3つの要素を保持できる文字列の配列として宣言されます。 値は、個々の要素に割り当てるか、個々の要素にアクセスすることができます、それは次のようなコマンドを使用して行うことができます-

コマンド

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

ここで、最後の例は、一般に、インデックスは整数を生成する任意の式にできることを示しています。 配列を定義するもう1つの方法があります- 

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

次の図は、配列 myList を表しています。 ここで、 myList は10個のdouble値を保持し、インデックスは0〜9です。

スカラ配列

配列の処理

配列要素を処理するとき、配列内のすべての要素が同じ型であり、配列のサイズがわかっているため、ループ制御構造をよく使用します。

以下は、配列を作成、初期化、処理する方法を示すサンプルプログラムです-

例

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 &plus;= 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 " &plus; max);
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scalaはさまざまな配列操作を直接サポートせず、あらゆる次元で配列を処理するためのさまざまな方法を提供します。 異なる方法を使用する場合は、 Array ._ パッケージをインポートする必要があります。

多次元配列

多次元配列（つまり、要素が配列である配列）を定義して使用する必要がある多くの状況があります。 たとえば、マトリックスとテーブルは、2次元配列として実現できる構造の例です。

以下は、二次元配列を定義する例です- 

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

これは、3つの要素を持つ整数の配列である3つの要素を持つ配列です。

次のサンプルプログラムを試して、多次元配列を処理してください-

例

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(" " &plus; myMatrix(i)(j));
         }
         println();
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

0 1 2
0 1 2
0 1 2

配列の連結

concat（）メソッドを使用して2つの配列を連結する次の例を試してください。 concat（）メソッドの引数として複数の配列を渡すことができます。

例

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 )
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

範囲付きの配列を作成

range（）メソッドを使用して、指定された範囲で増加する整数のシーケンスを含む配列を生成します。 最終引数をステップとして使用して、シーケンスを作成できます。最終引数を使用しない場合、ステップは1と見なされます。

範囲（10、20、2）の配列を作成する例を見てみましょう。10〜20の要素と範囲の差2を持つ配列を作成することを意味します。 配列の要素は、10、12、14、16、および18です。

別の例：範囲（10、20）。 ここでは範囲の違いは与えられていないので、デフォルトでは1つの要素を想定しています。 範囲が1の10〜20の要素を持つ配列を作成します。 配列内の要素は、10、11、12、13、…、および19です。

次のプログラム例は、範囲を持つ配列を作成する方法を示しています。

例

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( " " &plus; x )
      }

      println()
      for ( x <- myList2 ) {
         print( " " &plus; x )
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

Scala配列メソッド

以下は重要なメソッドで、配列で遊んでいるときに使用できます。 上記のように、上記のメソッドを使用する前に Array ._ パッケージをインポートする必要があります。 利用可能なメソッドの完全なリストについては、Scalaの公式ドキュメントを確認してください。

Sr.No Methods with Description
1

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

Tオブジェクトの配列を作成します。Tは、Unit、Double、Float、Long、Int、Char、Short、Byte、Booleanです。

2

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

すべての配列を単一の配列に連結します。

3

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

ある配列を別の配列にコピーします。 JavaのSystem.arraycopy（src、srcPos、dest、destPos、length）と同等です。

4

def empty[T]: Array[T]

長さ0の配列を返します

5

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

関数の繰り返し適用を含む配列を開始値に戻します。

6

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

いくつかの要素計算の結果を複数回含む配列を返します。

7

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

いくつかの要素計算の結果を複数回含む2次元配列を返します。

8

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

関数の繰り返し適用を含む配列を開始値に戻します。

9

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

指定された次元で配列を作成します。

10

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

2次元配列を作成します

11

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

3次元配列を作成します

12

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

整数間隔で等間隔​​の値を含む配列を返します。

13

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

範囲内で増加する整数のシーケンスを含む配列を返します。

14

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

0から始まる整数値の範囲で指定された関数の値を含む配列を返します。

15

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

0から始まる整数値の範囲にわたって、指定された関数の値を含む2次元配列を返します。

Scala-コレクション

Scalaには豊富なコレクションライブラリのセットがあります。 コレクションは物のコンテナです。 これらのコンテナは、リスト、タプル、オプション、マップなどのアイテムの線形セットをシーケンスできます。 コレクションには、任意の数の要素を含めることも、0個または1個の要素にバインドすることもできます（例：Option）。

コレクションは strict または lazy である場合があります。 遅延コレクションには、 Ranges のように、アクセスされるまでメモリを消費しない要素があります。 さらに、コレクションは mutable （参照の内容が変更される可能性があります）または immutable （参照が参照するものが変更されることはありません）の場合があります。 不変のコレクションには、変更可能なアイテムが含まれることがあります。

いくつかの問題では、可変コレクションがより適切に機能し、他の問題では不変コレクションがより適切に機能します。 疑わしい場合は、不変のコレクションから始めて、変更可能なコレクションが必要な場合は後で変更することをお勧めします。

この章では、最も一般的に使用されるコレクションタイプと、それらのコレクションで最も頻繁に使用される操作について説明します。

Sr.No Collections with Description
1

Scala Lists

Scalaのリスト[T]は、タイプTのリンクリストです。

2

Scala Sets

セットは、同じタイプのペアごとに異なる要素のコレクションです。

3

Scala Maps

マップは、キー/値のペアのコレクションです。 キーに基づいて任意の値を取得できます。

4

Scala Tuples

配列やリストとは異なり、タプルは異なるタイプのオブジェクトを保持できます。

5

Scala Options

Option [T]は、指定されたタイプのゼロまたは1つの要素のコンテナを提供します。

6

Scala Iterators

イテレータはコレクションではなく、コレクションの要素に1つずつアクセスする方法です。

Scala-特性

トレイトはメソッドとフィールドの定義をカプセル化し、それらをクラスに混ぜて再利用できます。 各クラスが1つのスーパークラスのみから継承する必要があるクラス継承とは異なり、クラスは任意の数の特性を混在させることができます。

特性は、サポートされているメソッドのシグネチャを指定することにより、オブジェクトタイプを定義するために使用されます。 Scalaでは、特性を部分的に実装することもできますが、特性にはコンストラクタパラメータがない場合があります。

特性定義は、キーワード trait を使用することを除いて、クラス定義のように見えます。 以下は、特性の基本的な構文例です。

構文

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

この特性は、2つのメソッド isEqual および isNotEqual で構成されています。 ここでは、別のメソッドに実装があるisEqualの実装は提供していません。 特性を拡張する子クラスは、実装されていないメソッドの実装を提供できます。 したがって、特性は、Javaで* abstractクラス*を持っているものと非常に似ています。

特性 Equal の例に、2つのメソッド* isEqual（）および isNotEqual（）が含まれると仮定します。 特性 *Equal には、* isEqual（）という実装メソッドが1つ含まれているため、ユーザー定義クラス *Point が特性 Equal を拡張する場合、 Point クラスの* isEqual（）*メソッドへの実装を提供する必要があります。

ここでは、次の例で使用されるScalaの2つの重要なメソッドを知る必要があります。

  • obj.isInstanceOf [Point] objのTypeとPointが同じであることを確認することはできません。
  • obj.asInstanceOf [Point] は、オブジェクトobj型を取得して正確にキャストすることを意味し、Point型と同じobjを返します。

次のプログラム例を試して、特性を実装してください。

例

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))
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

true
false
true

価値クラスと普遍的特性

値クラスは、ランタイムオブジェクトの割り当てを回避するためのScalaの新しいメカニズムです。 これには、 val パラメーターが1つだけのプライマリコンストラクターが含まれます。 var、val、ネストされたクラス、特性、またはオブジェクトを許可されていないメソッド（def）のみが含まれます。 値クラスを別のクラスで拡張することはできません。 これは、AnyValで値クラスを拡張することで可能になります。 実行時のオーバーヘッドのないカスタムデータ型の型安全性。

重量、身長、電子メール、年齢などの値クラスの例を見てみましょう。 これらすべての例で、アプリケーションにメモリを割り当てる必要はありません。

特性の拡張が許可されていない値クラス。 値クラスが特性を拡張できるようにするために、 Any を拡張する universal traits が導入されています。

例

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
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Wrapperクラスのハッシュコードが表示されます。 

Wrapper@13

特性を使用する場合

確固たるルールはありませんが、考慮すべきガイドラインはほとんどありません-

  • 動作が再利用されない場合は、それを具体的なクラスにします。 結局、再利用可能な振る舞いではありません。
  • 無関係な複数のクラスで再利用される可能性がある場合は、それを特性にします。 特性だけがクラス階層の異なる部分に混在することができます。
  • Javaコードで*継承*する場合は、抽象クラスを使用します。
  • コンパイルされた形式で配布する予定で、外部のグループがそれを継承するクラスを作成することを期待する場合は、抽象クラスを使用することをお勧めします。
  • 効率が非常に重要な場合は、クラスを使用するようにしてください。

Scala-パターンマッチング

パターンマッチングは、関数値とクロージャに次いで、Scalaで2番目に広く使用されている機能です。 Scalaは、メッセージの処理において、パターンマッチングの優れたサポートを提供します。

パターンマッチには、キーワード case で始まる一連の選択肢が含まれます。 それぞれの選択肢には*パターン*と1つ以上の*式*が含まれ、パターンが一致した場合に評価されます。 矢印記号⇒は、パターンを式から分離します。

次のサンプルプログラムを試してください。これは、整数値と照合する方法を示しています。

例

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"
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

many

caseステートメントを含むブロックは、整数を文字列にマップする関数を定義します。 matchキーワードは、関数（上記のパターンマッチング関数など）をオブジェクトに適用する便利な方法を提供します。

異なるタイプのパターンに対して値を照合する次のプログラム例を試してください。

例

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"
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

2
many
one

ケースクラスを使用したマッチング

  • caseクラス*は、case式とのパターンマッチングで使用される特別なクラスです。 構文的には、これらは特別な修飾子を持つ標準クラスです：ケース。

以下を試してください。これは、ケースクラスを使用した単純なパターンマッチングの例です。

例

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: " &plus; age &plus; " year, name: " &plus; name &plus; "?")
         }
      }
   }
   case class Person(name: String, age: Int)
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

caseキーワードを追加すると、コンパイラーは多くの便利な機能を自動的に追加します。 このキーワードは、パターンマッチングにおけるケース式との関連付けを示唆しています。

まず、コンパイラーはコンストラクター引数を不変フィールド（vals）に自動的に変換します。 valキーワードはオプションです。 可変フィールドが必要な場合は、varキーワードを使用します。 したがって、コンストラクター引数リストはより短くなりました。

第二に、コンパイラは、コンストラクタ引数として指定されたフィールドを使用する* equals、hashCode、および *toString メソッドをクラスに自動的に実装します。 したがって、独自のtoString（）メソッドは必要なくなりました。

最後に、定義する必要のあるメソッドがないため、 Person クラスの本体も空になります！

Scala-正規表現

この章では、scala.util.matchingパッケージで利用可能な Regex クラスを介してScalaが正規表現をサポートする方法について説明します。

次のサンプルプログラムを試してみてください。ステートメントから単語 Scala を見つけようとします。

例

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)
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Some(Scala)

文字列を作成し、その上で* r（）メソッドを呼び出します。 Scalaは暗黙的にStringをRichStringに変換し、そのメソッドを呼び出してRegexのインスタンスを取得します。 正規表現の最初の一致を見つけるには、単に findFirstIn（）メソッドを呼び出します。 最初の出現のみを見つけるのではなく、一致する単語のすべての出現を検索する場合は、 findAllIn（）*メソッドを使用できます。ターゲット文字列に複数のScala単語がある場合、これは一致するすべての単語。

mkString（）メソッドを使用して結果のリストを連結し、パイプ（|）を使用してScalaの大文字小文字を検索し、代わりに Regex コンストラクターまたは* r（）*メソッドを使用して作成できます。模様。

次のプログラム例を試してください。

例

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(","))
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Scala,scala

一致するテキストを置換する場合、* replaceFirstIn（）を使用して最初の一致を置換するか、 replaceAllIn（）*を使用してすべての出現箇所を置換できます。

例

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"))
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Java is scalable and cool

正規表現の形成

ScalaはJavaから正規表現構文を継承し、JavaはPerlのほとんどの機能を継承します。 ここでは、復習として十分ないくつかの例を示します-

以下は、Javaで使用可能なすべての正規表現メタ文字構文をリストした表です。

Subexpression Matches
^ Matches beginning of line.
$ Matches end of line.
. Matches any single character except newline. Using m option allows it to match newline as well.
[…​] Matches any single character in brackets.
[^…​] Matches any single character not in brackets
\\A Beginning of entire string
\\z End of entire string
\\Z End of entire string except allowable final line terminator.
re* Matches 0 or more occurrences of preceding expression.
rePLUS Matches 1 or more of the previous thing
re? Matches 0 or 1 occurrence of preceding expression.
re\{ n} Matches exactly n number of occurrences of preceding expression.
re\{ n,} Matches n or more occurrences of preceding expression.
re\{ n, m} Matches at least n and at most m occurrences of preceding expression.
a b
Matches either a or b. (re)
Groups regular expressions and remembers matched text. (?: re)
Groups regular expressions without remembering matched text. (?> re)
Matches independent pattern without backtracking. \\w
Matches word characters. \\W
Matches nonword characters. \\s
Matches whitespace. Equivalent to [\t\n\r\f]. \\S
Matches nonwhitespace. \\d
Matches digits. Equivalent to [0-9]. \\D
Matches nondigits. \\A
Matches beginning of string. \\Z
Matches end of string. If a newline exists, it matches just before newline. \\z
Matches end of string. \\G
Matches point where last match finished. \\n
Back-reference to capture group number "n" \\b
Matches word boundaries when outside brackets. Matches backspace (0x08) when inside brackets. \\B
Matches nonword boundaries. \\n, \\t, etc.
Matches newlines, carriage returns, tabs, etc. \\Q
Escape (quote) all characters up to \\E \\E

正規表現の例

Example Description
. Match any character except newline
[Rr]uby Match "Ruby" or "ruby"
rub[ye] Match "ruby" or "rube"
[aeiou] Match any one lowercase vowel
[0-9] Match any digit; same as [0123456789]
[a-z] Match any lowercase ASCII letter
[A-Z] Match any uppercase ASCII letter
[a-zA-Z0-9] Match any of the above
[^aeiou] Match anything other than a lowercase vowel
[^0-9] Match anything other than a digit
\\d Match a digit: [0-9]
\\D Match a nondigit: [^0-9]
\\s Match a whitespace character: [ \t\r\n\f]
\\S Match nonwhitespace: [^ \t\r\n\f]
\\w Match a single word character: [A-Za-z0-9_]
\\W Match a nonword character: [^A-Za-z0-9_]
ruby? Match "rub" or "ruby": the y is optional
ruby* Match "rub" plus 0 or more ys
rubyPLUS Match "rub" plus 1 or more ys
\\d{3} Match exactly 3 digits
\\d\{3,} Match 3 or more digits
\\d\{3,5} Match 3, 4, or 5 digits
\\D\\dPLUS No group: PLUS repeats \\d
(\\D\\d)PLUS/ Grouped: PLUS repeats \\D\d pair
([Rr]uby(, )?)PLUS Match "Ruby", "Ruby, ruby, ruby", etc.

注意-上記の文字列では、すべてのバックスラッシュが2回出現します。 これは、JavaおよびScalaでは、単一のバックスラッシュが文字列リテラルのエスケープ文字であり、文字列に現れる通常の文字ではないためです。 そのため、「\」の代わりに「\\」と記述して、文字列に単一のバックスラッシュを追加する必要があります。

次のプログラム例を試してください。

例

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("abl[ae]\\d&plus;")
      val str = "ablaw is able1 and cool"

      println((pattern findAllIn str).mkString(","))
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

able1

Scala-例外処理

Scalaの例外は、Javaのような他の多くの言語の例外のように機能します。 通常の方法で値を返す代わりに、メソッドは例外をスローして終了できます。 ただし、Scalaには実際にチェック例外はありません。

例外を処理する場合、Javaの場合と同様にtry \ {…​} catch \ {…​}ブロックを使用しますが、catchブロックはマッチングを使用して例外を識別および処理します。

例外を投げる

例外のスローは、Javaの場合と同じです。 例外オブジェクトを作成し、次のように throw キーワードでスローします。 

throw new IllegalArgumentException

例外をキャッチする

Scalaでは、1つのブロックで例外を try/catch し、 case ブロックを使用してパターンマッチングを実行できます。 次のサンプルプログラムを試して、例外を処理してください。

例

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")
         }
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Missing file exception

この try-catch 式の動作は、例外を除いて他の言語と同じです。 本体が実行され、例外がスローされると、各 catch 句が順番に試行されます。

最終節

式の終了方法に関係なくコードを実行する場合は、 finally 句で式をラップできます。 次のプログラムを試してください。

例

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...")
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Missing file exception
Exiting finally...

Scala-エクストラクター

Scalaのエクストラクターは、メンバーの1つとして unapply というメソッドを持つオブジェクトです。 この適用解除メソッドの目的は、値を一致させて分解することです。 多くの場合、extractorオブジェクトは、値を構築するためのデュアルメソッド apply も定義しますが、これは必須ではありません。

例

*apply* メソッドと *unapply* メソッドの両方を定義するオブジェクトの例を見てみましょう。 applyメソッドはいつもと同じ意味を持ちます：Testを、メソッドが適用されるのと同じ方法で括弧内の引数に適用できるオブジェクトに変えます。 したがって、Test（ "Zara"、 "gmail.com"）を記述して、文字列 "[email protected]"を作成できます。
*unapply* メソッドは、Testクラスを *extractor* に変換し、 *apply* の構築プロセスを逆にします。 applyが2つの文字列を受け取り、それらから電子メールアドレス文字列を形成する場合、unapplyは電子メールアドレスを受け取り、潜在的に2つの文字列を返します。アドレスの *user* と *domain* です。
*unapply* は、指定された文字列が電子メールアドレスではない場合も処理する必要があります。 これが、unapplyが文字列のペアに対してOption型を返す理由です。 結果は、文字列strが指定されたユーザーとドメイン部分を持つ電子メールアドレスである場合は* Some（user、domain）*、strが電子メールアドレスでない場合はNoneです。 以下に例を示します。

構文

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

次のプログラム例は、電子メールアドレスの抽出オブジェクトを示しています。

例

object Demo {
   def main(args: Array[String]) {
      println ("Apply method : " &plus; apply("Zara", "gmail.com"));
      println ("Unapply method : " &plus; unapply("[email protected]"));
      println ("Unapply method : " &plus; unapply("Zara Ali"));
   }

  //The injection method (optional)
   def apply(user: String, domain: String) = {
      user &plus;"@"&plus; 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
      }
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

エクストラクタを使用したパターンマッチング

クラスのインスタンスの後に、ゼロ個以上のパラメーターのリストを含む括弧が続く場合、コンパイラーはそのインスタンスで apply メソッドを呼び出します。 オブジェクトとクラスの両方で適用を定義できます。

上記のように、 unapply メソッドの目的は、探している特定の値を抽出することです。 apply とは逆の操作を行います。 match ステートメントを使用して抽出オブジェクトを比較すると、 unapply メソッドが自動的に実行されます。

次のプログラム例を試してください。

例

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

      x match {
         case Demo(num) => println(x&plus;" is bigger two times than "&plus;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
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

10
10 is bigger two times than 5

Scala-ファイルI/O

Scalaは任意のJavaオブジェクトを使用するために開かれており、 java.io.File はScalaプログラミングでファイルの読み取りおよび書き込みに使用できるオブジェクトの1つです。

以下は、ファイルに書き込むためのプログラム例です。

例

import java.io._

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

プログラムが置かれている現在のディレクトリに Demo.txt という名前のファイルを作成します。 以下はそのファイルの内容です。

出力

Hello Scala

コマンドラインから行を読む

画面からユーザー入力を読み取って、さらに処理を進める必要がある場合があります。 次のサンプルプログラムは、コマンドラインから入力を読み取る方法を示しています。

例

object Demo {
   def main(args: Array[String]) {
      print("Please enter your input : " )
      val line = Console.readLine

      println("Thanks, you just typed: " &plus; line)
   }
}

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

ファイルコンテンツの読み取り

ファイルからの読み取りは本当に簡単です。 Scalaの Source クラスとそのコンパニオンオブジェクトを使用して、ファイルを読み取ることができます。 以下は、以前に作成した "Demo.txt" ファイルから読み取る方法を示す例です。

例

import scala.io.Source

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

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

上記のプログラムを Demo.scala に保存します。 このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Following is the content read:
Hello Scala
「https://www.finddevguides.com/index.php?title=Scala-quick-guide&oldid=79343」から取得
Powered by MediaWiki