Kategória: Scala.

Konzol műveletek

A kírást már láttuk, most ismételjük át egy beolvasással:

println("Hogy hívnak?")
val name = Console.in.readLine()
println("Szia, " + name + "!")

A Console.in.readLine() helyett használhatjuk az újabb scala.io.StdIn.readLine() függvényt is. A scala.io.StdIn osztálynak számos egyéb, típus specifikus része van, pl. a scala.io.StdIn.readInt() számokat olvas be.

Fájlműveletek

A Scala-ban a fájl olvasás viszonylag egyszerű:

val data = scala.io.Source.fromFile("data.txt").mkString
data

A fájlba íráshoz viszont furcsamód nincs standard Scala megoldás, ahhoz a Java osztályokat kell használnunk, pl.

import java.io._

val writer = new PrintWriter(new File("write.txt"))
writer.write("Writing test messages to file.\n")
writer.write("Second line.\n")
writer.close()

A rendszer elérése

A System osztályon keresztül érjük el az operációs rendszert. Például a rendszeridő lekérdezése a következőképpen történhet:

System.currentTimeMillis()

Webes letöltés

HTTP GET kérést az alábbi módon tudunk végrehajtani:

scala.io.Source.fromURL("http://faragocsaba.hu").mkString

Bonyolultabb HTTP kérésekhez külső könyvtárakat érdemes használni.

Többszálúság

A többszálúság a Scala-ban hasonló a Java-hoz: itt is vagy a Thread osztályból származtatunk, vagy megvalósítjuk a Runnable interfészt, majd megfelelő példányosítás után meghívjuk a start() metódust. A második lehetőségre lássunk gey példát:

class MyRunnable extends Runnable {
  override def run(): Unit = {
    println(Thread.currentThread().getName() + " is running.")
    Thread.sleep(1000)
    println(Thread.currentThread().getName() + " stops.")
  }
}

object Multithreading {
  def main(args: Array[String]): Unit = {
    for (x <- 1 to 5) (new Thread(new MyRunnable)).start()
  }
}

Azzal, hogy nincs a Scala-ban ellenőrzött kivétel, a Thread.sleep nem piszkítja össze a kódot a kivételkezeléssel.

Future

A többszálúsághoz szorosan kapcsolódik a Future mechanizmus: a meghívott függvényt külön szálon indítja a program aszinkron módon, így az eredeti szál tovább fut, az erdmény pedig egy Future osztályba kerül, ahol le lehet kérdezni, hogy benne van-e már, és ha igen, akkor mi lett az eredmény. Lássunk erre is egy példát:

import scala.util._
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global

object FutureExample {
  def longRunningAdd(a: Int, b: Int): Int = {
    Thread.sleep(1000)
    a + b
  }

  def main(args: Array[String]): Unit = {
    val future: Future[Int] = Future {
      longRunningAdd(2, 3)
    }
    while (!future.isCompleted) {
      println("Waiting for the result...")
      Thread.sleep(100)
    }
    future.onComplete {
      case Success(value) => println(value)
      case Failure(e) => e.printStackTrace
    }
  }
}

Grafikus programok

A Scala-ban a grafikus felhasználói felület nem kapott jelentős hangsúlyt. A Java Swingre épül. Van egy köztes réteg a scala.swing csomagban, de az a 2.11-es verziótól kezdve már nem része a standard könyvtáraknak, azt külön hozzá kell adni függőségként. Másik lehetőség a Java osztályok közvetlen használata, pl.

import javax.swing._

val frame = new JFrame("Swing from Scala")
val textArea = new JTextArea
textArea.setText("Ez egy teszt szöveg.")
frame.getContentPane.add(textArea)
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setSize(500, 300)
frame.setVisible(true)

A Swingről ennél egy nem sokkal részletesebb leírást találunk a Java standard könyvtárak oldalon. Az ott megadott külső oldalon (vagy rákeresve a neten) találunk további leírásokat erről a technológiáról.