Java 基于成员变量或映射函数返回子列表

我有一个pojo的列表

列表pojoList

；和

pojo.getcolor（）返回枚举实例

我想这样做：

List<Pojo> newlist = new ArrayList<Pojo>();
for(Pojo pojo:pojoList){
  if(pojo.getColour() == Colour.Red){
    newList.add(pojo);
  }
}

List newlist=newarraylist（）；
for（Pojo Pojo:pojoList）{
if（pojo.getcolor（）==color.Red）{
newList.add（pojo）；
}
}

我可以看到我自己对其他类型的列表使用了类似的函数，因此，与其重复大量代码，不如让它变得通用和/或功能化？因此，我可以根据不同的规则创建不同类型的子列表？
您必须使您的类型实现用于检查的公共接口：

public interface Candidate {
  public boolean isAddable();
}

然后，循环将如下所示

List<Candidate> newlist = new ArrayList<Candidate>();
for(Candidate pojo:pojoList){
 if(pojo.isAddable()){
   newList.add(pojo);
 }
}

您必须使您的类型实现用于检查的公共接口：

public interface Candidate {
  public boolean isAddable();
}

然后，循环将如下所示

List<Candidate> newlist = new ArrayList<Candidate>();
for(Candidate pojo:pojoList){
 if(pojo.isAddable()){
   newList.add(pojo);
 }
}

创建一个通用过滤器接口

public interface Filter<T>{
     public boolean match(T item);
}

公共接口过滤器{
公共布尔匹配（T项）；
}

使用过滤器创建一个方法

public <T> List<T> getFilteredList(List<T> oldList, List<T> filter){
   List<T> newlist = new ArrayList<T>();

   for(T item:oldList){
      if(filter.match(item)){
         newlist.add(item);
      }
   }

   return newlist;
} 

public List getFilteredList（List oldList，List filter）{
List newlist=newarraylist（）；
对于（T项：旧列表）{
if（筛选匹配（项目））{
新建列表。添加（项）；
}
}
返回newlist；
} 

把它们放在一起

List<Pojo> myList = .. 

List<Pojo> redList = getFilteredList(myList,new Filter<Pojo>(){
      public boolean match(Pojo item){ return item.isRed()};
});

List<Pojo> blueList = getFilteredList(myList,new Filter<Pojo>(){
      public boolean match(Pojo item){ return item.COLOR== Color.BLUE};
 }); 

List myList=。。
List redList=getFilteredList（myList，new Filter（）{
公共布尔匹配（Pojo项）{return item.isRed（）}；
});
List blueList=getFilteredList（myList，new Filter（）{
公共布尔匹配（Pojo项）{return item.COLOR==COLOR.BLUE}；
}); 
制作一个通用过滤器接口

public interface Filter<T>{
     public boolean match(T item);
}

公共接口过滤器{
公共布尔匹配（T项）；
}

使用过滤器创建一个方法

public <T> List<T> getFilteredList(List<T> oldList, List<T> filter){
   List<T> newlist = new ArrayList<T>();

   for(T item:oldList){
      if(filter.match(item)){
         newlist.add(item);
      }
   }

   return newlist;
} 

public List getFilteredList（List oldList，List filter）{
List newlist=newarraylist（）；
对于（T项：旧列表）{
if（筛选匹配（项目））{
新建列表。添加（项）；
}
}
返回newlist；
} 

把它们放在一起

List<Pojo> myList = .. 

List<Pojo> redList = getFilteredList(myList,new Filter<Pojo>(){
      public boolean match(Pojo item){ return item.isRed()};
});

List<Pojo> blueList = getFilteredList(myList,new Filter<Pojo>(){
      public boolean match(Pojo item){ return item.COLOR== Color.BLUE};
 }); 

List myList=。。
List redList=getFilteredList（myList，new Filter（）{
公共布尔匹配（Pojo项）{return item.isRed（）}；
});
List blueList=getFilteredList（myList，new Filter（）{
公共布尔匹配（Pojo项）{return item.COLOR==COLOR.BLUE}；
}); 
根据您使用它的频率/使用的过滤器数量（只有红色、绿色等），创建一个过滤器界面是有意义的-如果只是检查isRed，那么可能代码太多，最好使用简单的静态方法

这种设计的好处是，您可以将其用于任何要过滤的对象（请参见下面的字符串示例）

publicstaticvoidmain（字符串[]args）{
List originalList=Arrays.asList（新Pojo（true）、新Pojo（false）、新Pojo（false））；
List filteredList=Utils.getFilteredList（原始列表，新过滤器（）{
@凌驾
公共布尔匹配（Pojo候选）{
返回候选者.isRed（）；
}
});
System.out.println（originalList.size（））；//3
System.out.println（filteredList.size（））；//1
//现在有了条件
List originalStringList=Arrays.asList（“abc”、“abd”、“def”）；
List filteredStringList=Utils.getFilteredList（originalStringList，new Filter（）{
@凌驾
公共布尔匹配（字符串候选）{
返回候选项。包含（“a”）；
}
});
System.out.println（originalStringList.size（））；//3
System.out.println（filteredStringList.size（））；//2
}
公共静态类Utils{
公共静态列表getFilteredList（列表列表，过滤器过滤器）{
所选列表=新建ArrayList（）；
对于（T:列表）{
if（过滤器匹配（t））{
选择。添加（t）；
}
}
返回选中的；
}
}
公共静态类Pojo{
私有布尔isRed；
公共Pojo（布尔isRed）{
this.isRed=isRed；
}
公共布尔isRed（）{
返回isRed；
}
}
公共接口过滤器{
/**
*当传递一个候选对象时，match如果与筛选条件匹配，则返回true，
*如果没有，则为false。
*@param-candidate根据筛选器检查项目
*@如果项目符合筛选条件，则返回true
*/
布尔匹配（T候选）；
}
根据您使用它的频率/使用的过滤器数量（只有红色、绿色等），创建一个过滤器界面是有意义的-如果只是检查isRed，那么可能代码太多，最好使用简单的静态方法

这种设计的好处是，您可以将其用于任何要过滤的对象（请参见下面的字符串示例）

publicstaticvoidmain（字符串[]args）{
List originalList=Arrays.asList（新Pojo（true）、新Pojo（false）、新Pojo（false））；
List filteredList=Utils.getFilteredList（原始列表，新过滤器（）{
@凌驾
公共布尔匹配（Pojo候选）{
返回候选者.isRed（）；
}
});
System.out.println（originalList.size（））；//3
System.out.println（filteredList.size（））；//1
//现在有了条件
List originalStringList=Arrays.asList（“abc”、“abd”、“def”）；
List filteredStringList=Utils.getFilteredList（originalStringList，new Filter（）{
@凌驾
公共布尔匹配（字符串候选）{
返回候选人。包含（“a”）；
}
});
System.out.println（originalStringList.size（））；//3
System.out.println（filteredStringList.size（））；//2
}
公共静态类Utils{
公共静态列表getFilteredList（列表列表，过滤器过滤器）{
所选列表=新建ArrayList（）；
对于（T:列表）{
if（过滤器匹配（t））{
选择。添加（t）；
}
}
返回选中的；
}
}
公共静态类Pojo{
私有布尔isRed；
公共Pojo（布尔isRed）{
this.isRed=isRed；
}
公共布尔isRed（）{
返回isRed；
}
}
平民的
List<Pojo> copy = Lists.newArrayList(redPojos);