TOC

Guava 18: Quoi de neuf?

Guava 18: Quoi de neuf?

1. Vue d'ensemble

Google Guava fournit aux bibliothèques des utilitaires qui facilitent le développement Java. Dans ce didacticiel, nous examinerons les nouvelles fonctionnalités introduites dans lesGuava 18 release.

2. Classe d'utilitéMoreObjects

Guava 18 a vu l'ajout de la classeMoreObjects, qui contient des méthodes qui n'ont pas d'équivalents enjava.util.Objects.

Depuis la version 18, il ne contient que des implémentations de la méthodetoStringHelper, qui peut être utilisée pour vous aider à construire vos propres méthodestoString.

  • toStringHelper (Classe clazz)

  • toStringHelper (objet self)

  • toStringHelper (chaîne nom_classe)

En général,toString() est utilisé lorsque vous avez besoin de sortir des informations sur un objet. Il doit généralement contenir des détails sur l'état actuel de l'objet. En utilisant l'une des implémentations detoStringHelper, vous pouvez facilement créer un messagetoString() utile.

Supposons que nous ayons un objetUser contenant quelques champs qui doivent être écrits lorsquetoString() est appelé. Nous pouvons utiliser la méthodeMoreObjects.toStringHelper(Object self) pour le faire facilement. 

public class User {

    private long id;
    private String name;

    public User(long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
            .add("id", id)
            .add("name", name)
            .toString();
    }
}

Ici, nous avons utilisé la méthodetoStringHelper(Object self). Avec cette configuration, nous pouvons créer un exemple d'utilisateur pour voir la sortie qui en résulte lors de l'appel detoString(). 

User user = new User(12L, "John Doe");
String userState = user.toString();
// userState: User{ id=12,name=John Doe }

Les deux autres implémentations renverront les mêmesString si elles sont configurées de manière similaire:

toStringHelper (Classe clazz) 

@Override
public String toString() {
    return MoreObjects.toStringHelper(User.class)
        .add("id", id)
        .add("name", name)
        .toString();
}

toStringHelper (chaîne nom_classe) 

@Override
public String toString() {
    return MoreObjects.toStringHelper("User")
        .add("id", id)
        .add("name", name)
        .toString();
}

La différence entre ces méthodes est évidente si vous appeleztoString() sur des extensions de la classeUser. Par exemple, si vous avez deux types deUsers:Administrator etPlayer, ils produiront une sortie différente. __ 

public class Player extends User {
    public Player(long id, String name) {
        super(id, name);
    }
}

public class Administrator extends User {
    public Administrator(long id, String name) {
        super(id, name);
    }
}

Si vous utiliseztoStringHelper(Object self) dans la classeUser, vosPlayer.toString() renverront «Player\{id=12, name=John Doe}». Cependant, si vous utiliseztoStringHelper(String className) outoStringHelper(Class<?> clazz),Player.toString() renverra «User\{id=12, name=John Doe}». Le nom de classe indiqué sera la classe parente plutôt que la sous-classe.

3. Nouvelles méthodes enFluentIterable

3.1. Vue d'ensemble

FluentIterable est utilisé pour fonctionner avec les instancesIterable de manière chaînée. Permet de voir comment il peut être utilisé.

Supposons que vous ayez une liste d'objetsUser, définie dans les exemples ci-dessus, et que vous souhaitiez filtrer cette liste pour n'inclure que les utilisateurs âgés de 18 ans ou plus. 

List users = new ArrayList<>();
users.add(new User(1L, "John", 45));
users.add(new User(2L, "Michelle", 27));
users.add(new User(3L, "Max", 16));
users.add(new User(4L, "Sue", 10));
users.add(new User(5L, "Bill", 65));

Predicate byAge = user -> user.getAge() >= 18;

List results = FluentIterable.from(users)
                           .filter(byAge)
                           .transform(Functions.toStringFunction())
                           .toList();

La liste résultante contiendra les informations pour John, Michelle et Bill.

3.2. FluentIterable.of(E[])

Avec cette méthode. vous pouvez créer unFluentIterable à partir du tableau deObject. 

User[] usersArray = { new User(1L, "John", 45), new User(2L, "Max", 15) } ;
FluentIterable users = FluentIterable.of(usersArray);

Vous pouvez maintenant utiliser les méthodes fournies dans l'interfaceFluentIterable.

3.3. FluentIterable.append(E…)

Vous pouvez créer de nouveauxFluentIterable à partir deFluentIterable existants en y ajoutant plus d'éléments. 

User[] usersArray = {new User(1L, "John", 45), new User(2L, "Max", 15)};

FluentIterable users = FluentIterable.of(usersArray).append(
                                 new User(3L, "Sue", 23),
                                 new User(4L, "Bill", 17)
                             );

Comme prévu, la taille desFluentIterable résultants est de 4.

3.4. FluentIterable.append(Iterable<? extends E>)>

Cette méthode se comporte de la même manière que l'exemple précédent, mais vous permet d'ajouter tout le contenu de toute implémentation existante deIterable à unFluentIterable. 

User[] usersArray = { new User(1L, "John", 45), new User(2L, "Max", 15) };

List usersList = new ArrayList<>();
usersList.add(new User(3L, "Diana", 32));

FluentIterable users = FluentIterable.of(usersArray).append(usersList);

Comme prévu, la taille desFluentIterable résultants est de 3.

3.5. FluentIterable.join(Joiner)

La méthodeFluentIterable.join(…) produit unString représentant tout le contenu desFluentIterable, joint par unString donné. 

User[] usersArray = { new User(1L, "John", 45), new User(2L, "Max", 15) };
FluentIterable users = FluentIterable.of(usersArray);
String usersString = users.join(Joiner.on("; "));

La variableusersString contiendra la sortie de l'appel de la méthodetoString() sur chaque élément desFluentIterable, séparés par un «;». La classeJoiner fournit plusieurs options pour joindre les chaînes.

4. Hashing.crc32c

Une fonction de hachage est une fonction qui peut être utilisée pour mapper des données de taille arbitraire à des données de taille fixe. Il est utilisé dans de nombreux domaines, tels que la cryptographie et la recherche d’erreurs dans les données transmises.

La méthodeHashing.crc32c renvoie unHashFunction qui implémente lesCRC32C algorithm. 

int receivedData = 123;
HashCode hashCode = Hashing.crc32c().hashInt(receivedData);
// hashCode: 495be649

5. InetAddresses.decrement(InetAddress)

Cette méthode renvoie un nouveauInetAddress qui sera «un de moins» que son entrée. 

InetAddress address = InetAddress.getByName("127.0.0.5");
InetAddress decrementedAddress = InetAddresses.decrement(address);
// decrementedAddress: 127.0.0.4

6. Nouveaux exécuteurs dansMoreExecutors __

6.1. Revue de filetage

En Java, vous pouvez utiliser plusieurs threads pour exécuter le travail. Pour cela, Java a les classesThread etRunnable. 

ConcurrentHashMap threadExecutions = new ConcurrentHashMap<>();
Runnable logThreadRun = () -> threadExecutions.put(Thread.currentThread().getName(), true);

Thread t = new Thread(logThreadRun);
t.run();

Boolean isThreadExecuted = threadExecutions.get("main");

Comme prévu,isThreadExecuted seratrue. Vous pouvez également voir que ceRunnable ne fonctionnera que dans le threadmain. Si vous souhaitez utiliser plusieurs threads, vous pouvez utiliser différentsExecutors à des fins différentes. 

ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.submit(logThreadRun);
executorService.submit(logThreadRun);
executorService.shutdown();

Boolean isThread1Executed = threadExecutions.get("pool-1-thread-1");
Boolean isThread2Executed = threadExecutions.get("pool-1-thread-2");
// isThread1Executed: true
// isThread2Executed: true

Dans cet exemple, tout le travail soumis est exécuté dans les threadsThreadPool.

Guava fournit différentes méthodes dans sa classeMoreExecutors.

6.2. MoreExecutors.directExecutor()

Il s'agit d'un exécuteur léger qui peut exécuter des tâches sur le thread qui appelle la méthodeexecute. 

Executor executor = MoreExecutors.directExecutor();
executor.execute(logThreadRun);

Boolean isThreadExecuted = threadExecutions.get("main");
// isThreadExecuted: true

6.3. MoreExecutors.newDirectExecutorService()

Cette méthode renvoie une instance deListeningExecutorService. C'est une implémentation plus lourde deExecutor qui a de nombreuses méthodes utiles. Elle est similaire à la méthode obsolètesameThreadExecutor() des versions précédentes de Guava.

CeExecutorService exécutera des tâches sur le thread qui appelle la méthodeexecute(). 

ListeningExecutorService executor = MoreExecutors.newDirectExecutorService();
executor.execute(logThreadRun);

Cet exécuteur a de nombreuses méthodes utiles telles queinvokeAll, invokeAny, awaitTermination, submit, isShutdown, isTerminated, shutdown, shutdownNow.

7. Conclusion

Guava 18 a introduit plusieurs ajouts et améliorations à sa bibliothèque croissante de fonctionnalités utiles. Cela vaut bien la peine d'être envisagé pour votre prochain projet. Les exemples de code de cet article sont disponiblesin the GitHub repository.

Related