Java 使用对象过滤ArrayList'；s场

我有一个由对象填充的ArrayList

我的对象类名为

Article

，它有两个字段

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

}

我想使用

desArt

字段过滤我的列表，对于测试，我使用字符串“test”

我使用了谷歌的番石榴，可以过滤ArrayList

这是我尝试的代码：

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

私有列表listArticles=new ArrayList（）；
//在这里，我已经填写了我的ArrayList
private List filteredList filteredList=Lists.newArrayList（Collections2.filter（listArticles，谓词.containsPattern（“test”））；

---

但此代码不起作用。

您可以使用for循环或for each循环遍历列表。 是否要根据某些条件创建另一个列表？ 我想这应该行得通

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

List secondList=new ArrayList（）；
（a条：清单条款）{
//或同等信号或任何你的情况
if（a.getDesArt（）.equals（“某个字符串”））{
//做点什么
第二名单。添加（a）；
}
}

这是正常的：在

CharSequence

s上操作，而您的

gestionStock.Article

对象没有实现

您需要编写自己的谓词：

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

公共最终类ArticleFilter
实现谓词
{
私人最终模式；
公共ArticleFilter（最终字符串正则表达式）
{
pattern=pattern.compile（regex）；
}
@凌驾
公共布尔应用（最终gestionstock.Article输入）
{
返回pattern.matcher（input.getDesArt（））.find（）；
}
}

然后使用：

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

private List filteredList
=Lists.newArrayList（Collections2.filter（listArticles，
新产品过滤器（“测试”）；

然而，这是一些可以用更少的代码使用非函数式编程完成的代码，如@mgnyp…

所示，尝试以下方法：

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

私有列表listArticles=new ArrayList（）；
private List filteredList filteredList=Lists.newArrayList（Collections2.filter（listArticles，new Predicate（））{
公共布尔应用（gestationstock.Article）{
return article.getDesArt（）包含（“测试”）
}
}));

---

因为您使用的是自定义对象，所以应该实现自己的谓词。如果您在其他任何地方使用它，请在文件中定义它，否则，此实现工作得很好

Guava是一个库，允许您使用Java中的一些函数式编程。 函数式编程中最成功的事情之一是像

集合->操作->操作->操作->转换集合

看这里：

Collection<Article> filtered = from(listArticles).filter(myPredicate1).filter(myPredicate2).filter(myPredicate3).toImmutableList();

Collection<Article> filtered = from(listArticles)
  .filter((Predicate) (candidate) -> { return candidate.getCodeArt() > SOME_VALUE })
  .toImmutableList();

Collection filtered=from（listArticles）.filter（myPredicate1）.filter（myPredicate2）.filter（myPredicate3.toImmutableList（）；

很漂亮，不是吗

第二个赢家是lambda函数。看这里：

Collection<Article> filtered = from(listArticles).filter(myPredicate1).filter(myPredicate2).filter(myPredicate3).toImmutableList();

Collection<Article> filtered = from(listArticles)
  .filter((Predicate) (candidate) -> { return candidate.getCodeArt() > SOME_VALUE })
  .toImmutableList();

Collection filtered=from（listArticles）
.filter（（谓词）（候选）->{return candidate.getCodeArt（）>SOME_VALUE}）
.toImmutableList（）；

实际上，Java还没有纯lambda函数。我们将能够在Java8中实现这一点。但现在我们可以在IDE InElij Idea中编写，IDE将这样的lambda转换为谓词，动态创建：

Collection<Article> filtered = from(listArticles)
        .filter(new Predicate<Article>() {
            @Override
            public boolean apply(Article candidate) {
                return candidate.getCodeArt() > SOME_VALUE;
            }
        })
        .toImmutableList();

Collection filtered=from（listArticles）
.filter（新谓词（）{
@凌驾
公共布尔应用（候选文章）{
返回candidate.getCodeArt（）>某个_值；
}
})
.toImmutableList（）；

如果您的筛选条件需要regexp，代码将变得更加复杂，您将需要将条件移动到单独的方法或将整个谓词移动到单独的类

如果所有这些函数式编程看起来太复杂，只需创建新集合并手动填充（不使用番石榴）：

List filtered=new ArrayList（）；
for（文章：listArticles）
{
if（article.getCodeArt（）>某些值）
过滤。添加（文章）；
}

对于番石榴，我认为目前最简单的方法是使用Collections2.filter，例如：

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

Collections2.filter（您的_集合，新谓词（）{
@凌驾
公共布尔应用（您的对象候选）{
返回一些_属性.equals（candidate.getAttribute（））；
}
});

在Java 8中，使用过滤器

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

List articleList=new ArrayList（）；
List filteredArticleList=articleList.stream（）.filter（article->article.getDesArt（）.contains（“test”））.collect（Collectors.toList（））；

它是如何工作的？我打赌是编译错误…@fge因为我使用字符串进行过滤，我没有使用对象的字段进行过滤，但我不知道如何进行过滤。您需要实现自己的

谓词

，而

谓词

没有提供任何一个（除了

notNull（）

/

isNull（）

）将能够以有意义的方式过滤对象。你读过吗？我对Guava库不太熟悉，但我认为你需要使用Predicate.compose（Predicate Predicate，Function Function）创建一个新函数来测试特定字段是否正确。我将在几分钟后发布一个答案，并给出某种精确的解决方案。但据我所知，这是你应该做的。这并不复杂，只是目标化了。这里的列表是什么？@lahirupasanna这是番石榴的

列表
，因为问题是关于番石榴的，没有使用lamda表达式将不胜感激：）