filtrage d'une liste de tableaux à l'aide d'un objet de champ

J'ai une liste de tableaux qui est rempli par les Objets.

Ma classe d'objet appelé Article qui a deux champs ;

public class Article {

    private int codeArt;
    private String desArt;

  public Article(int aInt, String string) {
        this.desArt = string;
        this.codeArt = aInt;
    }

    public int getCodeArt() {return codeArt; }
    public void setCodeArt(int codeArt) {this.codeArt = codeArt;}
    public String getDesArt() {return desArt;}
    public void setDesArt(String desArt) { this.desArt = desArt;}

}

Je veux filtrer ma Liste à l'aide de la desArt champ, et pour le test j'ai utilisé la Chaîne "test".

J'ai utilisé la Goyave de google qui me permet de filtrer une liste de tableaux.

c'est le code que j'ai essayé :

private List<gestionstock.Article> listArticles = new ArrayList<>();

//Here the I've filled my ArrayList

private List<gestionstock.Article> filteredList filteredList = Lists.newArrayList(Collections2.filter(listArticles, Predicates.containsPattern("test")));

mais ce code ne fonctionne pas.

Comment n'est-il pas de travail? Je parierais pour une erreur de compilation...
parce que je suis filtrage à l'aide d'une chaîne, j'ai t filtre à l'aide de l'objet, mais je ne sais pas comment le faire.
Vous devez mettre en place votre propre Predicate, aucun de ceux fournis par Predicates (sauf pour notNull()/isNull()) sera en mesure de filtrer votre objet dans une manière significative. Avez-vous lu Fonctionnelle expliqué?
Je ne suis pas aussi familier que je devrais être avec la Goyave de la bibliothèque, mais je pense que vous devez utiliser le Prédicat.composer(Prédicat<B> prédicat, la Fonction<Un,? extends B> function) pour créer une nouvelle fonction pour tester si le champ est correct. Je vais poster une réponse en quelques minutes, avec une sorte de solution exacte. Mais d'après ce que je comprends, c'est ce que vous devriez faire.

OriginalL'auteur Aimad Majdou | 2013-05-31

C'est normal: Les prédicats.containsPattern() fonctionne sur CharSequences, votre gestionStock.Article objet n'est pas de mettre en œuvre.

Vous devez écrire votre propre prédicat:

public final class ArticleFilter
    implements Predicate<gestionstock.Article>
{
    private final Pattern pattern;

    public ArticleFilter(final String regex)
    {
        pattern = Pattern.compile(regex);
    }

    @Override
    public boolean apply(final gestionstock.Article input)
    {
        return pattern.matcher(input.getDesArt()).find();
    }
}

Alors utiliser:

 private List<gestionstock.Article> filteredList
     = Lists.newArrayList(Collections2.filter(listArticles,     
         new ArticleFilter("test")));

Cependant, c'est tout à fait un peu de code pour quelque chose qui peut être fait dans beaucoup moins de code à l'aide de la non programmation fonctionnelle, comme l'a démontré par @mgnyp...

qu'est-ce que les Listes ici?
c'est la Goyave est Lists, puisque la question est à propos de Goyave
merci u got it et de construire avec gradle

OriginalL'auteur fge

Dans Java 8, à l'aide de filtre

List<Article> articleList = new ArrayList<Article>();
List<Article> filteredArticleList= articleList.stream().filter(article -> article.getDesArt().contains("test")).collect(Collectors.toList());

sans l'aide de lamda expression sera reconnaissant 🙂

OriginalL'auteur Free-Minded

Vous pouvez utiliser une boucle for ou pour chaque boucle pour boucle à travers la liste.
Voulez-vous créer une liste basée sur une condition?
Cela devrait fonctionner je pense.

List<Article> secondList = new ArrayList<Article>();

for( Article a : listArticles) { 
//or equalsIgnoreCase or whatever your conditon is
if (a.getDesArt().equals("some String")) {
//do something 
secondList.add(a);
}
}

OriginalL'auteur monika

2

Goyave est une bibliothèque qui vous permet d'utiliser certaines techniques de programmation en Java.
L'une des gagnantes de choses dans la programmation fonctionnelle est la collecte de transformation comme

Collection -> op> op> op> transformedCollection.

Regardez ici:
```
Collection<Article> filtered = from(listArticles).filter(myPredicate1).filter(myPredicate2).filter(myPredicate3).toImmutableList();
```
C'est beau, n'est-ce pas?

La deuxième chose gagnante est lambda fonctions. Regardez ici:
```
Collection<Article> filtered = from(listArticles)
  .filter((Predicate) (candidate) -> { return candidate.getCodeArt() > SOME_VALUE })
  .toImmutableList();
```
En fait, Java n'a pas pur lambda fonctions encore. Nous serons en mesure de le faire en Java 8. Mais pour l'instant, nous pouvons écrire cette IDE Inellij Idée, IDE et transforme ces lambda dans Prédicat, créé à la volée:
```
Collection<Article> filtered = from(listArticles)
        .filter(new Predicate<Article>() {
            @Override
            public boolean apply(Article candidate) {
                return candidate.getCodeArt() > SOME_VALUE;
            }
        })
        .toImmutableList();
```
Si votre condition de filtre nécessite regexp, le code est devenue plus compliquée, et vous aurez besoin de déplacer la condition de séparer méthode ou de déplacer tout un ensemble de Prédicat à une catégorie distincte.

Si tout cela de la programmation fonctionnelle semble trop compliqué, il suffit de créer une nouvelle collection et le remplir manuellement (sans Goyave):
```
List<Article> filtered = new ArrayList<Article>();
for(Article article : listArticles)
{
    if(article.getCodeArt() > SOME_VALUE)
        filtered.add(article);
}
```
C'est pas compliqué, c'est juste obfucated.

OriginalL'auteur n00bot

Avec la Goyave, je dirais que la façon la plus simple et de loin, serait en utilisant Collections2.filtre, tels que:

Collections2.filter(YOUR_COLLECTION, new Predicate<YOUR_OBJECT>() {
  @Override
  public boolean apply(YOUR_OBJECT candidate) {
    return SOME_ATTRIBUTE.equals(candidate.getAttribute());
  }
});

OriginalL'auteur facundofarias

Essayez ceci:

private List<gestionstock.Article> listArticles = new ArrayList<>();
private List<gestionstock.Article> filteredList filteredList = Lists.newArrayList(Collections2.filter(listArticles, new Predicate<gestionstock.Article>(){
        public boolean apply(gestationstock.Article article){
            return article.getDesArt().contains("test")
        }
    }));

L'idée est depuis que vous êtes à l'aide d'un objet personnalisé, vous devez mettre en place votre propre prédicat. Si vous l'utilisez n'importe où ailleurs, de définir dans un fichier, sinon, cette application fonctionne très bien.

OriginalL'auteur cxdf

Vous devez vous connecter pour publier un commentaire.