Des exemples de code Scala et Java où le code Scala semble plus simple/avec moins de lignes ?

Question

J'ai besoin d'échantillons de code (et je suis aussi très curieux à leur sujet) de Scala et de Java qui montrent que le code Scala est plus simple et plus concis que le code écrit en Java (bien sûr, les deux échantillons doivent résoudre le même problème).

S'il n'y a qu'un exemple en Scala avec un commentaire du type "il s'agit d'une fabrique abstraite en Scala, en Java elle sera beaucoup plus encombrante", c'est également acceptable.

Merci !

J'aime surtout être accepté et este réponses

Answer 1

Améliorons Exemple d'un empileur et utiliser l'outil de Scala classes de cas :

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

La classe Scala ci-dessus contient toutes les caractéristiques de la classe Java ci-dessous, et d'autres encore - par exemple, il prend en charge filtrage par motif (que Java ne possède pas). Scala 2.8 ajoute des arguments nommés et des arguments par défaut, qui sont utilisés pour générer un argument de type méthode de copie pour les classes de cas, ce qui donne la même capacité que les méthodes with* de la classe Java suivante.

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

Ensuite, dans l'usage, nous avons (bien sûr) :

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

Contre

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

Answer 2

J'ai trouvé celui-ci impressionnant

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)

Ainsi que ceux-là (désolé de ne pas avoir collé, je ne voulais pas voler le code)

• Queens-Problem Java
• Queens-Problem Scala

Answer 3

Tâche : Écrivez un programme pour indexer une liste de mots-clés (comme des livres).

Explication :

• Entrée : Liste<String>
• Sortie : Carte<Caractère, Liste<Chaîne>>.
• La clé de la carte est 'A' à 'Z'.
• Chaque liste de la carte est triée.

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

Answer 4

Tâche :

Vous avez une liste people d'objets de la classe Person qui a des champs name y age . Votre tâche consiste à trier cette liste d'abord par name et ensuite par 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))

Java 8 :

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

Answer 5

Tâche :

Vous avez un fichier XML "company.xml" qui ressemble à ceci :

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

Vous devez lire ce fichier et imprimer le firstName y lastName les champs de tous les employés.

Java : [extrait 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 : [extrait de aquí , slide #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 par Bill ; Voir les commentaires pour la discussion ] --

Hmm, comment le faire sans répondre dans une section de réponse non formatée... Hmph. Je suppose que je vais éditer ta réponse et te laisser la supprimer si ça te dérange.

C'est ainsi que je le ferais en Java avec de meilleures bibliothèques :

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

Il s'agit juste d'un hack rapide n'impliquant aucune magie et tous les composants sont réutilisables. Si je voulais ajouter un peu de magie, je pourrais faire quelque chose de mieux que de renvoyer un tableau de chaînes de caractères, mais même telle quelle, cette GoodXMLLib serait complètement réutilisable. Le premier paramètre de scanFor est la section, tous les paramètres suivants seraient les éléments à trouver, ce qui est limité, mais l'interface pourrait être légèrement améliorée pour ajouter plusieurs niveaux de correspondance sans réel problème.

J'admets que Java dispose d'un support de bibliothèque assez médiocre en général, mais allez - comparer une utilisation horrible de la bibliothèque XML de Java vieille de dix ( ?) ans à une mise en œuvre basée sur le laconisme n'est tout simplement pas juste - et est loin d'être une comparaison des langages !