Convert Prolog program to Java

HuntingBuddies.java

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class HuntingBuddies {

  // Person class with attributes
  public static class Person {
    private String name;
    private boolean hasJob;
    private boolean jobPays;
    private boolean hasPossessions;
    private boolean hasKidney;
    private boolean hasMoney;

    public Person(String name) {
      this.name = name;
      this.hasJob = false;
      this.jobPays = false;
      this.hasPossessions = false;
      this.hasKidney = false;
      this.hasMoney = false;
    }

    // Getters and setters
    public String getName() {
      return name;
    }

    public boolean hasJob() {
      return hasJob;
    }

    public boolean jobPays() {
      return jobPays;
    }

    public boolean hasPossessions() {
      return hasPossessions;
    }

    public boolean hasKidney() {
      return hasKidney;
    }

    public boolean hasMoney() {
      return hasMoney;
    }

    public Person setHasJob(boolean hasJob) {
      this.hasJob = hasJob;
      return this;
    }

    public Person setJobPays(boolean jobPays) {
      this.jobPays = jobPays;
      return this;
    }

    public Person setHasPossessions(boolean hasPossessions) {
      this.hasPossessions = hasPossessions;
      return this;
    }

    public Person setHasKidney(boolean hasKidney) {
      this.hasKidney = hasKidney;
      return this;
    }

    public Person setHasMoney(boolean hasMoney) {
      this.hasMoney = hasMoney;
      return this;
    }

    @Override
    public String toString() {
      return name;
    }
  }

  // Rule predicates using lambda functions
  public static final Predicate<Person> canSellPossessions = person -> person.hasPossessions();

  public static final Predicate<Person> canSellKidney = person -> person.hasKidney();

  public static final Predicate<Person> hasMoneyFromJob = person -> person.hasJob() && person.jobPays();

  public static final Predicate<Person> hasMoneyFromKidney = person -> canSellKidney.test(person);

  public static final Predicate<Person> hasMoneyFromPossessions = person -> canSellPossessions.test(person);

  // Combined money predicate - person has money if any of the conditions are true
  public static final Predicate<Person> hasMoney = person -> hasMoneyFromJob.test(person) ||
      hasMoneyFromKidney.test(person) ||
      hasMoneyFromPossessions.test(person) ||
      person.hasMoney(); // Direct money attribute

  // Main hunting predicate
  public static final Predicate<Person> canGoHunt = person -> hasMoney.test(person);

  public static void main(String[] args) {
    // Create people with their life circumstances
    List<Person> people = Arrays.asList(
        new Person("aaron").setHasJob(true),
        new Person("tony").setHasJob(true).setJobPays(true),
        new Person("mike").setHasPossessions(true),
        new Person("jeremy").setHasKidney(true),
        new Person("gareth").setHasMoney(true));

    // Find hunting buddies using lambda and streams
    List<Person> huntingBuddies = people.stream()
        .filter(canGoHunt)
        .collect(Collectors.toList());

    // Display results
    System.out.println("People and their circumstances:");
    people.forEach(person -> {
      System.out.printf("%s: job=%b, jobPays=%b, possessions=%b, kidney=%b, money=%b%n",
          person.getName(), person.hasJob(), person.jobPays(),
          person.hasPossessions(), person.hasKidney(), person.hasMoney());
    });

    System.out.println("\n=== HUNTING BUDDIES ===");
    System.out.println("go_hunt: " + huntingBuddies.stream()
        .map(Person::getName).collect(Collectors.joining(", ")));
  }
}