How to refactor a three dimensional list?

Question

I currently have a three dimensional list in my Java project. I am using it to store the following. I have a list of Pairs. A Pair has a gender (male, female or mixed) and a food preference (meat, veggie or vegan).

In my code I have to access sometimes only the pairs which have veggie as food preference and are male or other combinations. I first thought that a three dimensional list would be the best to do this. My 3D list looks like the following:

ArrayList<ArrayList<ArrayList<Pair>>> pairsSplitUp;

The list is filled with values such that if we access it we get the following:

• Index 0: Index 0: all Pairs that are male and have meat as food Preference
• Index 0: Index 1: all Pairs that are female and have meat as food Preference
• Index 0: Index 2: all Pairs that are mixed and have meat as food Preference
• Index 1: Index 0: all Pairs that are male and have veggie as food Preference
• ...
• Index 2: Index 0: all Pairs that are male and have vegan as food Preference
• ...

I first thought that this might be the best way to store this data, but then I read this question, where it is stated that if you are implementing a 3D list you are probably not handling your data right. In the mentioned question there is also an answer where a Map is used to store the data, but I am not really understanding this abstraction and I don't know how it could be used for my case. Because of this I wanted to ask, if there is a better, cleaner way for storing my data such that I can still access only the Pairs which are male and vegan etc.

In the code there exists a ArrayList<Pair> pairList which holds all the Pairs. The Pair class looks like the following:

public class Pair {
    private Person person1;
    private Person person2; 
    private String foodPreference;
    private String gender;
    
    public Pair(Person person1, Person person2) {
        this.person1 = person1;
        this.person2 = person2;
        this.foodPreference = decideFoodPreference();
        this.gender = decideGender();
    }
 
    /*
      contains Getter for the fields and methods to decide and set the foodPreference
      and the gender.
    */

}

The Person class contains information about a specific Person like the name, age, gender, location and so on.

Is there a better, cleaner way to do the storing of the Pairs, where I can still get only the Pairs which have foodPreference x and gender y or is my way with the three dimensional list the best way for my specific data?

Answer 1

Should be able to use a single List<Pair>, and apply various filters to get a subset of relevant pairs.

For example:

List<Pair> allPairs = List.of(new Pair(...), 
                              new Pair(...), 
                              new Pair(...),
                              ....);

List<Pair> allMaleCarnivores = allPairs.stream()
                                  .filter(p -> p.getPerson1().isCarnivore() 
                                                 && p.getPerson2().isCarnivore()
                                                 && p.getPerson1().isMale()
                                                 && p.getPerson2().isMale()
                                          )
                                  .toList();


 // then do something with the subset
 allMaleCarnivores.forEach(p -> eatSalad(p);

Answer 2

While @Andrew S answer works, I could also suggest to use a Map for quick retrieve of a desired Pairs. It would take constant (O(1)) time to look up instead of filtering the whole list (O(n)). The flip side is extra memory consumption.

To do that you have to extract a kind of PairAttributes class which holds foodPreference and gender with properly defined equals and hashCode methods. Use lombok or auto-generation by IDE. Don't forget to update them in case of new attributes.

public static class PairAttributes {
    private final String foodPreference;
    private final String gender;

    public PairAttributes(Pair pair) {
        this.foodPreference = pair.foodPreference;
        this.gender = pair.gender;
    }

    public PairAttributes(String foodPreference, String gender) {
        this.foodPreference = foodPreference;
        this.gender = gender;
    }

    // getters

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PairAttributes that = (PairAttributes) o;
        return foodPreference.equals(that.foodPreference) && gender.equals(that.gender);
    }

    @Override
    public int hashCode() {
        return Objects.hash(foodPreference, gender);
    }
}

Now, just put given Pairs to a HashMap with PairAttributes as a key:

one by one

    private final Map<PairAttributes, List<Pair>> pairsByAttributes = new HashMap<>();
    ...
    pairsByAttributes.computeIfAbsent(new PairAttributes(somePair), p -> new ArrayList<>()).add(somePair);

or if given a whole list:

List<Pair> allPairs = List.of(new Pair(...),
        new Pair(...),
        new Pair(...),
        ...
);

Map<PairAttributes, List<Pair>> pairsByAttributes = allPairs
        .stream().
        collect(Collectors.groupingBy(PairAttributes::new));

then to get desired pairs just get them:

List<Pair> veggieMales = pairsByAttributes.get(
        new PairAttributes("veggie", "male")
);

Answer 3

"... I read this question, where it is stated that if you are implementing a 3D list you are probably not handling your data right. ..."

More or less; typically, 3-dimensional arrays are used to represent mathematical matrices.

"... In the mentioned question there is also an answer where a Map is used to store the data, but I am not really understanding this abstraction and I don't know how it could be used for my case. ..."

In computer science, a map structure—sometimes referred to as a dictionary, or an associative array—it's simply a list of values, each of which are mapped to separate keys.  Similar to a literal dictionary, which has a word and a definition.

Here is the Java Tutorial on using the Map collection.
The Map Interface (The Java™ Tutorials > Collections > Interfaces).

Here is a basic example.

Map<String, Integer> map = new HashMap<>();
map.put("abc", 123);
map.put("def", 456);

And, you can retrieve values using the "key".

map.get("abc");

... Is there a better, cleaner way to do the storing of the Pairs, where I can still get only the Pairs which have foodPreference x and gender y or is my way with the three dimensional list the best way for my specific data?"

Yes, I'll demonstrate; you can use a single ArrayList.

Consider the following objects, to hold your data.

class Pair {
    Person personA, personB;
}

class Person {
    String name, location;
    int age;
    Gender gender;
    FoodPreference foodPreference;
}

enum Gender {
    MALE, FEMALE, MIXED
}

enum FoodPreference {
    MEAT, VEGGIE, VEGAN
}

From here, you can create new constructors for both Person, and Pair.
Additionally, here I added a toString method, as a way to debug the data.

class Pair {
    Person personA, personB;

    public Pair(Person personA, Person personB) {
        this.personA = personA;
        this.personB = personB;
    }
}

class Person {
    String name, location;
    int age;
    Gender gender;
    FoodPreference foodPreference;

    public Person(Gender gender, FoodPreference foodPreference) {
        this.gender = gender;
        this.foodPreference = foodPreference;
    }

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

Here is an example of adding new items to the list.

List<Pair> list = new ArrayList<>();

Person personA = new Person("personA", 1, Gender.MALE);
personA.foodPreference = FoodPreference.MEAT;
Person personB = new Person("personB", 2, Gender.FEMALE);
personB.foodPreference = FoodPreference.VEGGIE;
list.add(new Pair(personA, personB));

Person personC = new Person("personC", 3, Gender.MALE);
personC.foodPreference = FoodPreference.MEAT;
Person personD = new Person("personD", 4, Gender.FEMALE);
personD.foodPreference = FoodPreference.VEGAN;
list.add(new Pair(personC, personD));

And, here is an example of acquiring Person objects, with a specific value.

List<Person> find(List<Pair> list, FoodPreference foodPreference, Gender gender) {
    List<Person> matches = new ArrayList<>();
    Person person;
    for (Pair pair : list) {
        person = pair.personA;
        if (person.foodPreference == foodPreference && person.gender == gender)
            matches.add(person);
        person = pair.personB;
        if (person.foodPreference == foodPreference && person.gender == gender)
            matches.add(person);
    }
    return matches;
}

And, usage.

List<Person> matches = find(list, FoodPreference.MEAT, Gender.MALE);

Output

personA
personC

Answer 4

After some discussion with OP, I think we have a layer of abstraction missing. Not including any necessary synchronized keywords, as I don't yet know all details.

public class PairManager {
    List<Pair> allPairs;

    // Add any cache worthy queries
    List<Pair> maleMeatEaters;

    public addPair(Pair newPair) {
        allPairs.add(newPair);
        // invalidate caches
        maleMeatEaters = null;
    }

    public removePair(Pair pair) {
        allPairs.remove(pair)
        // invalidate caches
        maleMeatEaters = null;
    }

    public List<Pair> listMaleMeatEaters() {
        return maleMeatEaters == null ? filterMaleMeatEaters() : maleMeatEaters;
    }

    private List<Pair> filterMaleMeatEaters() {
        maleMeatEaters = allPairs.stream()
            .filter(pair -> pair.getGender() == Gender.MALE)
            .filter(pair -> pair.getFoodPreference() == FoodPreference.MEAT)
            .toList(); // pre-Java17 .collect(Collectors.toList());
        return maleMeatEaters;
    }
}