用于存储对象数组列表的二维数组列表或数组列表的映射？

Question

I'm making a simple bookkeeping program for my dad's art business to help him out a bit with their workflow(a gallery with a bunch of artists that sell their work through one register), and I'm a bit stumped on the direction I should go for storing the data I have. I currently have an arraylist of objects that store each sale every artist makes. So it's a few hundred elements long and each element has information about the sale(it's not artist specific, just every sale that's been through the register in 2 weeks). It's sorted by name, but ideally I want to split it up into individual artists so they all belong to their own list for better access and control.

So now I'm stuck on the best method for this, both basically being a map. I was thinking a 2D arrayList, first dimension being a string assigned for the specific artist for easy accessibility and the second being a list with all of their sales that I could add to whenever information is entered.

Or I could use a map, but from what I've read a key can only be assigned one value, and I don't really want to make another class just for storing a bunch of objects when an Arraylist does that fine. Can I make a map with lists as it's elements? I haven't messed around with them at all.

Or is there just a better way to go about all of this? I have yet to take Data Structures so I'm basically using my OOP knowledge the best I can. I also plan on serializing the data so it can be used on a rolling basis(They get excel reports bi monthly and Im parsing using Apache) if that changes anything.

Thanks!

Answer 1

This is the implementation of what I said in the comments:

Class Art:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Art implements Serializable {
    public String author;
    public String mainColor;
    public String field3;

    public Art(String author, String mainColor, String field3) {
        this.author = author;
        this.mainColor = mainColor;
        this.field3 = field3;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.writeObject(author);
        out.writeObject(mainColor);
        out.writeObject(field3);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        author = (String)in.readObject();
        mainColor = (String)in.readObject();
        field3 = (String)in.readObject();
    }
}

class ArtCollection:

import java.io.*;
import java.util.*;

public class ArtCollection {
    private final File file;
    private final List<Art> arts = new ArrayList<>();
    private final Map<String,List<Art>> byAuthor = new HashMap<>();
    private final Map<String,List<Art>> byMainColor = new HashMap<>();
    private final Map<String,List<Art>> byField3 = new HashMap<>();

    public ArtCollection(File file) throws ArtException {
        this.file = file;
        try (var in = new ObjectInputStream(new FileInputStream(file))) {
            for (Object art : (Iterable<?>)in.readObject())
                addArt((Art)art);
        } catch (Exception e) {
            throw new ArtException(e);
        }
    }

    public void save() throws ArtException {
        try (var out = new ObjectOutputStream(new FileOutputStream(file))) {
            out.writeObject(arts);
        } catch (Exception e) {
            throw new ArtException(e);
        }
    }

    private void addArt(Art art) {
        arts.add(art);
        byAuthor.computeIfAbsent(art.author, arg->new ArrayList<>()).add(art);
        byMainColor.computeIfAbsent(art.mainColor, arg->new ArrayList<>()).add(art);
        byField3.computeIfAbsent(art.field3, arg->new ArrayList<>()).add(art);
    }

    private void removeArt(Art art) {
        if (arts.remove(art)) {
            byAuthor.get(art.author).remove(art);
            byMainColor.get(art.mainColor).remove(art);
            byField3.get(art.field3).remove(art);
        }
    }

    public List<Art> getByAuthor(String author) {
        return get(author, byAuthor);
    }

    public List<Art> getByMainColor(String mainColor) {
        return get(mainColor, byMainColor);
    }

    public List<Art> getByField3(String field3) {
        return get(field3, byField3);
    }

    private static List<Art> get(String key, Map<String,List<Art>> map) {
        List<Art> arts = map.get(key);
        return arts == null ? Collections.emptyList() : Collections.unmodifiableList(arts);
    }

    public static class ArtException extends RuntimeException {
        public ArtException(Throwable cause) {
            super(cause);
        }
    }
}

Everything is O(1), except for the constructor, save, and removeArt