Necesito algunas muestras de código (y también tengo mucha curiosidad por ellas) de código Scala y Java que muestran que el código Scala es más simple y conciso que el código escrito en Java (por supuesto, ambas muestras deberían resolver el mismo problema).

Si solo hay una muestra de Scala con comentarios como "esto es una fábrica abstracta en Scala, en Java se verá mucho más complicado", entonces esto también es aceptable.

¡Gracias!

Me gusta sobre todo aceptado y esto responde

Mejoremos el ejemplo del apilador y usemos las clases de casos de Scala :

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

La clase de Scala anterior contiene todas las características de la siguiente clase de Java y algunas más ; por ejemplo, admite la coincidencia de patrones (que Java no tiene). Scala 2.8 agrega argumentos con nombre y predeterminados, que se utilizan para generar un método de copia para clases de casos, que brinda la misma capacidad que los métodos with * de la siguiente clase 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 + ")";
    }
}

Entonces, en uso tenemos (por supuesto):

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

En contra

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

Encontré este impresionante

Java

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)

Además de estos (perdón por no pegar, no quería robar el código)

• Reinas-Problema Java
• Scala del problema de las reinas

Tarea: escriba un programa para indexar una lista de palabras clave (como libros).

Explicación:

• Entrada: Lista <String>
• Salida: Mapa <Carácter, Lista <String>>
• La clave del mapa es 'A' a 'Z'
• Cada lista del mapa está ordenada.

Java:

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

Tarea:

Tienes una lista peoplede objetos de clase Personque tiene campos namey age. Su tarea es ordenar esta lista primero por namey luego por 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))

Actualizar

Desde que escribí esta respuesta, ha habido bastante progreso. Las lambdas (y las referencias de métodos) finalmente aterrizaron en Java, y están tomando el mundo de Java por asalto.

Así es como se verá el código anterior con Java 8 (contribuido por @fredoverflow):

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

Si bien este código es casi tan corto, no funciona con tanta elegancia como el de Scala.

En la solución Scala, el Seq[A]#sortBymétodo acepta una función A => Bdonde Bse requiere tener un Ordering. Orderinges una clase de tipo. Piense lo mejor de ambos mundos: Comparablees implícito para el tipo en cuestión, pero Comparatores extensible y se puede agregar retrospectivamente a los tipos que no lo tenían. Dado que Java carece de clases de tipos, tiene que duplicar cada uno de esos métodos, una vez por Comparabley luego por Comparator. Por ejemplo, vea comparingy thenComparing aquí .

Las clases de tipos permiten escribir reglas como "Si A tiene orden y B tiene orden, entonces su tupla (A, B) también tiene orden". En código, eso es:

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

Así es como sortByen nuestro código se puede comparar por nombre y luego por edad. Esa semántica se codificará con la "regla" anterior. Un programador de Scala esperaría intuitivamente que esto funcionara de esta manera. No se comparingtuvo que agregar ningún método de propósito especial como Ordering.

Las lambdas y las referencias a métodos son solo la punta de un iceberg que es la programación funcional. :)

Tarea:

Tiene un archivo XML "company.xml" que se parece a esto:

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

Tienes que leer este archivo e imprimir los campos firstNamey lastNamede todos los empleados.


Java: [tomado de aquí ]

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: [tomado de aquí , diapositiva n. ° 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)
        } 
      }
    }
  }
}

[EDITAR por Bill; Verifique los comentarios para la discusión] -

Hmm, cómo hacerlo sin responder en una sección de respuesta sin formato ... Hmph. Supongo que editaré tu respuesta y te dejaré eliminarla si te molesta.

Así es como lo haría en Java con mejores bibliotecas:

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

Este es solo un truco rápido que no involucra magia y todos los componentes reutilizables. Si quisiera agregar algo de magia, podría hacer algo mejor que devolver una matriz de matrices de cadenas, pero incluso así, este GoodXMLLib sería completamente reutilizable. El primer parámetro de scanFor es la sección, todos los parámetros futuros serían los elementos a encontrar que son limitados, pero la interfaz podría mejorarse ligeramente para agregar múltiples niveles de coincidencia sin ningún problema real.

Admitiré que Java tiene un soporte de biblioteca bastante deficiente en general, pero vamos, comparar un uso horrible de la biblioteca XML de una década (?) De Java con una implementación basada en ser conciso simplemente no es justo, y está lejos a partir de una comparación de idiomas!

Un mapa de acciones a realizar en función de una cadena.

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

¡Y todo está hecho con el mejor sabor posible!

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

Estoy escribiendo un juego de Blackjack en Scala ahora. Así es como se vería mi método dealerWins en Java:

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

Así es como se ve en Scala:

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

¡Hurra por las funciones de orden superior!

Solución Java 8:

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

Me gustó este simple ejemplo de clasificación y transformación, tomado del libro 'Beginning Scala' de David Pollak:

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

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

¿Qué tal Quicksort?

Java

El siguiente es un ejemplo de Java encontrado a través de una búsqueda de Google,

la URL es 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 intento rápido de una versión de Scala. Temporada abierta para mejoradores de código; @)

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

Me gustó tanto la respuesta del usuario desconocido que voy a intentar mejorarla. El código siguiente no es una traducción directa del ejemplo de Java, pero realiza la misma tarea con la misma 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)
}

Me gusta mucho el método getOrElseUpdate, que se encuentra en mutableMap y se muestra aquí, primero en Java, sin:

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, y aquí en 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
}

Y aquí está en 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;
}

Y si quieres ir 100% funcional:

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

filtery sortya se han mostrado, pero mira lo fácil que se integran con el mapa:

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

Este es un ejemplo muy simple: cuadrados enteros y luego sumarlos

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

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

El mapa compacto aplica la función a todos los elementos de la matriz, por lo que:

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

Doblar a la izquierda comenzará con 0 como acumulador (es) y se aplicará add(s,i)a todos los elementos (i) de la matriz, de modo que:

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

Ahora esto se puede compactar aún más para:

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

Este no lo probaré en Java (mucho trabajo), convertir XML en un mapa:

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

Otro trazador de líneas para obtener el mapa del 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: necesita diseñar un método que ejecute cualquier código dado de forma asincrónica.

Solución en 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
            }
});

Lo mismo en Scala (usando actores):

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    
}

El patrón de disyuntor de Release It de Michael Nygard en FaKods ( enlace al código )

La implementación se ve así en Scala:

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


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

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

Lo que creo que es super bonito. Parece una parte del lenguaje, pero es una simple combinación en el objeto CircuitBreaker que hace todo el trabajo.

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

Referencia en otros idiomas de Google para "Disyuntor" + su idioma.

Estoy preparando un documento que da varios ejemplos de código Java y Scala, utilizando solo las características simples de entender de Scala:

Scala: un Java mejor

Si desea que agregue algo, responda en los comentarios.

Por qué nadie publicó esto antes:

Java:

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

116 caracteres.

Scala:

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

56 caracteres.

Los flujos infinitos evaluados con pereza son un buen ejemplo:

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

}

Aquí hay una pregunta que aborda flujos infinitos en Java: ¿Es un iterador infinito un mal diseño?

Otro buen ejemplo son las funciones y cierres de primera clase:

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 no admite funciones de primera clase y la imitación de cierres con clases internas anónimas no es muy elegante. Otra cosa que este ejemplo muestra que java no puede hacer es ejecutar código desde un intérprete / REPL. Encuentro esto inmensamente útil para probar rápidamente fragmentos de código.

Este código 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))
  })
}

... sería completamente ilegible en Java, si es posible.