Ho bisogno di alcuni esempi di codice (e sono anche molto curioso di loro) di codice Scala e Java che dimostrano che il codice Scala è più semplice e conciso del codice scritto in Java (ovviamente entrambi gli esempi dovrebbero risolvere lo stesso problema).

Se c'è solo un campione Scala con commenti come "questa è una fabbrica astratta in Scala, in Java sembrerà molto più ingombrante", allora anche questo è accettabile.

Grazie!

Mi piace più di tutto accettato e questo risponde

Miglioriamo l'esempio di stacker e utilizzare di Scala classi case :

case class Person(firstName: String, lastName: String)

La classe Scala sopra contiene tutte le funzionalità della classe Java sottostante e altre ancora , ad esempio supporta il pattern matching (che Java non ha). Scala 2.8 aggiunge argomenti denominati e predefiniti, che vengono utilizzati per generare un metodo di copia per le classi case, che fornisce la stessa capacità dei metodi with * della seguente classe Java.

public class Person implements Serializable {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public Person withFirstName(String firstName) {
        return new Person(firstName, lastName);
    }

    public Person withLastName(String lastName) {
        return new Person(firstName, lastName);
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        if (firstName != null ? !firstName.equals(person.firstName) : person.firstName != null) {
            return false;
        }
        if (lastName != null ? !lastName.equals(person.lastName) : person.lastName != null) {
            return false;
        }
        return true;
    }

    public int hashCode() {
        int result = firstName != null ? firstName.hashCode() : 0;
        result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
        return result;
    }

    public String toString() {
        return "Person(" + firstName + "," + lastName + ")";
    }
}

Quindi, nell'uso abbiamo (ovviamente):

Person mr = new Person("Bob", "Dobbelina");
Person miss = new Person("Roberta", "MacSweeney");
Person mrs = miss.withLastName(mr.getLastName());

Contro

val mr = Person("Bob", "Dobbelina")
val miss = Person("Roberta", "MacSweeney")
val mrs = miss copy (lastName = mr.lastName)

Ho trovato questo impressionante

Giava

public class Person {
    private final String firstName;
    private final String lastName;
    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
}

Scala

class Person(val firstName: String, val lastName: String)

Oltre a questi (scusate per non incollare, non volevo rubare il codice)

• Queens-Problem Java
• Queens-Problem Scala

Attività: scrivi un programma per indicizzare un elenco di parole chiave (come i libri).

Spiegazione:

• Input: List <String>
• Output: Map <Character, List <String>>
• La chiave della mappa va dalla "A" alla "Z"
• Ogni elenco nella mappa viene ordinato.

Giava:

import java.util.*;

class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer"); 
    Map<Character, List<String>> result = new HashMap<Character, List<String>>(); 
    for(String k : keywords) {   
      char firstChar = k.charAt(0);     
      if(!result.containsKey(firstChar)) {     
        result.put(firstChar, new  ArrayList<String>());   
      }     
      result.get(firstChar).add(k); 
    } 
    for(List<String> list : result.values()) {   
      Collections.sort(list); 
    }
    System.out.println(result);         
  }
}

Scala:

object Main extends App {
  val keywords = List("Apple", "Ananas", "Mango", "Banana", "Beer")
  val result = keywords.sorted.groupBy(_.head)
  println(result)
}

Compito:

Hai un elenco peopledi oggetti della classe Personche ha campi namee age. Il tuo compito è ordinare questo elenco prima per namee poi per age.

Java 7:

Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return a.getName().compare(b.getName());
  }
});
Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return Integer.valueOf(a.getAge()).compare(b.getAge());
  }
});

Scala:

val sortedPeople = people.sortBy(p => (p.name, p.age))

Aggiornare

Da quando ho scritto questa risposta, ci sono stati dei progressi. I lambda (e i riferimenti ai metodi) sono finalmente atterrati in Java e stanno conquistando il mondo di Java.

Ecco come apparirà il codice sopra con Java 8 (contributo di @fredoverflow):

people.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));

Sebbene questo codice sia quasi altrettanto breve, non funziona in modo così elegante come quello Scala.

Nella soluzione Scala, il Seq[A]#sortBymetodo accetta una funzione in A => Bcui Bè richiesto di avere un'estensione Ordering. Orderingè una classe di tipo. Pensa meglio di entrambi i mondi: come Comparable, è implicito per il tipo in questione, ma come Comparator, è estensibile e può essere aggiunto in modo retrospettivo ai tipi che non lo avevano. Poiché Java manca di classi di tipo, deve duplicare ogni metodo di questo tipo, una volta per Comparable, poi per Comparator. Ad esempio, vedi comparinge thenComparing qui .

Le classi di tipo consentono di scrivere regole come "Se A ha un ordine e B ha un ordine, anche la loro tupla (A, B) ha un ordine". Nel codice, ovvero:

implicit def pairOrdering[A : Ordering, B : Ordering]: Ordering[(A, B)] = // impl

È così che sortBynel nostro codice si possono confrontare per nome e poi per età. Quelle semantiche saranno codificate con la "regola" di cui sopra. Un programmatore Scala si aspetterebbe intuitivamente che funzioni in questo modo. Non è comparingstato necessario aggiungere metodi per scopi speciali come Ordering.

Lambda e riferimenti ai metodi sono solo la punta di un iceberg che è la programmazione funzionale. :)

Compito:

Hai un file XML "company.xml" che assomiglia a questo:

<?xml version="1.0"?>
<company>
    <employee>
        <firstname>Tom</firstname>
        <lastname>Cruise</lastname>
    </employee>
    <employee>
        <firstname>Paul</firstname>
        <lastname>Enderson</lastname>
    </employee>
    <employee>
        <firstname>George</firstname>
        <lastname>Bush</lastname>
    </employee>
</company>

Devi leggere questo file e stampare i campi firstNamee lastNamedi tutti i dipendenti.


Java: [tratto da qui ]

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XmlReader {
  public static void main(String[] args) {   
    try {
      File file = new File("company.xml");
      DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
      DocumentBuilder db = dbf.newDocumentBuilder();
      Document doc = db.parse(file);
      doc.getDocumentElement().normalize();
      NodeList nodeLst = doc.getElementsByTagName("employee");
      for (int s = 0; s < nodeLst.getLength(); s++) {  
        Node fstNode = nodeLst.item(s); 
        if (fstNode.getNodeType() == Node.ELEMENT_NODE) {         
          Element fstElmnt = (Element) fstNode;
          NodeList fstNmElmntLst = fstElmnt.getElementsByTagName("firstname");
          Element fstNmElmnt = (Element) fstNmElmntLst.item(0);
          NodeList fstNm = fstNmElmnt.getChildNodes();
          System.out.println("First Name: "  + ((Node) fstNm.item(0)).getNodeValue());
          NodeList lstNmElmntLst = fstElmnt.getElementsByTagName("lastname");
          Element lstNmElmnt = (Element) lstNmElmntLst.item(0);
          NodeList lstNm = lstNmElmnt.getChildNodes();
          System.out.println("Last Name: " + ((Node) lstNm.item(0)).getNodeValue());
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Scala: [tratto da qui , diapositiva # 19]

import xml.XML

object XmlReader {
  def main(args: Array[String]): Unit = {
    XML.loadFile("company.xml") match {
      case <employee> { employees @ _* } </employee> => {
        for(e <- employees) {
          println("First Name: " + (e \ "firstname").text)
          println("Last Name: " + (e \ "lastname").text)
        } 
      }
    }
  }
}

[EDIT di Bill; Controlla i commenti per la discussione] -

Hmm, come farlo senza rispondere in una sezione di risposta non formattata ... Hmph. Immagino che modificherò la tua risposta e ti permetterò di eliminarla se ti disturba.

Ecco come lo farei in Java con librerie migliori:

public scanForEmployees(String filename) {
    GoodXMLLib source=new GoodXMLLib(filename);
    while( String[] employee: source.scanFor("employee", "firstname", "lastname") )
    {
          System.out.println("First Name: " + employee[0]);
          System.out.println("Last Name: " + employee[1]);
    }
} 

Questo è solo un rapido trucco che non coinvolge la magia e tutti i componenti riutilizzabili. Se volessi aggiungere un po 'di magia, potrei fare qualcosa di meglio che restituire un array di array di stringhe, ma anche se questo GoodXMLLib sarebbe completamente riutilizzabile. Il primo parametro di scanFor è la sezione, tutti i parametri futuri sarebbero gli elementi da trovare che sono limitati, ma l'interfaccia potrebbe essere leggermente potenziata per aggiungere più livelli di corrispondenza senza problemi reali.

Ammetto che Java ha un supporto per le librerie piuttosto scarso in generale, ma dai - confrontare un uso orribile della vecchia libreria XML decennale (?) Di Java con un'implementazione basata sull'essere conciso non è giusto - ed è lontano da un confronto delle lingue!

Una mappa di azioni da eseguire in base a una stringa.

Java 7:

// strategy pattern = syntactic cruft resulting from lack of closures
public interface Todo {   
  public void perform();
}

final Map<String, Todo> todos = new HashMap<String,Todo>();
todos.put("hi", new Todo() { 
    public void perform() { 
        System.out.println("Good morning!");
    } 
} );

final Todo todo = todos.get("hi");
if (todo != null)
    todo.perform();
else
    System.out.println("task not found");

Scala:

val todos = Map( "hi" -> { () => println("Good morning!") } )
val defaultFun = () => println("task not found")
todos.getOrElse("hi", defaultFun).apply()

Ed è tutto fatto nel miglior gusto possibile!

Java 8:

Map<String, Runnable> todos = new HashMap<>();
todos.put("hi", () -> System.out.println("Good morning!"));
Runnable defaultFun = () -> System.out.println("task not found");
todos.getOrDefault("hi", defaultFun).run();

Sto scrivendo un gioco di blackjack in Scala adesso. Ecco come apparirebbe il mio metodo dealerWins in Java:

boolean dealerWins() {
    for(Player player : players)
        if (player.beats(dealer))
            return false;
    return true;
}

Ecco come appare in Scala:

def dealerWins = !(players.exists(_.beats(dealer)))

Evviva le funzioni di ordine superiore!

Soluzione Java 8:

boolean dealerWins() {
    return players.stream().noneMatch(player -> player.beats(dealer));
}

Mi è piaciuto questo semplice esempio di ordinamento e trasformazione, tratto dal libro "Beginning Scala" di David Pollak:

In Scala:

def validByAge(in: List[Person]) = in.filter(_.valid).sortBy(_.age).map(_.first)
case class Person(val first: String, val last: String, val age: Int) {def valid: Boolean = age > 18}
validByAge(List(Person("John", "Valid", 32), Person("John", "Invalid", 17), Person("OtherJohn", "Valid", 19)))

In Java:

public static List<String> validByAge(List<Person> in) {
   List<Person> people = new ArrayList<Person>();
   for (Person p: in) {
     if (p.valid()) people.add(p);
   }
   Collections.sort(people, new Comparator<Person>() {
      public int compare(Person a, Person b) {
        return a.age() - b.age();
      } 
   } );
   List<String> ret = new ArrayList<String>();
     for (Person p: people) {
       ret.add(p.first);
     }
   return ret;
}

public class Person {
    private final String firstName;
    private final String lastName;
    private final Integer age;
    public Person(String firstName, String lastName, Integer age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
    public String getFirst() {
        return firstName;
    }
    public String getLast() {
        return lastName;
    }
    public Integer getAge() {
       return age;
    }
    public Boolean valid() {
       return age > 18;
    }
}

List<Person> input = new ArrayList<Person>();
input.add(new Person("John", "Valid", 32));
input.add(new Person("John", "InValid", 17));
input.add(new Person("OtherJohn", "Valid", 19));

List<Person> output = validByAge(input)

Che ne dici di Quicksort?

Giava

Quello che segue è un esempio Java trovato tramite una ricerca su Google,

l'URL è http://www.mycstutorials.com/articles/sorting/quicksort

public void quickSort(int array[]) 
// pre: array is full, all elements are non-null integers
// post: the array is sorted in ascending order
{
   quickSort(array, 0, array.length - 1);   // quicksort all the elements in the array
}


public void quickSort(int array[], int start, int end)
{
   int i = start;      // index of left-to-right scan
   int k = end;        // index of right-to-left scan

   if (end - start >= 1)               // check that there are at least two elements to sort
   {
       int pivot = array[start];       // set the pivot as the first element in the partition

       while (k > i)                   // while the scan indices from left and right have not met,
       {
           while (array[i] <= pivot && i <= end && k > i) // from the left, look for the first
              i++;                                        // element greater than the pivot
           while (array[k] > pivot && k >= start && k >= i) // from the right, look for the first
              k--;                                          // element not greater than the pivot
           if (k > i)                  // if the left seekindex is still smaller than
               swap(array, i, k);      // the right index, swap the corresponding elements
       }
       swap(array, start, k);          // after the indices have crossed, swap the last element in
                                       // the left partition with the pivot 
       quickSort(array, start, k - 1); // quicksort the left partition
       quickSort(array, k + 1, end);   // quicksort the right partition
    }
    else // if there is only one element in the partition, do not do any sorting
    {
        return;                        // the array is sorted, so exit
    }
}

public void swap(int array[], int index1, int index2) 
// pre: array is full and index1, index2 < array.length
// post: the values at indices 1 and 2 have been swapped
{
   int temp      = array[index1];      // store the first value in a temp
   array[index1] = array[index2];      // copy the value of the second into the first
   array[index2] = temp;               // copy the value of the temp into the second
}

Scala

Un rapido tentativo di una versione Scala. Stagione aperta per i miglioratori di codice; @)

def qsort(l: List[Int]): List[Int] = {
  l match {
    case Nil         => Nil
    case pivot::tail => qsort(tail.filter(_ < pivot)) ::: pivot :: qsort(tail.filter(_ >= pivot))
  }
}

Mi è piaciuta così tanto la risposta di utente sconosciuto che cercherò di migliorarla. Il codice seguente non è una traduzione diretta dell'esempio Java, ma esegue la stessa operazione con la stessa API.

def wordCount (sc: Scanner, delimiter: String) = {
  val it = new Iterator[String] {
    def next = sc.nextLine()
    def hasNext = sc.hasNextLine()
  }
  val words = it flatMap (_ split delimiter iterator)
  words.toTraversable groupBy identity mapValues (_.size)
}

Mi piace molto il metodo getOrElseUpdate, trovato in mutableMap e mostrato qui, prima Java, senza:

public static Map <String, Integer> wordCount (Scanner sc, String delimiters) {
    Map <String, Integer> dict = new HashMap <String, Integer> ();
            while (sc.hasNextLine ()) {
                    String[] words = sc.nextLine ().split (delimiters);
                    for (String word: words) {
                        if (dict.containsKey (word)) {
                            int count = dict.get (word);
                            dict.put (word, count + 1);
                        } else
                            dict.put (word, 1);
                    }
            }       
    return dict;
}

sì - un WordCount, e qui in scala:

def wordCount (sc: Scanner, delimiter: String) = {
        val dict = new scala.collection.mutable.HashMap [String, Int]()
        while (sc.hasNextLine ()) {
                val words = sc.nextLine.split (delimiter)
                words.foreach (word =>
                      dict.update (word, dict.getOrElseUpdate (word, 0) + 1))
        }
        dict
}

Ed eccolo in Java 8:

public static Map<String, Integer> wordCount(Scanner sc, String delimiters)
{
    Map<String, Integer> dict = new HashMap<>();
    while (sc.hasNextLine())
    {
        String[] words = sc.nextLine().split(delimiters);
        Stream.of(words).forEach(word -> dict.merge(word, 1, Integer::sum));
    }
    return dict;
}

E se vuoi essere funzionale al 100%:

import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;

public static Map<String, Long> wordCount(Scanner sc, String delimiters)
{
    Stream<String> stream = stream(sc.useDelimiter(delimiters));
    return stream.collect(groupingBy(identity(), counting()));
}

public static <T> Stream<T> stream(Iterator<T> iterator)
{
    Spliterator<T> spliterator = Spliterators.spliteratorUnknownSize(iterator, 0);
    return StreamSupport.stream(spliterator, false);
}

filtere sortsono già stati mostrati, ma guarda come si integrano facilmente con la mappa:

    def filterKeywords (sc: Scanner, keywords: List[String]) = {
            val dict = wordCount (sc, "[^A-Za-z]")
            dict.filter (e => keywords.contains (e._1)).toList . sort (_._2 < _._2)
    } 

Questo è un esempio molto semplice: Square integer e poi aggiungili

    public int sumSquare(int[] list) {
        int s = 0;
        for(int i = 0; i < list.length; i++) {
            s += list[i] * list[i]; 
        }
        return s;
    }

In scala:

val ar = Array(1,2,3)
def square(x:Int) = x * x
def add(s:Int,i:Int) = s+i

ar.map(square).foldLeft(0)(add)

La mappa compatta applica la funzione a tutti gli elementi dell'array, quindi:

Array(1,2,3).map(square)
Array[Int] = Array(1, 4, 9)

La piega a sinistra inizierà con 0 come accumulatore (i) e si applicherà add(s,i)a tutti gli elementi (i) dell'array, in modo che:

 Array(1,4,9).foldLeft(0)(add)  // return 14 form 0 + 1 + 4 + 9

Ora questo può essere ulteriormente compattato per:

Array(1,2,3).map(x => x * x ).foldLeft(0)((s,i) => s + i )

Questo non lo proverò in Java (per molto lavoro), trasforma XML in una mappa:

<a>
   <b id="a10">Scala</b>
   <b id="b20">rules</b>
</a>

Un altro liner per ottenere la mappa dall'XML:

val xml = <a><b id="a10">Scala</b><b id="b20">rules</b></a>

val map = xml.child.map( n => (n \ "@id").text -> n.child.text).toMap
// Just to dump it.
for( (k,v) <- map) println(k + " --> " + v)

Problema: è necessario progettare un metodo che eseguirà un dato codice in modo asincrono.

Soluzione in Java :

/**
* This method fires runnables asynchronously
*/
void execAsync(Runnable runnable){
    Executor executor = new Executor() {
        public void execute(Runnable r) {
            new Thread(r).start();
        }
    };
    executor.execute(runnable);
}

...

execAsync(new Runnable() {
            public void run() {
                ...   // put here the code, that need to be executed asynchronously
            }
});

La stessa cosa in Scala (usando gli attori):

def execAsync(body: => Unit): Unit = {
  case object ExecAsync    
  actor {
    start; this ! ExecAsync
    loop {
      react {           
        case ExecAsync => body; stop
      }
    }
  }    
}

...

execAsync{  // expressive syntax - don't need to create anonymous classes
  ...  // put here the code, that need to be executed asynchronously    
}

Lo schema Circuit Breaker di Release It in FaKods di Michael Nygard ( collegamento al codice )

l'implementazione è simile a questa in Scala:

. . .
addCircuitBreaker("test", CircuitBreakerConfiguration(100,10))
. . .


class Test extends UsingCircuitBreaker {
  def myMethodWorkingFine = {
    withCircuitBreaker("test") {
      . . .
    }
  }

  def myMethodDoingWrong = {
    withCircuitBreaker("test") {
      require(false,"FUBAR!!!")
    }
  }
}

Che penso sia super carino. Sembra solo un pezzo del linguaggio, ma è un semplice mixin nell'oggetto CircuitBreaker che fa tutto il lavoro.

/**
 * Basic MixIn for using CircuitBreaker Scope method
 *
 * @author Christopher Schmidt
 */
trait UsingCircuitBreaker {
  def withCircuitBreaker[T](name: String)(f: => T): T = {
    CircuitBreaker(name).invoke(f)
  }
}

Riferimento in altre lingue Google per "Circuit breaker" + la tua lingua.

Sto preparando un documento che fornisce diversi esempi di codice Java e Scala, utilizzando solo le caratteristiche di semplice comprensione di Scala:

Scala: un Java migliore

Se desideri che aggiunga qualcosa, rispondi nei commenti.

Perché nessuno lo ha pubblicato prima:

Giava:

class Hello {
     public static void main( String [] args ) {
          System.out.println("Hello world");
     }
}

116 caratteri.

Scala:

object Hello extends App {
     println("Hello world")
}

56 caratteri.

I flussi infiniti valutati pigramente sono un buon esempio:

object Main extends Application {

   def from(n: Int): Stream[Int] = Stream.cons(n, from(n + 1))

   def sieve(s: Stream[Int]): Stream[Int] =
     Stream.cons(s.head, sieve(s.tail filter { _ % s.head != 0 }))

   def primes = sieve(from(2))

   primes take 10 print

}

Ecco una domanda che si rivolge a flussi infiniti in Java: un iteratore infinito è un cattivo design?

Un altro buon esempio sono le funzioni e le chiusure di prima classe:

scala> def f1(w:Double) = (d:Double) => math.sin(d) * w
f1: (w: Double)(Double) => Double

scala> def f2(w:Double, q:Double) = (d:Double) => d * q * w
f2: (w: Double,q: Double)(Double) => Double

scala> val l = List(f1(3.0), f2(4.0, 0.5))
l: List[(Double) => Double] = List(<function1>, <function1>)

scala> l.map(_(2))
res0: List[Double] = List(2.727892280477045, 4.0)

Java non supporta le funzioni di prima classe e imitare le chiusure con classi interne anonime non è molto elegante. Un'altra cosa che questo esempio mostra che java non può fare è eseguire codice da un interprete / REPL. Lo trovo immensamente utile per testare rapidamente frammenti di codice.

Questo codice Scala ...

def partition[T](items: List[T], p: (T, T) => Boolean): List[List[T]] = {
  items.foldRight[List[List[T]]](Nil)((item: T, items: List[List[T]]) => items match {
    case (first :: rest) :: last if p (first, item) =>
      (List(item)) :: (first :: rest) :: last
    case (first :: rest) :: last =>
      (item :: first :: rest) :: last
    case _ => List(List(item))
  })
}

... sarebbe completamente illeggibile in Java, se possibile.