Коллекции Scala - Краткое руководство

Scala имеет богатый набор библиотек коллекций. Коллекции - это вместилища вещей. Эти контейнеры могут быть упорядоченными, линейными наборами элементов, такими как List, Tuple, Option, Map и т. Д. Коллекции могут иметь произвольное количество элементов или быть ограниченными до нуля или одного элемента (например, Option).

Коллекции могут быть strict или же lazy. В ленивых коллекциях есть элементы, которые могут не потреблять память до тех пор, пока к ним не поступит доступ, напримерRanges. Дополнительно коллекции могут бытьmutable (содержание ссылки может измениться) или immutable(то, на что ссылается ссылка, никогда не изменяется). Обратите внимание, что неизменяемые коллекции могут содержать изменяемые элементы.

Для некоторых задач лучше работают изменяемые коллекции, а для других - неизменные. В случае сомнений лучше начать с неизменяемой коллекции и изменить ее позже, если вам понадобятся изменяемые коллекции.

В этой главе освещаются наиболее часто используемые типы коллекций и наиболее часто используемые операции с этими коллекциями.

Старший Нет	Коллекции с описанием
1	Scala Lists Список Scala [T] - это связанный список типа T.
2	Scala Sets Набор - это совокупность попарно различных элементов одного типа.
3	Scala Maps Карта - это набор пар ключ / значение. Любое значение может быть получено на основе его ключа.
4	Scala Tuples В отличие от массива или списка, кортеж может содержать объекты разных типов.
5	Scala Options Опция [T] предоставляет контейнер для нуля или одного элемента данного типа.
6	Scala Iterators Итератор - это не коллекция, а способ доступа к элементам коллекции один за другим.

Scala может быть установлен в любой системе на базе UNIX или Windows. Перед тем как начать установку Scala на свой компьютер, на вашем компьютере должна быть установлена Java 1.8 или выше.

Следуйте инструкциям ниже, чтобы установить Scala.

Шаг 1. Проверьте установку Java

Прежде всего, вам необходимо установить Java Software Development Kit (SDK) в вашей системе. Чтобы проверить это, выполните любую из следующих двух команд в зависимости от платформы, на которой вы работаете.

Если установка Java была выполнена правильно, отобразится текущая версия и спецификация вашей установки Java. Пример вывода приведен в следующей таблице.

Платформа	Команда	Пример вывода
Windows	Откройте командную консоль и введите - \>java -version	Версия Java "1.8.0_31" Java (TM) SE Время выполнения Среда (сборка 1.8.0_31-b31) 64-разрядный сервер Java Hotspot (TM) ВМ (сборка 25.31-b07, смешанный режим)
Linux	Откройте командный терминал и введите - $java -version	Версия Java "1.8.0_31" Откройте среду выполнения JDK (rhel-2.8.10.4.el6_4-x86_64) Откройте виртуальную машину 64-разрядного сервера JDK (сборка 25.31-b07, смешанный режим)

Мы предполагаем, что у читателей этого руководства в системе установлен Java SDK версии 1.8.0_31.

Если у вас нет Java SDK, загрузите его текущую версию с https://www.oracle.com/technetwork/java/javase/downloads/index.html и установите его.

Шаг 2. Настройте среду Java

Установите переменную среды JAVA_HOME, чтобы она указывала на расположение базового каталога, в котором установлена Java на вашем компьютере. Например,

Старший Нет	Платформа и описание
1	Windows Установите JAVA_HOME в C: \ ProgramFiles \ java \ jdk1.8.0_31
2	Linux Экспорт JAVA_HOME = / usr / local / java-current

Добавьте полный путь к расположению компилятора Java в системный путь.

Старший Нет	Платформа и описание
1	Windows Добавьте строку «C: \ Program Files \ 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. Убедитесь, что у вас есть права администратора, чтобы продолжить. Теперь выполните следующую команду в командной строке -

Платформа	Команда и вывод	Описание
Windows	\> java -jar scala-2.13.1-installer.jar \>	Эта команда отобразит мастер установки, который поможет вам установить Scala на ваш компьютер с Windows. Во время установки он запросит лицензионное соглашение, просто примите его, а в дальнейшем он спросит путь, по которому будет установлен Scala. Я выбрал заданный по умолчанию путь "C: \ Program Files \ Scala", вы можете выбрать подходящий путь по своему усмотрению.
Linux	Command - $ java -jar scala-2.13.1-installer.jar Output - Добро пожаловать на установку Scala 2.13.1! Домашняя страница находится по адресу - http://Scala-lang.org/ нажмите 1 для продолжения, 2 для выхода, 3 для повторного отображения 1 ................................................ [Начало распаковки] [Пакет обработки: Установка программного пакета (1/1)] [Распаковка завершена] [Установка консоли завершена]	Во время установки он запросит лицензионное соглашение, чтобы принять его, введите 1 и запросит путь, по которому будет установлен Scala. Я ввел / usr / local / share, вы можете выбрать подходящий путь по своему усмотрению.

Наконец, откройте новую командную строку и введите Scala -versionи нажмите Enter. Вы должны увидеть следующее -

Платформа	Команда	Вывод
Windows	\> scala -версия	Средство выполнения кода Scala версии 2.13.1 - Copyright 2002-2019, LAMP / EPFL и Lightbend, Inc.
Linux	$ scala -version	Средство выполнения кода Scala версии 2.13.1 - Copyright 2002-2019, LAMP / EPFL и Lightbend, Inc. tut

Scala предоставляет структуру данных, array, в котором хранится последовательная коллекция фиксированного размера элементов одного типа. Массив используется для хранения набора данных, но часто бывает более полезно думать о массиве как о коллекции переменных одного типа.

Вместо объявления отдельных переменных, таких как число0, число1, ... и число99, вы объявляете одну переменную массива, например числа, и используете числа [0], числа [1] и ..., числа [99] для представления отдельные переменные. В этом руководстве рассказывается, как объявлять переменные массива, создавать массивы и обрабатывать массивы с помощью индексированных переменных. Индекс первого элемента массива равен нулю, а индекс последнего элемента - это общее количество элементов минус один.

Объявление переменных массива

Чтобы использовать массив в программе, вы должны объявить переменную для ссылки на массив и указать тип массива, на который может ссылаться переменная.

Ниже приводится синтаксис объявления переменной массива.

Синтаксис

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

or

var z = new Array[String](3)

Здесь z объявлен как массив строк, который может содержать до трех элементов. Значения могут быть присвоены отдельным элементам или получить доступ к отдельным элементам, это можно сделать с помощью таких команд, как следующие:

Команда

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

Здесь последний пример показывает, что в общем случае индекс может быть любым выражением, которое дает целое число. Есть еще один способ определения массива -

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

На следующем рисунке представлен массив myList. Вот,myList содержит десять двойных значений и индексы от 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._ пакет.

Есть много ситуаций, когда вам нужно определять и использовать многомерные массивы (т. Е. Массивы, элементы которых являются массивами). Например, матрицы и таблицы являются примерами структур, которые могут быть реализованы в виде двумерных массивов.

Ниже приведен пример определения двумерного массива -

var myMatrix = ofDim[Int](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();
      }
   }
}

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

0 1 2
0 1 2
0 1 2

Использование метода range () для создания массива, содержащего последовательность возрастающих целых чисел в заданном диапазоне. Вы можете использовать последний аргумент как шаг для создания последовательности; если вы не используете последний аргумент, тогда step будет принят как 1.

Давайте рассмотрим пример создания массива диапазона (10, 20, 2): это означает создание массива с элементами между 10 и 20 и разницей диапазона 2. Элементы в массиве - 10, 12, 14, 16 и 18. .

Другой пример: диапазон (10, 20). Здесь разница в диапазоне не указана, поэтому по умолчанию предполагается 1 элемент. Он создает массив с элементами от 10 до 20 с разницей в диапазоне 1. Элементы в массиве - 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 )
      }
   }
}

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Списки Scala очень похожи на массивы, что означает, что все элементы списка имеют один и тот же тип, но есть два важных различия. Во-первых, списки неизменяемы, что означает, что элементы списка не могут быть изменены путем присвоения. Во-вторых, списки представляют собой связанный список, а массивы - плоские.

Тип списка, в котором есть элементы типа 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)
)

Все списки могут быть определены с помощью двух основных строительных блоков, хвоста 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

Основные операции со списками

Все операции со списками могут быть выражены следующими тремя способами.

Старший Нет	Методы и описание
1	head Этот метод возвращает первый элемент списка.
2	tail Этот метод возвращает список, состоящий из всех элементов, кроме первого.
3	isEmpty Этот метод возвращает истину, если список пуст, в противном случае - ложь.

В следующем примере показано, как использовать вышеуказанные методы.

пример

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

Команда

\>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()метод добавления двух или более списков. Пожалуйста, найдите следующий пример, приведенный ниже -

пример

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

Команда

\>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()создает список, состоящий из нуля или более копий одного и того же элемента. Попробуйте следующий пример программы.

пример

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

Команда

\>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: первый список аргументов дает размеры создаваемого списка, а второй описывает элементы списка. Единственное отличие состоит в том, что вместо фиксированных элементов они вычисляются из функции.

Попробуйте следующий пример программы.

пример

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

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Scala предоставляет структуру данных, ListBuffer, что более эффективно, чем List, при добавлении / удалении элементов в списке. Он предоставляет методы для добавления элементов в список.

Объявление переменных 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));
   }
}

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Scala Set - это набор попарно различных элементов одного типа. Другими словами, Set - это коллекция, не содержащая повторяющихся элементов. ListSet реализует неизменяемые наборы и использует структуру списка. Порядок вставки элементов сохраняется при сохранении элементов.

Объявление переменных ListSet

Ниже приводится синтаксис объявления переменной ListSet.

Синтаксис

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

Здесь z объявлен как набор строк, состоящий из трех членов. Значения могут быть добавлены с помощью следующих команд:

Команда

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

Команда

\>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 объявлен как вектор строк, состоящий из трех членов. Значения могут быть добавлены с помощью следующих команд:

Команда

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

Команда

\>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 - это набор попарно различных элементов одного типа. Другими словами, Set - это коллекция, не содержащая повторяющихся элементов. Есть два вида наборов:immutable и mutable. Разница между изменяемыми и неизменяемыми объектами заключается в том, что, когда объект неизменен, сам объект не может быть изменен.

По умолчанию Scala использует неизменяемый Set. Если вы хотите использовать изменяемый набор, вам придется импортировать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)

При определении пустого набора аннотация типа необходима, поскольку системе необходимо присвоить конкретный тип переменной.

Основные операции на съемочной площадке

Все операции над множествами можно выразить с помощью следующих трех методов:

Старший Нет	Методы и описание
1	head Этот метод возвращает первый элемент набора.
2	tail Этот метод возвращает набор, состоящий из всех элементов, кроме первого.
3	isEmpty Этот метод возвращает истину, если набор пуст, в противном случае - ложь.

Попробуйте следующий пример, показывающий использование основных методов работы -

пример

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

Команда

\>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.++() для объединения двух или более наборов, но при добавлении наборов он удалит повторяющиеся элементы.

Ниже приводится пример объединения двух наборов.

пример

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

Команда

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

Команда

\>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.intersectчтобы узнать общие значения между двумя наборами. Попробуйте следующий пример, чтобы продемонстрировать использование.

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Bitset - это общий базовый класс для изменяемых и неизменяемых битовых наборов. Битовые наборы представляют собой наборы неотрицательных целых чисел и представлены в виде массивов битов переменного размера, упакованных в 64-битные слова. Объем памяти битового набора представлен самым большим числом, хранящимся в нем.

Объявление переменных BitSet

Ниже приводится синтаксис объявления переменной BitSet.

Синтаксис

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

Здесь z объявлен как набор битов неотрицательных целых чисел, состоящий из трех членов. Значения могут быть добавлены с помощью следующих команд:

Команда

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

Команда

\>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 - это набор попарно различных элементов одного типа. Другими словами, Set - это коллекция, не содержащая повторяющихся элементов. HashSet реализует неизменяемые наборы и использует хеш-таблицу. Порядок вставки элементов не сохраняется.

Объявление переменных HashSet

Ниже приводится синтаксис объявления переменной HashSet.

Синтаксис

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

Здесь z объявлен как хэш-набор строк, состоящий из трех членов. Значения могут быть добавлены с помощью следующих команд:

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Scala Set - это набор попарно различных элементов одного типа. Другими словами, Set - это коллекция, не содержащая повторяющихся элементов. TreeSet реализует неизменяемые наборы и сохраняет элементы в отсортированном порядке.

Объявление переменных TreeSet

Ниже приводится синтаксис объявления переменной TreeSet.

Синтаксис

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

Здесь z объявлен как древовидный набор строк, состоящий из трех членов. Значения могут быть добавлены с помощью следующих команд:

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Карта Scala - это набор пар ключ / значение. Любое значение может быть получено на основе его ключа. Ключи уникальны на карте, но значения не обязательно должны быть уникальными. Карты также называются хеш-таблицами. Есть два вида карт: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

Все операции с картами можно описать следующими тремя способами.

Старший Нет	Методы и описание
1	keys Этот метод возвращает итерацию, содержащую каждый ключ на карте.
2	values Этот метод возвращает итерацию, содержащую каждое значение на карте.
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 )
   }
}

Команда

\>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.++() для объединения двух или более карт, но при добавлении карт он удалит повторяющиеся ключи.

Попробуйте выполнить следующий пример программы для объединения двух карт.

пример

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

Команда

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

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Объявление переменных HashMap

Ниже приводится синтаксис объявления переменной HashMap.

Синтаксис

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

Здесь цвета объявлены как хэш-карта строк, 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);		  
   }
}

Команда

\>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 реализует неизменяемую карту и использует список для ее реализации. Используется с небольшим количеством элементов.

Объявление переменных ListMap

Ниже приводится синтаксис объявления переменной ListMap.

Синтаксис

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

Команда

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

Список обработки Карта

Ниже приведен пример программы, показывающей, как создавать, инициализировать и обрабатывать 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);		  
   }
}

Команда

\>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()

Итератор - это не коллекция, а способ доступа к элементам коллекции один за другим. Две основные операции надiterator it находятся next и hasNext. Звонок вit.next()вернет следующий элемент итератора и продвинет состояние итератора. Вы можете узнать, есть ли еще элементы, которые нужно вернуть, используя Iteratorit.hasNext метод.

Самый простой способ «перебрать» все элементы, возвращаемые итератором, - это использовать цикл while. Давайте следовать следующей программе-примеру.

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

a
number
of
words

Найти элемент с минимальным и максимальным значением

Вы можете использовать it.min и it.maxметоды, чтобы узнать минимальное и максимальное значения элементов от итератора. Здесь мы использовалиita и itbдля выполнения двух разных операций, потому что итератор может быть пройден только один раз. Ниже приведен пример программы.

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

Maximum valued element 90
Minimum valued element 2

Найдите длину итератора

Вы можете использовать либо it.size или же it.lengthметоды, чтобы узнать количество элементов, доступных в итераторе. Здесь мы использовали ita и itb для выполнения двух разных операций, потому что итератор можно пройти только один раз. Ниже приведен пример программы.

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Scala Option [T] - это контейнер для нуля или одного элемента данного типа. Вариант [T] может быть либоSome[T] или же Noneобъект, представляющий пропущенное значение. Например, метод get в Scala Map выдает Some (значение), если было найдено значение, соответствующее данному ключу, илиNone если данный ключ не определен на карте.

Тип опции часто используется в программах Scala, и вы можете сравнить это с nullзначение, доступное в Java, которое означает отсутствие значения. Например, метод get java.util.HashMap возвращает либо значение, хранящееся в 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" ))
   }
}

Команда

\>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 => "?"
   }
}

Команда

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

Команда

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

Команда

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

Команда

\>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, если вам нужно больше, тогда вы можете использовать коллекцию, а не кортеж. Для каждого типа TupleN, где 1 <= N <= 22, Scala определяет несколько методов доступа к элементам. Учитывая следующее определение -

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

Чтобы получить доступ к элементам кортежа t, вы можете использовать метод t._1 для доступа к первому элементу, t._2 для доступа ко второму и так далее. Например, следующее выражение вычисляет сумму всех элементов t.

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

Вы можете использовать Tuple для написания метода, который принимает List [Double] и возвращает счетчик, сумму и сумму квадратов, возвращаемых в трехэлементном Tuple, 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 )
   }
}

Команды

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

Команды

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

Команда

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

Команда

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

Ниже приведен пример программы, показывающей, как создавать, инициализировать и обрабатывать 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)           
   }
}

Команда

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

Команда

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

Здесь поток объявлен как поток чисел. Здесь 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")
   }
}

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

drop () - это метод, используемый List для выбора всех элементов, кроме первых n элементов списка.

Синтаксис

Ниже приводится синтаксис метода drop.

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

Здесь n - количество элементов, которые нужно удалить из списка. Этот метод возвращает все элементы списка, кроме первых n.

Применение

Ниже приведен пример программы, показывающей, как использовать метод drop -

пример

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

Команда

\>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) => Boolean - это предикат или условие, применяемое к каждому элементу списка. Этот метод возвращает все элементы списка, кроме отброшенных.

Применение

Ниже приведен пример программы, показывающей, как использовать метод 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)      
   }
}

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

filter () - это метод, используемый List для выбора всех элементов, которые удовлетворяют заданному предикату.

Синтаксис

Ниже приводится синтаксис метода фильтрации.

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

Здесь p: (A) => Boolean - это предикат или условие, применяемое к каждому элементу списка. Этот метод возвращает все элементы списка, удовлетворяющие заданному условию.

Применение

Ниже приведен пример программы, показывающей, как использовать метод фильтрации -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

find () - это метод, используемый Итераторами для поиска элемента, удовлетворяющего заданному предикату.

Синтаксис

Ниже приводится синтаксис метода поиска.

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

Здесь p: (A) => Boolean - это предикат или условие, применяемое к каждому элементу итератора. Этот метод возвращает элемент Option, содержащий соответствующий элемент итератора, который удовлетворяет заданному условию.

Применение

Ниже приведен пример программы, показывающей, как использовать метод поиска -

пример

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

Команда

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Метод flatten () является признаком GenericTraversableTemplate члена, он возвращает единую коллекцию элементов путем слияния дочерних коллекций.

Синтаксис

Ниже приводится синтаксис метода сглаживания.

def flatten[B]: Traversable[B]

Применение

Ниже приведен пример программы, показывающей, как использовать метод сглаживания -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

List(1, 2, 3, 4)

Метод fold () является членом трейта TraversableOnce, он используется для сворачивания элементов коллекций.

Синтаксис

Ниже приводится синтаксис метода сворачивания.

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

Здесь метод 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)      
   }
}

Здесь мы передали 0 в качестве начального значения функции сворачивания, а затем все значения добавлены. Сохраните указанную выше программу вDemo.scala. Следующие команды используются для компиляции и выполнения этой программы.

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

Метод foldLeft () является членом трейта TraversableOnce, он используется для сворачивания элементов коллекций. Он перемещает элементы слева направо. Он в основном используется в рекурсивных функциях и предотвращает исключения переполнения стека.

Синтаксис

Ниже приводится синтаксис метода сворачивания.

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

Метод 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

Вывод

Метод map () является членом трейта TraversableLike, он используется для запуска метода предиката для каждого элемента коллекции. Возвращает новую коллекцию.

Синтаксис

Ниже приводится синтаксис метода карты.

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

Здесь метод map принимает в качестве параметра функцию-предшественницу. Этот метод возвращает обновленную коллекцию.

Применение

Ниже приведен пример программы, показывающей, как использовать метод карты -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

List(2, 4, 6, 8)

Метод partition () является членом трейта TraversableLike, он используется для запуска метода предиката для каждого элемента коллекции. Он возвращает две коллекции, одна коллекция состоит из элементов, удовлетворяющих заданной функции предиката, а другая коллекция состоит из элементов, которые не удовлетворяют данной функции предиката.

Синтаксис

Ниже приводится синтаксис метода карты.

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

Здесь метод разделения принимает в качестве параметра функцию-предшественницу. Этот метод возвращает коллекции.

Применение

Ниже приведен пример программы, показывающей, как использовать метод разделения -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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

Метод reduce () является членом трейта TraversableOnce, он используется для сворачивания элементов коллекций. Он похож на метод сворачивания, но не принимает начального значения.

Синтаксис

Ниже приводится синтаксис метода уменьшения.

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

Здесь метод reduce принимает в качестве параметра функцию ассоциативного бинарного оператора. Этот метод возвращает результирующее значение.

Применение

Ниже приведен пример программы, показывающей, как использовать метод складывания -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

Метод scan () является членом трейта TraversableLike, он похож на метод fold, но используется для применения операции к каждому элементу коллекции и возврата коллекции.

Синтаксис

Ниже приводится синтаксис метода сворачивания.

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

Здесь метод сканирования принимает в качестве параметра функцию ассоциативного бинарного оператора. Этот метод возвращает обновленную коллекцию как результат. Он рассматривает первый вход как начальное значение, а второй вход как функцию.

Применение

Ниже приведен пример программы, показывающей, как использовать метод сканирования -

пример

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

Команда

\>scalac Demo.scala
\>scala Demo

Вывод

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