AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

过滤器模式 rust和java的实现（二）

2023-12-08 79
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 过滤器模式 rust和java的实现

过滤器模式 rust和java的实现（一）https://developer.aliyun.com/article/1392026


rust

由于时间关系，并没有实现or条件，大家有兴趣可以自行补充

// 设置人类实体类
#[derive(Clone)]
struct Person{
    name:String,
    gender:String,
    marital_status:String
}
impl Person {
    fn get_gender(&self)->&str {
        self.gender.as_ref()
    }
    fn get_marital_status(&self)->&str {
        self.marital_status.as_ref()
    }
}
// 设置过滤标准特征
trait Criteria {
  fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>; 
}
// 设置男性
struct CriteriaMale{}
// 重写男性评判标准
impl   Criteria for CriteriaMale {
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_gender().eq_ignore_ascii_case("MALE")).collect()
    }
}
// 设置女性
struct CriteriaFemale{}
// 设置女性标准
impl   Criteria for CriteriaFemale{
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_gender().eq_ignore_ascii_case("FEMALE")).collect()
    }
}
// 设置单身标准
struct CriteriaSingle{}
impl   Criteria for CriteriaSingle{
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_marital_status().eq_ignore_ascii_case("SINGLE")).collect()
    }
}
// 设置and标准，求交集
struct AndCriteria  {
    criteria:Box<dyn Criteria>,
    other_criteria:Box<dyn Criteria>
}
impl Criteria for AndCriteria {
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person> {
        self.other_criteria.meet_criteria(self.criteria.meet_criteria(persons))
    }
}
// struct OrCriteria {
//     criteria:Box<dyn Criteria>,
//     other_criteria:Box<dyn Criteria>
// }
// impl Criteria for OrCriteria{
//     fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person> {
//         let mut first_criteria_items = self.criteria.meet_criteria(persons);
//         let other_criteria_items = self.other_criteria.meet_criteria(persons);
//         for o in other_criteria_items  {
//             if !other_criteria_items.contains(&o) {
//                 first_criteria_items.push(o);
//             }
//         }
//         first_criteria_items
//     }
// }
fn print_persons(persons:Vec<Person>) {
    persons.into_iter().for_each(|x| println!("Person : [NAME: {},Gender : {} ,Maeital Status : {} ]",x.name,x.gender,x.marital_status));
}
fn main() {
    let mut persons=Vec::new();
    persons.push(Person{name:String::from("Robert"),gender:String::from("Male"),marital_status:String::from("Single")});
    persons.push(Person{name:String::from("John"),gender:String::from("Male"),marital_status:String::from("Married")});
    persons.push(Person{name:String::from("Laura"),gender:String::from("Female"),marital_status:String::from("Married")});
    persons.push(Person{name:String::from("Diana"),gender:String::from("Female"),marital_status:String::from("Single")});
    let male=Box::new(CriteriaMale{});
    let female=Box::new(CriteriaFemale{});
    let single_male=AndCriteria{criteria:Box::new(CriteriaSingle{}),other_criteria:Box::new(CriteriaMale{})};
    // let single_or_female=OrCriteria{criteria:Box::new(CriteriaMale{}),other_criteria:Box::new(CriteriaFemale{})};
    println!("男士");
    print_persons(male.meet_criteria(persons.clone()));
    println!("女士");
    print_persons(female.meet_criteria(persons.clone()));
    println!("单身男士");
    print_persons(single_male.meet_criteria(persons))
}

java

步骤 1

创建一个类，在该类上应用标准。

Person.java

public class Person {
   private String name;
   private String gender;
   private String maritalStatus;
   public Person(String name,String gender,String maritalStatus){
      this.name = name;
      this.gender = gender;
      this.maritalStatus = maritalStatus;    
   }
   public String getName() {
      return name;
   }
   public String getGender() {
      return gender;
   }
   public String getMaritalStatus() {
      return maritalStatus;
   }  
}

步骤 2

为标准（Criteria）创建一个接口。

Criteria.java

import java.util.List;
public interface Criteria {
   public List<Person> meetCriteria(List<Person> persons);
}

步骤 3

创建实现了 Criteria 接口的实体类。

CriteriaMale.java

import java.util.ArrayList;
import java.util.List;
public class CriteriaMale implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> malePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getGender().equalsIgnoreCase("MALE")){
            malePersons.add(person);
         }
      }
      return malePersons;
   }
}

CriteriaFemale.java

import java.util.ArrayList;
import java.util.List;
public class CriteriaFemale implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> femalePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getGender().equalsIgnoreCase("FEMALE")){
            femalePersons.add(person);
         }
      }
      return femalePersons;
   }
}

CriteriaSingle.java

import java.util.ArrayList;
import java.util.List;
public class CriteriaSingle implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> singlePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getMaritalStatus().equalsIgnoreCase("SINGLE")){
            singlePersons.add(person);
         }
      }
      return singlePersons;
   }
}

AndCriteria.java

import java.util.List;
public class AndCriteria implements Criteria {
   private Criteria criteria;
   private Criteria otherCriteria;
   public AndCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria; 
   }
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);     
      return otherCriteria.meetCriteria(firstCriteriaPersons);
   }
}



OrCriteria.java

import java.util.List;
public class OrCriteria implements Criteria {
   private Criteria criteria;
   private Criteria otherCriteria;
   public OrCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria; 
   }
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
      List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);
      for (Person person : otherCriteriaItems) {
         if(!firstCriteriaItems.contains(person)){
           firstCriteriaItems.add(person);
         }
      }  
      return firstCriteriaItems;
   }
}

步骤4

使用不同的标准（Criteria）和它们的结合来过滤 Person 对象的列表。

CriteriaPatternDemo.java

import java.util.ArrayList; 
import java.util.List;
public class CriteriaPatternDemo {
   public static void main(String[] args) {
      List<Person> persons = new ArrayList<Person>();
      persons.add(new Person("Robert","Male", "Single"));
      persons.add(new Person("John","Male", "Married"));
      persons.add(new Person("Laura","Female", "Married"));
      persons.add(new Person("Diana","Female", "Single"));
      persons.add(new Person("Mike","Male", "Single"));
      persons.add(new Person("Bobby","Male", "Single"));
      Criteria male = new CriteriaMale();
      Criteria female = new CriteriaFemale();
      Criteria single = new CriteriaSingle();
      Criteria singleMale = new AndCriteria(single, male);
      Criteria singleOrFemale = new OrCriteria(single, female);
      System.out.println("Males: ");
      printPersons(male.meetCriteria(persons));
      System.out.println("\nFemales: ");
      printPersons(female.meetCriteria(persons));
      System.out.println("\nSingle Males: ");
      printPersons(singleMale.meetCriteria(persons));
      System.out.println("\nSingle Or Females: ");
      printPersons(singleOrFemale.meetCriteria(persons));
   }
   public static void printPersons(List<Person> persons){
      for (Person person : persons) {
         System.out.println("Person : [ Name : " + person.getName() 
            +", Gender : " + person.getGender() 
            +", Marital Status : " + person.getMaritalStatus()
            +" ]");
      }
   }      
}

步骤 5

执行程序，输出结果：

Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : John, Gender : Male, Marital Status : Married ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Females: 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Single Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Single Or Females: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]

rust

由于时间关系，并没有实现or条件，大家有兴趣可以自行补充

// 设置人类实体类
#[derive(Clone)]
struct Person{
    name:String,
    gender:String,
    marital_status:String
}
impl Person {
    fn get_gender(&self)->&str {
        self.gender.as_ref()
    }
    fn get_marital_status(&self)->&str {
        self.marital_status.as_ref()
    }
}
// 设置过滤标准特征
trait Criteria {
  fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>; 
}
// 设置男性
struct CriteriaMale{}
// 重写男性评判标准
impl   Criteria for CriteriaMale {
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_gender().eq_ignore_ascii_case("MALE")).collect()
    }
}
// 设置女性
struct CriteriaFemale{}
// 设置女性标准
impl   Criteria for CriteriaFemale{
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_gender().eq_ignore_ascii_case("FEMALE")).collect()
    }
}
// 设置单身标准
struct CriteriaSingle{}
impl   Criteria for CriteriaSingle{
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person>{
        persons.into_iter().filter(|x| x.get_marital_status().eq_ignore_ascii_case("SINGLE")).collect()
    }
}
// 设置and标准，求交集
struct AndCriteria  {
    criteria:Box<dyn Criteria>,
    other_criteria:Box<dyn Criteria>
}
impl Criteria for AndCriteria {
    fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person> {
        self.other_criteria.meet_criteria(self.criteria.meet_criteria(persons))
    }
}
// struct OrCriteria {
//     criteria:Box<dyn Criteria>,
//     other_criteria:Box<dyn Criteria>
// }
// impl Criteria for OrCriteria{
//     fn meet_criteria(&self,persons:Vec<Person>)->Vec<Person> {
//         let mut first_criteria_items = self.criteria.meet_criteria(persons);
//         let other_criteria_items = self.other_criteria.meet_criteria(persons);
//         for o in other_criteria_items  {
//             if !other_criteria_items.contains(&o) {
//                 first_criteria_items.push(o);
//             }
//         }
//         first_criteria_items
//     }
// }
fn print_persons(persons:Vec<Person>) {
    persons.into_iter().for_each(|x| println!("Person : [NAME: {},Gender : {} ,Maeital Status : {} ]",x.name,x.gender,x.marital_status));
}
fn main() {
    let mut persons=Vec::new();
    persons.push(Person{name:String::from("Robert"),gender:String::from("Male"),marital_status:String::from("Single")});
    persons.push(Person{name:String::from("John"),gender:String::from("Male"),marital_status:String::from("Married")});
    persons.push(Person{name:String::from("Laura"),gender:String::from("Female"),marital_status:String::from("Married")});
    persons.push(Person{name:String::from("Diana"),gender:String::from("Female"),marital_status:String::from("Single")});
    let male=Box::new(CriteriaMale{});
    let female=Box::new(CriteriaFemale{});
    let single_male=AndCriteria{criteria:Box::new(CriteriaSingle{}),other_criteria:Box::new(CriteriaMale{})};
    // let single_or_female=OrCriteria{criteria:Box::new(CriteriaMale{}),other_criteria:Box::new(CriteriaFemale{})};
    println!("男士");
    print_persons(male.meet_criteria(persons.clone()));
    println!("女士");
    print_persons(female.meet_criteria(persons.clone()));
    println!("单身男士");
    print_persons(single_male.meet_criteria(persons))
}

rust代码仓库

https://github.com/onenewcode/design.git

本教程项目在bin文件夹下的filtert.rs文件中

文章标签：
Java
Rust
关键词：
Java过滤器
Rust模式
Java模式
模式Java
Rust java
过去日记
目录
相关文章
墨城coding
|
23天前
|
监控 Java 数据管理
java会话跟踪和拦截器过滤器
本文介绍了Web开发中的会话跟踪技术——Cookie与Session，以及过滤器(Filter)和监听器(Listener)的概念和应用。Cookie通过在客户端记录信息来识别用户，而Session则在服务器端保存用户状态。过滤器用于拦截和处理请求及响应，监听器则监控域对象的状态变化。文章详细解释了这些技术的实现方式、应用场景和主要方法，帮助开发者更好地理解和使用这些工具。
墨城coding
38 1
希望_睿智
|
3月前
|
Rust 安全 开发者
30天拿下Rust之模式与模式匹配
30天拿下Rust之模式与模式匹配
希望_睿智
52 1
1941623231718325
|
3月前
|
存储 Java 开发者
【Java新纪元启航】JDK 22：解锁未命名变量与模式，让代码更简洁，思维更自由！
【9月更文挑战第7天】JDK 22带来的未命名变量与模式匹配的结合，是Java编程语言发展历程中的一个重要里程碑。它不仅简化了代码，提高了开发效率，更重要的是，它激发了我们对Java编程的新思考，让我们有机会以更加自由、更加创造性的方式解决问题。随着Java生态系统的不断演进，我们有理由相信，未来的Java将更加灵活、更加强大，为开发者们提供更加广阔的舞台。让我们携手并进，共同迎接Java新纪元的到来！
1941623231718325
68 11
艾利克斯冰
|
3月前
|
设计模式 Java
Java设计模式-工厂方法模式（4）
Java设计模式-工厂方法模式（4）
艾利克斯冰
39 0
土木林森
|
4月前
|
消息中间件 Java
【实战揭秘】如何运用Java发布-订阅模式，打造高效响应式天气预报App？
【8月更文挑战第30天】发布-订阅模式是一种消息通信模型，发送者将消息发布到公共队列，接收者自行订阅并处理。此模式降低了对象间的耦合度，使系统更灵活、可扩展。例如，在天气预报应用中，`WeatherEventPublisher` 类作为发布者收集天气数据并通知订阅者（如 `TemperatureDisplay` 和 `HumidityDisplay`），实现组件间的解耦和动态更新。这种方式适用于事件驱动的应用，提高了系统的扩展性和可维护性。
土木林森
72 2
yuanzhengme
|
3月前
|
监控 前端开发 Java
Java里的过滤器和拦截器是什么原理，如何选择？
Java里的过滤器和拦截器是什么原理，如何选择？
yuanzhengme
31 0
蓝易云
|
3月前
|
JSON Java UED
uniapp:使用DCloud的uni-push推送消息通知（在线模式）java实现
以上展示了使用Java结合DCloud的uni-push进行在线消息推送的基本步骤和实现方法。实际部署时，可能需要依据实际项目的规模，业务场景及用户基数进行必要的调整和优化，确保消息推送机制在保证用户体验的同时也满足业务需求。
蓝易云
196 0
土木林森
|
4月前
|
Rust 开发者 C#
解锁Rust高手的秘密武器：模式匹配与宏，学会这一招，编程效率翻倍！
【8月更文挑战第31天】Xamarin 是移动应用开发领域的强大跨平台工具，采用 C# 语言，具备高代码复用性、熟悉开发语言及接近原生性能等优势。开发者可通过共享项目实现多平台业务逻辑复用，简化开发流程。然而，Xamarin 也存在学习曲线陡峭、需处理平台差异及第三方库兼容性等问题。总体而言，Xamarin 在提高开发效率的同时，也对开发者提出了新的挑战。
土木林森
31 0
欲揽西江月
|
20天前
|
Rust 安全 Java
探索Rust语言的并发编程模型
探索Rust语言的并发编程模型
欲揽西江月
31 2
爱的不是纯牛奶-47754
|
26天前
|
Rust 安全 区块链
探索Rust语言：系统编程的新选择
【10月更文挑战第27天】Rust语言以其安全性、性能和并发性在系统编程领域受到广泛关注。本文介绍了Rust的核心特性，如内存安全、高性能和强大的并发模型，以及开发技巧和实用工具，展示了Rust如何改变系统编程的面貌，并展望了其在WebAssembly、区块链和嵌入式系统等领域的未来应用。
爱的不是纯牛奶-47754
35 3

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    Java实现生产者消费者的四种方法
  • 3
    [零基础学JAVA]Java SE应用部分-35.JAVA类集之四
  • 4
    Java控制内存的功力
  • 5
    对象共享：Java并发环境中的烦心事
  • 6
    Java网络编程：实现HTTP模拟器
  • 7
    Java || 线程 || 大一新生 || 一篇synchronized锁的知识点总结
  • 8
    阿里开发者学院：Java Spring Boot 2.5.x开发实战课程
  • 9
    关于Eclipse提示Failed to create the java virtual machine问题解决办法
  • 10
    java-subString方法易导致内存溢出
  • 1
    通过Rust实现公司电脑监控软件的性能优化算法
    251
  • 2
    一名C++程序员的Rust入门初体验
    436
  • 3
    探索新一代编程语言：Rust
    89
  • 4
    【专栏】`ripgrep`（rg）是Linux下快速、内存高效的文本搜索工具，用Rust编写，支持PCRE2正则表达式
    562
  • 5
    Rust并发编程实践：快速入门系统级编程
    249
  • 6
    Rust 基础语法和数据类型
    116
  • 7
    Rust vs Go：解析两者的独特特性和适用场景
    234
  • 8
    异常处理的三国演义：Python、Go、Rust的对比探究
    103
  • 9
    Rust代码编写高性能屏幕监控软件的核心算法
    255
  • 10
    开发语言漫谈-rust
    82

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 语言入门-1：环境构建
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月