Scalaコレクション-クイックガイド

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

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

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

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

シニア番号	説明付きのコレクション
1	Scala Lists ScalaのList [T]は、タイプTのリンクリストです。
2	Scala Sets セットは、同じタイプのペアごとに異なる要素のコレクションです。
3	Scala Maps マップは、キーと値のペアのコレクションです。キーに基づいて任意の値を取得できます。
4	Scala Tuples 配列やリストとは異なり、タプルはさまざまなタイプのオブジェクトを保持できます。
5	Scala Options Option [T]は、特定のタイプの0個または1個の要素のコンテナーを提供します。
6	Scala Iterators イテレータはコレクションではなく、コレクションの要素に1つずつアクセスする方法です。

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

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

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

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

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

プラットホーム	コマンド	サンプル出力
ウィンドウズ	コマンドコンソールを開き、「-」と入力します。 \>java -version	Javaバージョン「1.8.0_31」 Java（TM）SEランタイム 環境（ビルド1.8.0_31-b31） Java Hotspot（TM）64ビットサーバー VM（ビルド25.31-b07、混合モード）
Linux	コマンドターミナルを開き、「-」と入力します。 $java -version	Javaバージョン「1.8.0_31」 JDKランタイム環境を開きます（rhel-2.8.10.4.el6_4-x86_64） JDK 64ビットサーバーVMを開きます（ビルド25.31-b07、混合モード）

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

Java SDKをお持ちでない場合は、現在のバージョンをからダウンロードしてください。 https://www.oracle.com/technetwork/java/javase/downloads/index.html そしてそれをインストールします。

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

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

シニア番号	プラットフォームと説明
1	Windows JAVA_HOMEをC：\ ProgramFiles \ java \ jdk1.8.0_31に設定します
2	Linux JAVA_HOME = / usr / local / java-currentをエクスポートします

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

シニア番号	プラットフォームと説明
1	Windows 文字列「C：\ ProgramFiles \ Java \ jdk1.8.0_31 \ bin」をシステム変数PATHの最後に追加します。
2	Linux PATH = $ PATH：$ JAVA_HOME / bin /をエクスポートします

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

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

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

プラットホーム	コマンドと出力	説明
ウィンドウズ	\> java -jar scala-2.13.1-installer.jar \>	このコマンドは、WindowsマシンにScalaをインストールするためのガイドとなるインストールウィザードを表示します。インストール中に、使用許諾契約を要求し、それを受け入れるだけで、さらにScalaがインストールされるパスを要求します。デフォルトのパス「C：\ ProgramFiles \ Scala」を選択しましたが、都合に合わせて適切なパスを選択できます。
Linux	Command − $ java -jarscala-2.13.1-installer.jar Output − Scala 2.13.1のインストールへようこそ！ ホームページは−にあります http://Scala-lang.org/ 1を押して続行、2を押して終了、3を押して再表示します 1................................................。 [開梱を開始] [処理パッケージ：ソフトウェアパッケージのインストール（1/1）] 【開梱終了】 [コンソールのインストールが完了しました]	インストール中に、使用許諾契約を要求し、タイプ1を受け入れ、Scalaをインストールするパスを要求します。私は、入力されたは/ usr / local /シェア、あなたの利便性に従って、適切なパスを選択することができます。

最後に、新しいコマンドプロンプトを開き、次のように入力します Scala -versionEnterキーを押します。次のように表示されます-

プラットホーム	コマンド	出力
ウィンドウズ	\> scalaバージョン	Scalaコードランナーバージョン2.13.1-Copyright2002-2019、LAMP / EPFL and Lightbend、Inc。
Linux	$ scalaバージョン	Scalaコードランナーバージョン2.13.1-Copyright2002-2019、LAMP / EPFL and Lightbend、Inc.tut

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

number0、number1、...、number99などの個々の変数を宣言する代わりに、numbersなどの1つの配列変数を宣言し、numbers [0]、numbers [1]、...、numbers [99]を使用して表現します。個々の変数。このチュートリアルでは、インデックス付き変数を使用して、配列変数を宣言し、配列を作成し、配列を処理する方法を紹介します。配列の最初の要素のインデックスは数値0であり、最後の要素のインデックスは要素の総数から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 += 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);
   }
}

上記のプログラムをに保存します 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次元配列として実現できる構造の例です。

以下は、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(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

0 1 2
0 1 2
0 1 2

range（）メソッドを使用して、指定された範囲で増加する整数のシーケンスを含む配列を生成します。シーケンスを作成するためのステップとしてfinal引数を使用できます。最終引数を使用しない場合、ステップは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( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

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

Scalaはデータ構造を提供します ArrayBuffer、初期サイズが不足するとサイズが変わる可能性があります。配列は固定サイズであり、配列内でそれ以上の要素を占有できないため、ArrayBufferはサイズが柔軟な配列の代替手段です。

内部的にArrayBufferは、要素を格納するために現在のサイズの配列を維持します。新しい要素が追加されると、サイズがチェックされます。基になる配列がいっぱいの場合、新しい大きな配列が作成され、すべての要素が大きな配列にコピーされます。

ArrayBuffer変数の宣言

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

構文

var z = ArrayBuffer[String]()

ここで、zは、最初は空の文字列の配列バッファとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

z += "Zara";
z += "Nuha";
z += "Ayan";

ArrayBufferの処理

以下は、ArrayBufferを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.mutable.ArrayBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ArrayBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

ArrayBuffer(Zara, Nuha, Ayan)
ArrayBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

Scalaリストは配列と非常によく似ています。つまり、リストのすべての要素は同じタイプですが、2つの重要な違いがあります。まず、リストは不変です。つまり、リストの要素を割り当てによって変更することはできません。次に、リストはリンクリストを表しますが、配列はフラットです。

タイプTの要素を持つリストのタイプは、次のように記述されます。 List[T]。

次の例を試してください。さまざまなデータ型に対して定義されたリストをいくつか示します。

// List of Strings
val fruit: List[String] = List("apples", "oranges", "pears")
// List of Integers
val nums: List[Int] = List(1, 2, 3, 4)
// Empty List.
val empty: List[Nothing] = List()
// Two dimensional list
val dim: List[List[Int]] = List(
   List(1, 0, 0),
   List(0, 1, 0),
   List(0, 0, 1)
)

すべてのリストは、2つの基本的な構成要素であるテールを使用して定義できます。 Nil そして ::、発音されます cons。Nilは、空のリストも表します。上記のリストはすべて、次のように定義できます。

// List of Strings
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
// List of Integers
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// Empty List.
val empty = Nil
// Two dimensional list
val dim = (1 :: (0 :: (0 :: Nil))) ::
   (0 :: (1 :: (0 :: Nil))) ::
   (0 :: (0 :: (1 :: Nil))) :: Nil

リストの基本操作

リストに対するすべての操作は、次の3つの方法で表すことができます。

シニア番号	方法と説明
1	head このメソッドは、リストの最初の要素を返します。
2	tail このメソッドは、最初の要素を除くすべての要素で構成されるリストを返します。
3	isEmpty このメソッドは、リストが空の場合はtrueを返し、それ以外の場合はfalseを返します。

次の例は、上記の方法の使用方法を示しています。

例

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      val nums = Nil
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

リストの連結

どちらでも使用できます ::: 演算子または List.:::() メソッドまたは List.concat()2つ以上のリストを追加する方法。以下の例を見つけてください-

例

object Demo {
   def main(args: Array[String]) {
      val fruit1 = "apples" :: ("oranges" :: ("pears" :: Nil))
      val fruit2 = "mangoes" :: ("banana" :: Nil)
      // use two or more lists with ::: operator
      var fruit = fruit1 ::: fruit2
      println( "fruit1 ::: fruit2 : " + fruit )
      // use two lists with Set.:::() method
      fruit = fruit1.:::(fruit2)
      println( "fruit1.:::(fruit2) : " + fruit )
      // pass two or more lists as arguments
      fruit = List.concat(fruit1, fruit2)
      println( "List.concat(fruit1, fruit2) : " + fruit  )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

fruit1 ::: fruit2 : List(apples, oranges, pears, mangoes, banana)
fruit1.:::(fruit2) : List(mangoes, banana, apples, oranges, pears)
List.concat(fruit1, fruit2) : List(apples, oranges, pears, mangoes, banana)

統一リストの作成

使用できます List.fill()メソッドは、同じ要素の0個以上のコピーで構成されるリストを作成します。次のサンプルプログラムを試してください。

例

object Demo {
   def main(args: Array[String]) {
      val fruit = List.fill(3)("apples") // Repeats apples three times.
      println( "fruit : " + fruit  )
      val num = List.fill(10)(2)         // Repeats 2, 10 times.
      println( "num : " + num  )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

fruit : List(apples, apples, apples)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)

関数の表

と一緒に機能を使用することができます List.tabulate()リストを集計する前に、リストのすべての要素に適用するメソッド。その引数はList.fillの引数と同じです。最初の引数リストは作成するリストの次元を示し、2番目の引数リストはリストの要素を記述します。唯一の違いは、要素が固定される代わりに、関数から計算されることです。

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

例

object Demo {
   def main(args: Array[String]) {
      // Creates 5 elements using the given function.
      val squares = List.tabulate(6)(n => n * n)
      println( "squares : " + squares  )
      val mul = List.tabulate( 4,5 )( _ * _ )      
      println( "mul : " + mul  )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

squares : List(0, 1, 4, 9, 16, 25)
mul : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), 
   List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))

リストの順序を逆にする

使用できます List.reverseリストのすべての要素を逆にするメソッド。次の例は、使用法を示しています。

例

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      println( "Before reverse fruit : " + fruit )
      println( "After reverse fruit : " + fruit.reverse )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Before reverse fruit : List(apples, oranges, pears)
After reverse fruit : List(pears, oranges, apples)

Scalaはデータ構造を提供します ListBuffer、リスト内の要素を追加/削除する際に、リストよりも効率的です。リストに要素を追加、追加するメソッドを提供します。

ListBuffer変数の宣言

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

構文

var z = ListBuffer[String]()

ここで、zは、最初は空の文字列のリストバッファとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

z += "Zara";
z += "Nuha";
z += "Ayan";

ListBufferを処理しています

以下は、ListBufferを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.mutable.ListBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ListBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

ListBuffer(Zara, Nuha, Ayan)
ListBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

Scala Setは、同じタイプのペアごとに異なる要素のコレクションです。つまり、セットは重複する要素を含まないコレクションです。ListSetは不変のセットを実装し、リスト構造を使用します。要素の挿入順序は、要素の保存中に保持されます。

ListSet変数の宣言

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

構文

var z : ListSet[String] = ListSet("Zara","Nuha","Ayan")

ここで、zは、3つのメンバーを持つ文字列のリストセットとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myList1: ListSet[String] = myList + "Naira";

ListSetを処理しています

以下は、ListSetを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.ListSet
object Demo {
   def main(args: Array[String]) = {
      var myList: ListSet[String] = ListSet("Zara","Nuha","Ayan");
      // Add an element
      var myList1: ListSet[String] = myList + "Naira";
      // Remove an element
      var myList2: ListSet[String] = myList - "Nuha";
      // Create empty set
      var myList3: ListSet[String] = ListSet.empty[String];
      println(myList);
      println(myList1);
      println(myList2);
      println(myList3);	  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

ListSet(Zara, Nuha, Ayan)
ListSet(Zara, Nuha, Ayan, Naira)
ListSet(Zara, Ayan)
ListSet()

Scala Vectorは、要素にランダムにアクセスできる汎用の不変データ構造です。これは通常、大量のデータ収集に使用されます。

ベクトル変数の宣言

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

構文

var z : Vector[String] = Vector("Zara","Nuha","Ayan")

ここで、zは、3つのメンバーを持つ文字列のベクトルとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var vector1: Vector[String] = z + "Naira";

ベクトルの処理

以下は、Vector-を作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.Vector
object Demo {
   def main(args: Array[String]) = {
      var vector: Vector[String] = Vector("Zara","Nuha","Ayan");
      // Add an element
      var vector1: Vector[String] = vector :+ "Naira";
      // Reverse an element
      var vector2: Vector[String] = vector.reverse;
      // sort a vector
      var vector3: Vector[String] = vector1.sorted;
      println(vector);
      println(vector1);
      println(vector2);
      println(vector3);	  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Vector(Zara, Nuha, Ayan)
Vector(Zara, Nuha, Ayan, Naira)
Vector(Ayan, Nuha, Zara)
Vector(Ayan, Naira, Nuha, Zara)

Scala Setは、同じタイプのペアごとに異なる要素のコレクションです。つまり、セットは重複する要素を含まないコレクションです。セットには2種類あります。immutable そしてその mutable。可変オブジェクトと不変オブジェクトの違いは、オブジェクトが不変の場合、オブジェクト自体を変更できないことです。

デフォルトでは、Scalaは不変のセットを使用します。可変セットを使用する場合は、インポートする必要がありますscala.collection.mutable.Set明示的にクラス。同じコレクションで可変セットと不変セットの両方を使用する場合は、引き続き不変セットを次のように参照できます。Set ただし、可変セットは次のように参照できます。 mutable.Set。

不変セットを宣言する方法は次のとおりです-

構文

// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(1,3,5,7)

or 

var s = Set(1,3,5,7)

空のセットを定義するとき、システムは具体的な型を変数に割り当てる必要があるため、型の注釈が必要です。

セットでの基本操作

セットに対するすべての操作は、次の3つの方法で表すことができます。

シニア番号	方法と説明
1	head このメソッドは、セットの最初の要素を返します。
2	tail このメソッドは、最初の要素を除くすべての要素で構成されるセットを返します。
3	isEmpty このメソッドは、セットが空の場合はtrueを返し、それ以外の場合はfalseを返します。

基本的な操作方法の使用法を示す次の例を試してください-

例

object Demo {
   def main(args: Array[String]) {
      val fruit = Set("apples", "oranges", "pears")
      val nums: Set[Int] = Set()
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

セットの連結

どちらでも使用できます ++ 演算子または Set.++() 2つ以上のセットを連結するメソッドですが、セットを追加すると、重複する要素が削除されます。

以下は、2つのセットを連結する例です。

例

object Demo {
   def main(args: Array[String]) {
      val fruit1 = Set("apples", "oranges", "pears")
      val fruit2 = Set("mangoes", "banana")
      // use two or more sets with ++ as operator
      var fruit = fruit1 ++ fruit2
      println( "fruit1 ++ fruit2 : " + fruit )
      // use two sets with ++ as method
      fruit = fruit1.++(fruit2)
      println( "fruit1.++(fruit2) : " + fruit )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)

セット内の最大要素と最小要素を検索

使用できます Set.min 最小値を見つける方法と Set.maxセットで使用可能な要素の最大値を見つける方法。以下は、プログラムを示す例です。

例

object Demo {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)
      // find min and max of the elements
      println( "Min element in Set(5,6,9,20,30,45) : " + num.min )
      println( "Max element in Set(5,6,9,20,30,45) : " + num.max )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Min element in Set(5,6,9,20,30,45) : 5
Max element in Set(5,6,9,20,30,45) : 45

共通の値のインセットを見つける

どちらでも使用できます Set.& メソッドまたは Set.intersect2つのセット間の共通の値を見つける方法。次の例を試して、使用法を示してください。

例

object Demo {
   def main(args: Array[String]) {
      val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)
      // find common elements between two sets
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)

ビットセットは、可変および不変ビットセットの共通基本クラスです。ビットセットは非負の整数のセットであり、64ビットワードにパックされたビットの可変サイズ配列として表されます。ビットセットのメモリフットプリントは、ビットセットに格納されている最大数で表されます。

BitSet変数の宣言

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

構文

var z : BitSet = BitSet(0,1,2)

ここで、zは、3つのメンバーを持つ非負の整数のビットセットとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myList1: BitSet = myList + 3;

BitSetの処理

以下は、BitSetを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.BitSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: BitSet = BitSet(0, 1, 2);
      // Add an element
      var mySet1: BitSet = mySet + 3;
      // Remove an element
      var mySet2: BitSet = mySet - 2;
      var mySet3: BitSet = BitSet(4, 5);
      // Adding sets
      var mySet4: BitSet = mySet1 ++ mySet3;
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet4);	  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

BitSet(0, 1, 2)
BitSet(0, 1, 2, 3)
BitSet(0, 1)
BitSet(0, 1, 2, 3, 4, 5)

Scala Setは、同じタイプのペアごとに異なる要素のコレクションです。つまり、セットは重複する要素を含まないコレクションです。HashSetは不変のセットを実装し、ハッシュテーブルを使用します。要素の挿入順序は保持されません。

HashSet変数の宣言

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

構文

var z : HashSet[String] = HashSet("Zara","Nuha","Ayan")

ここで、zは、3つのメンバーを持つ文字列のハッシュセットとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myList1: HashSet[String] = myList + "Naira";

HashSetの処理

以下は、HashSetを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.HashSet
object Demo {
   def main(args: Array[String]) = {
      var mySet: HashSet[String] = HashSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: HashSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: HashSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: HashSet[String] = HashSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

HashSet(Zara, Nuha, Ayan)
HashSet(Zara, Nuha, Ayan, Naira)
HashSet(Zara, Ayan)
HashSet()

Scala Setは、同じタイプのペアごとに異なる要素のコレクションです。つまり、セットは重複する要素を含まないコレクションです。TreeSetは不変のセットを実装し、要素をソートされた順序で保持します。

TreeSet変数の宣言

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

構文

var z : TreeSet[String] = TreeSet("Zara","Nuha","Ayan")

ここで、zは、3つのメンバーを持つ文字列のツリーセットとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myList1: TreeSet[String] = myList + "Naira";

TreeSetの処理

以下は、TreeSetを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.TreeSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: TreeSet[String] = TreeSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: TreeSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: TreeSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: TreeSet[String] = TreeSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

TreeSet(Ayan, Nuha, Zara)
TreeSet(Ayan, Naira, Nuha, Zara)
TreeSet(Ayan, Zara)
TreeSet()

Scalaマップは、キーと値のペアのコレクションです。キーに基づいて任意の値を取得できます。キーはマップ内で一意ですが、値は一意である必要はありません。マップはハッシュテーブルとも呼ばれます。マップには2種類あります。immutable そしてその mutable。可変オブジェクトと不変オブジェクトの違いは、オブジェクトが不変の場合、オブジェクト自体を変更できないことです。

デフォルトでは、Scalaは不変のマップを使用します。可変マップを使用する場合は、インポートする必要がありますscala.collection.mutable.Map明示的にクラス。可変マップと不変マップの両方を同じように使用する場合は、引き続き不変マップを次のように参照できます。Map ただし、可変セットは次のように参照できます。 mutable.Map。

以下は、不変のマップを宣言するステートメントの例です-

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

空のマップを定義する際、システムは具体的な型を変数に割り当てる必要があるため、型の注釈が必要です。キーと値のペアをマップに追加する場合は、次のように演算子+を使用できます。

A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)

MAPの基本操作

マップ上のすべての操作は、次の3つの方法で表すことができます。

シニア番号	方法と説明
1	keys このメソッドは、マップ内の各キーを含むイテラブルを返します。
2	values このメソッドは、マップ内の各値を含むiterableを返します。
3	isEmpty このメソッドは、マップが空の場合はtrueを返し、それ以外の場合はfalseを返します。

Mapメソッドの使用法を示す次のサンプルプログラムを試してください。

例

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val nums: Map[Int, Int] = Map()
      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

マップの連結

どちらでも使用できます ++ 演算子または Map.++() 2つ以上のマップを連結する方法ですが、マップを追加すると、重複するキーが削除されます。

次のサンプルプログラムを試して、2つのマップを連結します。

例

object Demo {
   def main(args: Array[String]) {
      val colors1 = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val colors2 = Map(
         "blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000"
      )
      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )
      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

マップからキーと値を印刷する

「foreach」ループを使用して、マップのキーと値を反復処理できます。ここでは、方法を使用しましたforeachキーをウォークスルーするイテレータに関連付けられています。以下はサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{
         i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )
      }
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

マップでキーを確認します

どちらでも使用できます Map.contains特定のキーがマップに存在するかどうかをテストするメソッド。次のサンプルプログラムを試して、キーチェックを行ってください。

例

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
         println("Red key does not exist")
      }
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Red key exists with value :#FF0000
Maroon key does not exist

Scalaマップは、キーと値のペアのコレクションです。キーに基づいて任意の値を取得できます。キーはマップ内で一意ですが、値は一意である必要はありません。HashMapは不変のマップを実装し、ハッシュテーブルを使用して同じものを実装します。

HashMap変数の宣言

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

構文

val colors = HashMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

ここで、colorsは、3つのキーと値のペアを持つStrings、Intのハッシュマップとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myMap1: HashMap[Char, Int] = colors + ("black" -> "#000000");

HashMapの処理

以下は、HashMapを作成、初期化、および処理する方法を示すプログラムの例です。

例

import scala.collection.immutable.HashMap
object Demo {
   def main(args: Array[String]) = {
      var myMap: HashMap[String,String] = HashMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: HashMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) )
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: HashMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: HashMap[String,String] = HashMap.empty[String, String];
      println(myMap1);
      println(myMap2);
      println(myMap3);		  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Key = red Value = #FF0000
Red key exists with value :#FF0000
Maroon key does not exist
HashMap(azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF, red -> #FF0000)
HashMap(azure -> #F0FFFF, peru -> #CD853F, red -> #FF0000)
HashMap()

Scalaマップは、キーと値のペアのコレクションです。キーに基づいて任意の値を取得できます。キーはマップ内で一意ですが、値は一意である必要はありません。ListMapは不変のマップを実装し、listを使用して同じものを実装します。少数の要素で使用されます。

ListMap変数の宣言

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

構文

val colors = ListMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

ここで、colorsは、3つのキーと値のペアを持つStrings、Intのハッシュマップとして宣言されています。次のようなコマンドを使用して値を追加できます-

コマンド

var myMap1: ListMap[Char, Int] = colors + ("black" -> "#000000");

ListMapの処理

以下は、ListMapを作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.ListMap

object Demo {
   def main(args: Array[String]) = {
      var myMap: ListMap[String,String] = ListMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: ListMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) ) 
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: ListMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: ListMap[String,String] = ListMap.empty[String, String];
      println(myMap1);
      println(myMap2);	
      println(myMap3);		  
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Red key exists with value :#FF0000
Maroon key does not exist
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF)
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F)
ListMap()

イテレータはコレクションではなく、コレクションの要素に1つずつアクセスする方法です。上の2つの基本的な操作iterator it です next そして hasNext。への呼び出しit.next()イテレータの次の要素を返し、イテレータの状態を進めます。Iteratorを使用して、返す要素が他にもあるかどうかを確認できます。it.hasNext 方法。

イテレータによって返されるすべての要素を「ステップスルー」する最も簡単な方法は、whileループを使用することです。次のサンプルプログラムに従ってみましょう。

例

object Demo {
   def main(args: Array[String]) {
      val it = Iterator("a", "number", "of", "words")
      while (it.hasNext){
         println(it.next())
      }
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

a
number
of
words

最小値と最大値の要素を見つける

使用できます it.min そして it.maxイテレータから最小値と最大値の要素を見つけるメソッド。ここでは、ita そして itbイテレータは1回しかトラバースできないため、2つの異なる操作を実行します。以下はサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Maximum valued element " + ita.max )
      println("Minimum valued element " + itb.min )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Maximum valued element 90
Minimum valued element 2

イテレータの長さを見つける

どちらでも使用できます it.size または it.lengthイテレータで使用可能な要素の数を見つける方法。ここでは、イテレータは1回しかトラバースできないため、itaとitbを使用して2つの異なる操作を実行しました。以下はサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Value of ita.size : " + ita.size )
      println("Value of itb.length : " + itb.length )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Value of ita.size : 6
Value of itb.length : 6

Scala Option [T]は、特定のタイプの0個または1個の要素のコンテナーです。Option [T]は次のいずれかになりますSome[T] または None欠落している値を表すオブジェクト。たとえば、Scalaのマップのgetメソッドは、特定のキーに対応する値が見つかった場合、Some（value）を生成します。None 指定されたキーがマップで定義されていない場合。

オプションタイプはScalaプログラムで頻繁に使用され、これを null値がないことを示すJavaで使用可能な値。たとえば、java.util.HashMapのgetメソッドは、HashMapに格納されている値を返すか、値が見つからなかった場合はnullを返します。

主キーに基づいてデータベースからレコードを取得するメソッドがあるとしましょう。

def findPerson(key: Int): Option[Person]

このメソッドは、レコードが見つかった場合はSome [Person]を返しますが、レコードが見つからなかった場合はNoneを返します。次のプログラムに従ってみましょう。

例

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("capitals.get( \"France\" ) : " +  capitals.get( "France" ))
      println("capitals.get( \"India\" ) : " +  capitals.get( "India" ))
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

capitals.get( "France" ) : Some(Paris)
capitals.get( "India" ) : None

オプションの値を分解する最も一般的な方法は、パターンマッチングを使用することです。たとえば、次のプログラムを試してください。

例

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("show(capitals.get( \"Japan\")) : " + show(capitals.get( "Japan")) )
      println("show(capitals.get( \"India\")) : " + show(capitals.get( "India")) )
   }
   def show(x: Option[String]) = x match {
      case Some(s) => s
      case None => "?"
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

show(capitals.get( "Japan")) : Tokyo
show(capitals.get( "India")) : ?

getOrElse（）メソッドの使用

以下は、getOrElse（）メソッドを使用して、値または値が存在しない場合のデフォルトにアクセスする方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.getOrElse(0): " + a.getOrElse(0) )
      println("b.getOrElse(10): " + b.getOrElse(10) )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

a.getOrElse(0): 5
b.getOrElse(10): 10

isEmpty（）メソッドの使用

以下は、isEmpty（）メソッドを使用してオプションがNoneかどうかを確認する方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.isEmpty: " + a.isEmpty )
      println("b.isEmpty: " + b.isEmpty )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

例

a.isEmpty: false
b.isEmpty: true

キューは先入れ先出しのFIFOデータ構造であり、FIFO方式で要素を挿入および取得できます。

キュー変数の宣言

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

構文

val queue = Queue(1, 2, 3, 4, 5)

ここで、キューは数値のキューとして宣言されています。次のようなコマンドを使用して、値を前に追加できます。

コマンド

queue.enqueue(6)

次のようなコマンドを使用して、値を前もって取得できます。

コマンド

queue.dequeue()

処理キュー

以下は、キューを作成、初期化、および処理する方法を示すプログラムの例です。

例

import scala.collection.mutable.Queue
object Demo {
   def main(args: Array[String]) = {
      var queue = Queue(1, 2, 3, 4, 5);
      // Print queue elements
      queue.foreach{(element:Int) => print(element + " ")}
      println();
      // Print first element
      println("First Element: " + queue.front)
      // Add an element
      queue.enqueue(6);
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
      println();
      // Remove an element
      var dq = queue.dequeue;
      // Print dequeued element
      println("Dequeued Element: " + dq)
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

1 2 3 4 5
First Element: 1
1 2 3 4 5 6
Dequeued Element: 1
2 3 4 5 6

Scalaタプルは、固定数のアイテムを組み合わせて、全体として渡すことができるようにします。配列やリストとは異なり、タプルはさまざまなタイプのオブジェクトを保持できますが、不変でもあります。

以下は、整数、文字列、およびコンソールを保持するタプルの例です。

val t = (1, "hello", Console)

次の糖衣構文（ショートカット）はどれですか？

val t = new Tuple3(1, "hello", Console)

タプルの実際のタイプは、タプルに含まれる要素の数と数、およびそれらの要素のタイプによって異なります。したがって、（99、 "Luftballons"）のタイプはTuple2 [Int、String]です。（ 'u'、 'r'、 "the"、1、4、 "me"）のタイプはTuple6 [Char、Char、String、Int、Int、String]です。

タプルのタイプは、Tuple1、Tuple2、Tuple3などです。現在、Scalaには22の上限があり、さらに必要な場合は、タプルではなくコレクションを使用できます。1 <= N <= 22であるTupleNタイプごとに、Scalaはいくつかの要素アクセスメソッドを定義します。次の定義が与えられた-

val t = (4,3,2,1)

タプルtの要素にアクセスするには、メソッドt._1を使用して最初の要素にアクセスし、t._2を使用して2番目の要素にアクセスします。たとえば、次の式はtのすべての要素の合計を計算します。

val sum = t._1 + t._2 + t._3 + t._4

タプルを使用して、List [Double]を受け取り、3要素のタプルTuple3 [Int、Double、Double]で返されたカウント、合計、および平方和を返すメソッドを作成できます。また、並行プログラミングのアクター間でデータ値のリストをメッセージとして渡す場合にも役立ちます。

次のサンプルプログラムを試してください。タプルの使い方を示しています。

例

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      val sum = t._1 + t._2 + t._3 + t._4
      println( "Sum of elements: "  + sum )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Sum of elements: 10

タプルを反復処理します

使用できます Tuple.productIterator() タプルのすべての要素を反復処理するメソッド。

次のサンプルプログラムを試して、タプルを反復処理します。

例

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Value = 4
Value = 3
Value = 2
Value = 1

文字列への変換

使用できます Tuple.toString()タプルのすべての要素を文字列に連結するメソッド。次のサンプルプログラムを試して、Stringに変換してください。

例

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      println("Concatenated String: " + t.toString() )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Concatenated String: (1,hello,scala.Console$@281acd47)

要素を交換します

使用できます Tuple.swap Tuple2の要素を交換するメソッド。

次のサンプルプログラムを試して、要素を交換してください。

例

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple2("Scala", "hello")
      println("Swapped Tuple: " + t.swap )
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Swapped tuple: (hello,Scala)

Scala Seqは、不変のシーケンスを表す特性です。この構造は、要素、それらの出現、およびサブシーケンスを見つけるためのインデックスベースのアクセスとさまざまなユーティリティメソッドを提供します。Seqは挿入順序を維持します。

Seq変数の宣言

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

構文

val seq: Seq[Int] = Seq(1, 2, 3, 4, 5)

ここで、seqは数値のSeqとして宣言されています。Seqは、次のようなコマンドを提供します-

コマンド

val isPresent = seq.contains(4);
val contains = seq.endsWith(Seq(4,5));
var lastIndexOf = seq.lasIndexOf(5);

処理シーケンス

以下は、Seq −を作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.Seq
object Demo {
   def main(args: Array[String]) = {
      var seq = Seq(1, 2, 3, 4, 5, 3)
      // Print seq elements
      seq.foreach{(element:Int) => print(element + " ")}
      println()
      println("Seq ends with (5,3): " + seq.endsWith(Seq(5, 3)))
      println("Seq contains 4: " + seq.contains(4))
      println("Last index of 3: " + seq.lastIndexOf(3))
      println("Reversed Seq" + seq.reverse)           
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

1 2 3 4 5 3
Seq ends with (5,3): true
Seq contains 4: true
Last index of 3: 5
Reversed SeqList(3, 5, 4, 3, 2, 1)

スタックは後入れ先出しのLIFOデータ構造であり、LIFO方式で要素を上部に挿入および取得できます。

スタック変数の宣言

以下は、スタック変数を宣言するための構文です。

構文

val stack = Stack(1, 2, 3, 4, 5)

ここで、スタックは数値のスタックとして宣言されています。次のようなコマンドを使用して、値を一番上に追加できます。

コマンド

stack.push(6)

次のようなコマンドを使用して、値を上から取得できます。

コマンド

stack.top

次のようなコマンドを使用して、値を上から削除できます。

コマンド

stack.pop

処理スタック

以下は、スタックを作成、初期化、および処理する方法を示すプログラムの例です。

例

import scala.collection.mutable.Stack
object Demo {
   def main(args: Array[String]) = {
      var stack: Stack[Int] = Stack();
      // Add elements
      stack.push(1);
      stack.push(2);
      // Print element at top
      println("Top Element: " + stack.top)
      // Print element
      println("Removed Element: " + stack.pop())
      // Print element
      println("Top Element: " + stack.top)	
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Top Element: 2
Removed Element: 2
Top Element: 1

Scala Streamは、遅延評価機能を備えた特別なリストです。Scalaストリームでは、要素は必要な場合にのみ評価されます。Streamは遅延計算をサポートし、パフォーマンスに精通しています。

ストリーム変数の宣言

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

構文

val stream = 1 #:: 2 #:: 3 #:: Stream.empty

ここで、streamは数値のストリームとして宣言されています。ここで、1はストリームの先頭、2、3はストリームの末尾です。Stream.emptyは、ストリームの終わりを示します。次のようなtakeコマンドを使用して値を取得できます-

コマンド

stream.take(2)

ストリームの処理

以下は、Stream-を作成、初期化、および処理する方法を示すサンプルプログラムです。

例

import scala.collection.immutable.Stream
object Demo {
   def main(args: Array[String]) = {
      val stream = 1 #:: 2 #:: 3 #:: Stream.empty
      // print stream
      println(stream)
      // Print first two elements	
      stream.take(2).print
      println()
      // Create an empty stream
      val stream1: Stream[Int] = Stream.empty[Int]
      // Print element
      println(s"Stream: $stream1")
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Stream(1, <not computed>)
1, 2
Stream: Stream()

drop（）メソッドは、リストの最初のn個の要素を除くすべての要素を選択するためにListが使用するメソッドです。

構文

以下は、dropメソッドの構文です。

def drop(n: Int): List[A]

ここで、nはリストから削除される要素の数です。このメソッドは、最初のn個を除くリストのすべての要素を返します。

使用法

以下は、ドロップ方式の使用方法を示すプログラム例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5)
      // print list
      println(list)
      //apply operation
      val result = list.drop(3)
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(1, 2, 3, 4, 5)
List(4, 5)

dropWhile（）メソッドは、指定された条件を満たすすべての要素を削除するためにListによって使用されるメソッドです。

構文

以下は、dropWhileメソッドの構文です。

def dropWhile(p: (A) => Boolean): List[A]

ここで、p：（A）=>ブール値は、リストの各要素に適用される述語または条件です。このメソッドは、削除された要素を除くリストのすべての要素を返します。

使用法

以下は、dropWhileメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.dropWhile(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(3, 6, 9, 4, 2)
List(4, 2)

filter（）メソッドは、指定された述語を満たすすべての要素を選択するためにListによって使用されるメソッドです。

構文

以下は、filterメソッドの構文です。

def filter(p: (A) => Boolean): List[A]

ここで、p：（A）=>ブール値は、リストの各要素に適用される述語または条件です。このメソッドは、指定された条件を満足するリストのすべての要素を返します。

使用法

以下は、フィルターメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.filter(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(3, 6, 9, 4, 2)
List(3, 6, 9)

find（）メソッドは、指定された述語を満たす要素を見つけるためにイテレータによって使用されるメソッドです。

構文

以下は、findメソッドの構文です。

def find(p: (A) => Boolean): Option[A]

ここで、p：（A）=>ブール値は、イテレータの各要素に適用される述語または条件です。このメソッドは、指定された条件を満足するイテレータの一致した要素を含むOption要素を返します。

使用法

以下は、findメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val iterator = Iterator(3, 6, 9, 4, 2)
      //apply operation
      val result = iterator.find(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

Some(3)

flatMap（）メソッドはTraversableLikeトレイトのメソッドであり、述語を受け取り、それをコレクションの各要素に適用し、述語によって返される要素の新しいコレクションを返します。

構文

以下はflatMapメソッドの構文です。

def flatMap[B](f: (A) ? GenTraversableOnce[B]): TraversableOnce[B]

ここで、f：（A）？GenTraversableOnce [B]は、コレクションの各要素に適用される述語または条件です。このメソッドは、指定された条件を満足するイテレータの一致した要素を含むOption要素を返します。

使用法

以下は、flatMapメソッドの使用方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 5, 10)
      //apply operation
      val result = list.flatMap{x => List(x,x+1)}
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(1, 2, 5, 6, 10, 11)

flatten（）メソッドはGenericTraversableTemplateトレイトのメンバーであり、子コレクションをマージすることによって要素の単一のコレクションを返します。

構文

以下はflattenメソッドの構文です。

def flatten[B]: Traversable[B]

ここで、f：（A）？GenTraversableOnce [B]は、コレクションの各要素に適用される述語または条件です。このメソッドは、指定された条件を満足するイテレータの一致した要素を含むOption要素を返します。

使用法

以下は、flattenメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(List(1,2), List(3,4))
      //apply operation
      val result = list.flatten
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(1, 2, 3, 4)

fold（）メソッドはTraversableOnceトレイトのメンバーであり、コレクションの要素を折りたたむために使用されます。

構文

foldメソッドの構文は次のとおりです。

def fold[A1 >: A](z: A1)(op: (A1, A1) ? A1): A1

ここで、foldメソッドは連想二項演算子関数をパラメーターとして取ります。このメソッドは、結果を値として返します。最初の入力を初期値、2番目の入力を関数（累積値と現在の項目を入力として受け取ります）と見なします。

使用法

以下は、foldメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.fold(0)(_ + _)
      //print result
      println(result)      
   }
}

ここでは、fold関数の初期値として0を渡してから、すべての値を追加しています。上記のプログラムをに保存しますDemo.scala。このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

10

foldLeft（）メソッドはTraversableOnceトレイトのメンバーであり、コレクションの要素を折りたたむために使用されます。要素を左から右の順序でナビゲートします。これは主に再帰関数で使用され、スタックオーバーフローの例外を防ぎます。

構文

foldメソッドの構文は次のとおりです。

def foldLeft[B](z: B)(op: (B, A) ? B): B

ここで、foldLeftメソッドは、連想二項演算子関数をパラメーターとして受け取ります。このメソッドは、結果を値として返します。

使用法

以下は、foldLeftメソッドの使用方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldLeft(0)(_ + _)
      //print result
      println(result)      
   }
}

ここでは、fold関数の初期値として0を渡してから、すべての値を追加しています。上記のプログラムをに保存しますDemo.scala。このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

10

foldRight（）メソッドはTraversableOnceトレイトのメンバーであり、コレクションの要素を折りたたむために使用されます。要素を右から左の順序でナビゲートします。

構文

以下は、foldRightメソッドの構文です。

def foldRight[B](z: B)(op: (B, A) ? B): B

ここで、foldメソッドは連想二項演算子関数をパラメーターとして取ります。このメソッドは、結果の値を返します。

使用法

以下は、foldRightメソッドの使用方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldRight(0)(_ + _)
      //print result
      println(result)      
   }
}

ここでは、初期値として0をfoldRight関数に渡してから、すべての値を追加しています。上記のプログラムをに保存しますDemo.scala。このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

10

map（）メソッドはTraversableLikeトレイトのメンバーであり、コレクションの各要素で述語メソッドを実行するために使用されます。新しいコレクションを返します。

構文

以下はmapメソッドの構文です。

def map[B](f: (A) ? B): Traversable[B]

ここで、mapメソッドはprediate関数をパラメーターとして取ります。このメソッドは、更新されたコレクションを返します。

使用法

以下は、マップメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get twice of each element.
      val result = list.map(_ * 2)
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(2, 4, 6, 8)

partition（）メソッドはTraversableLikeトレイトのメンバーであり、コレクションの各要素で述語メソッドを実行するために使用されます。2つのコレクションを返します。1つのコレクションは、指定された述語関数を満足させる要素であり、もう1つのコレクションは、指定された述語関数を満たさない要素です。

構文

以下はmapメソッドの構文です。

def partition(p: (A) ? Boolean): (Repr, Repr)

ここで、partitionメソッドはprediate関数をパラメーターとして取ります。このメソッドはコレクションを返します。

使用法

以下は、パーティション方式の使用方法を示すプログラム例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5, 6, 7)
      //apply operation to get twice of each element.
      val (result1, result2) = list.partition(x=>{x % 3 == 0})
      //print result
      println(result1)
      println(result2)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(3, 6)
List(1, 2, 4, 5, 7)

reduce（）メソッドはTraversableOnceトレイトのメンバーであり、コレクションの要素を折りたたむために使用されます。fold法に似ていますが、初期値を取りません。

構文

以下は、reduceメソッドの構文です。

def reduce[A1 >: A](op: (A1, A1) ? A1): A1

ここで、reduceメソッドは連想二項演算子関数をパラメーターとして取ります。このメソッドは、結果の値を返します。

使用法

以下は、foldメソッドの使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.reduce(_ + _)
      //print result
      println(result)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

10

scan（）メソッドはTraversableLikeトレイトのメンバーであり、foldメソッドに似ていますが、コレクションの各要素に操作を適用してコレクションを返すために使用されます。

構文

foldメソッドの構文は次のとおりです。

def scan[B >: A, That](z: B)(op: (B, B) ? B)(implicit cbf: CanBuildFrom[Repr, B, That]): That

ここで、scanメソッドは連想二項演算子関数をパラメーターとして取ります。このメソッドは、更新されたコレクションを結果として返します。最初の入力を初期値と見なし、2番目の入力を関数と見なします。

使用法

以下は、スキャン方法の使用方法を示すプログラムの例です。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to create a running total of all elements of the list
      val list1 = list.scan(0)(_ + _)
      //print list
      println(list1)      
   }
}

ここでは、スキャン関数に初期値として0を渡してから、すべての値を追加します。上記のプログラムをに保存しますDemo.scala。このプログラムをコンパイルして実行するには、次のコマンドを使用します。

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List(0, 1, 3, 6, 10)

zip（）メソッドはIterableLikeトレイトのメンバーであり、コレクションを現在のコレクションにマージするために使用され、結果は両方のコレクションからのタプル要素のペアのコレクションになります。

構文

以下はzipメソッドの構文です。

def zip[B](that: GenIterable[B]): Iterable[(A, B)]

ここで、zipメソッドはコレクションをパラメーターとして受け取ります。このメソッドは、結果として更新されたペアのコレクションを返します。

使用法

以下は、zipメソッドの使用方法を示すサンプルプログラムです。

例

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      val list1 = List("A", "B", "C", "D")
      //apply operation to create a zip of list
      val list2 = list zip list1
      //print list
      println(list2)      
   }
}

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

コマンド

\>scalac Demo.scala
\>scala Demo

出力

List((1,A), (2,B), (3,C), (4,D))