Fonte de l'Optionnel<> ArrayList<>

J'ai la situation suivante:

public ArrayList<A> getMethods(){
    return b.c.test();
}

Donc, mon problème est que b.c.test() renvoie une valeur avec Optional<A> comme type de retour. Mais j'ai besoin de retourner un ArrayList<A>.

Donc, j'ai essayé de le jeter et de le réécrire :

public ArrayList<A> getMethods(){
    return (ArrayList<A>)b.c.test();
}

Mais Eclipse dit qu'un tel casting de Optional<A> à ArrayList<A> est pas possible.

Comment puis-je résoudre ce problème?

Eh bien oui, un Optional n'est pas un ArrayList, ils ont certainement ne peut pas être lancé. Que voulez-vous dire que vous "ne pouvez pas le changer"? Qu'est-ce que "il" et pourquoi ne peut-il être changé?
qu'est-ce que Optianal<A> ?
docs.oracle.com/javase/8/docs/api/java/util/Optional.html
il n'est pas une Collection, qu'entendez-vous par "cast" à ArrayList ?
est Optianal<A>?", si votre question est générale: elle est très belle chose ajoutée de la Goyave de Java 8. Il hleps nous éviter de ing null code.google.com/p/guava-libraries/wiki/...

OriginalL'auteur user3097712 | 2015-07-28

17

Je suis en supposant que votre objectif sémantique est 'si la valeur est présente retourner une liste avec un seul élément, sinon renvoyer une liste vide.' Dans ce cas, je suggère quelque chose comme ce qui suit:
```
ArrayList<A> result = new ArrayList<>();
b.c.test().ifPresent(result::add);
return result;
```
Cependant, je voudrais suggérer à votre type de retour doit être List<A> plutôt que ArrayList<A> comme qui vous donne la possibilité de changer le type de liste sans changer les appelants. Il permettrait également de retour Collections.EMPTY_LIST si la valeur facultative n'est pas présent, ce qui est plus efficace que la création d'un inutile ArrayList.

Mise à jour: il y a maintenant une option plus facile avec Java 9:
```
b.c.test().stream().collect(Collectors.toList());
```
OriginalL'auteur sprinter
3

Si tout le monde insiste sur l'utilisation de flux pour cette question, il devrait être plus idiomatique que d'utiliser ifPresent()
Malheureusement, Java 8, n'ont pas de Optional.stream() méthode, de sorte qu'il n'est pas possible de le faire:
```
 optional.stream().collect(Collectors.toList());
```
voir aussi: À l'aide de Java 8, en Option, avec Stream::flatMap

Mais dans le JDK 9, il sera ajouté (et que le code s'exécute déjà sur Java 9)
```
Optional<Integer> o = Optional.empty();
final List<Integer> list = o.stream().collect(Collectors.toList());
System.out.println(list);
```
OriginalL'auteur user140547
2
```
return b.c.test()
    .map(Arrays::asList).map(ArrayList::new)
    .orElseGet(ArrayList::new);
```
Si l'option a une valeur, il "cartes" à une List<A> avec Arrays.asList et puis à un ArrayList via le new ArrayList<A>(List<A>) constructeur; sinon il fournit un vide ArrayList par le constructeur vide.

Cela pourrait être plus explicitement écrit que:
```
return b.c.test()
    .map(value -> new ArrayList<A>(Arrays.asList(value)))
    .orElseGet(() -> new ArrayList<A>());
```
Cela semble trop verbeux; n'est-ce pas en fait mauvais usage de Java 8 fonctionnelle des expressions idiomatiques pour une tâche très simple?
Je ne sais pas, j'aime ce style. J'aime l'absence de variables temporaires. Je vois la complexité comme une conséquence de la trop spécifiques type de retour. Si c'était List au lieu de ArrayList ce qui pourrait être écrit plus simplement: map(Collections::singletonList).orElseGet(Collections::emptyList). J'aime la façon que l'air.
OMI, la variable temporaire dans @sprinter réponse rend le code plus lisible (et beaucoup plus concis). map et orElseGet sont utiles -- lorsque utilisé dans le bon endroit. Votre solution m'a rappelé les mises en garde présentées dans Goyave est de Fonctionnelles Expliqué -- code impératif doit être la valeur par défaut, même dans Java 8.

OriginalL'auteur John Kugelman

Dans ce cas, il est possible de ne pas utiliser les flux à tous:

public static <T> List<T> toList(Optional<T> opt) {
    return opt.isPresent()
            ? Collections.singletonList(opt.get())
            : Collections.emptyList();
}

Ou, le même code à l'aide de la fonctionnelle de l'API:

public static <T> List<T> toList(Optional<T> opt) {
    return opt
            .map(Collections::singletonList)
            .orElseGet(Collections::emptyList);
}

Je préfère la partie supérieure de la variante parce que je sais pour sûr qu'il ne crée pas d'objets inutiles sur le tas Java.

OriginalL'auteur Roland Illig

0

Si vous utilisez la Goyave est Facultatif, vous pouvez le faire:
```
return new ArrayList<>(b.c.test().asSet());
```
Cela permettra d'extraire la valeur de la Optional (si présent) et l'ajouter à un nouveau ArrayList.

Si vous êtes à l'aide de Java 8, @sprinter réponse est ce que vous avez besoin.

OriginalL'auteur dimo414
0

Une Option est un objet conteneur qui peut contenir ou non une valeur non null.

Dans ArrayList termes, je voudrais le traduire comme un tableau qui a 0 ou 1 membres.
```
public ArrayList<A> getMethods(){
  Optional<A> opt = b.c.test();
  ArrayList<A> res = new ArrayList<>();
  if ( opt.isPresent() )
    res.add( opt.get() );
  return res;
}
```
Optional.empty() c'est une méthode statique qui renvoie un nouveau, vide Optional. Vous voulez Optional.isPresent(). Il y a également nettoyeur de façons de le faire (@sprinter de la réponse).
En effet, vous avez raison dans les deux comptes.
Je pense que tu veux dire if (opt.isPresent()) plutôt que if (!opt.isPresent()). Pour l'instant, cette lèvera une exception lorsque vous essayez de get et vide en option.
Bien sûr, c'est ce qui se passe pour la modification à l'aveuglette !opt.empty() pour !opt.isPresent().

OriginalL'auteur Jose Antonio Dura Olmos

Avec Java9, vous pouvez faire cela en utilisant le nouvellement ajouté Optional::stream API :

Optional<List<A>> list;
List<A> collect = list.stream()
               .flatMap(Optional::stream)
               .collect(Collectors.toList());

OriginalL'auteur Niraj Sonawane

Vous devez vous connecter pour publier un commentaire.