Can I add a new object to a collection while streaming it?

Question

I have a Set<Client> which I am filling with results from a database query. The resulting rows contain different values for clients so that several rows contain values to be added to a single instance of Client.
The Clients are stored in the mentioned Set<Client> and currently, I am checking if the client is already present in that Set or needs to be created by the following stream:

Set<Client> clients = new TreeSet<>(); 
// yes, Client implements Comparable<Client>, has hashCode() and equals()

// some things that are irrelevant to this question happen here

// then iterating the database result
ResultSet rs = ps.executeQuery();

while (rs.next()) {
    int clientNumber = rs.getInt(...);
    String clientName = rs.getString(...);
    // get the client from the collection or create a new one if it isn't there
    Client client = clients.stream()
            .filter(c -> c.getNumber() == clientNumber)
            .findFirst()
            .orElse(new Client(clientNumber, clientName));

    // here I have to check again if the client is in the Set, how can I avoid that?
}

However, this does — of course — not add a possibly newly created Client to the Set<Client>, I need to check again if clients contains this instance afterwards in order to find out if I have to add this instance to clients or not. I couldn't even try anthing because I couldn't even add methods of Stream, like concat(...) at any position in the clients.stream()... statement.

That leads to the following question:

Is there any way at all that provides a possibility of directly adding a new instance of Client (or any object) to the Set while streaming this Set and the new instance is created by .orElse(new ...)?

I can imagine something like orElseAdd(new ...) but couldn't find anything similar.

Answer 1

A Map provides a useful method of inserting something if it doesn't exist.

It also doesn't hurt to store clients in a map. It seems from your example that clientNumber is unique so that will be the key.

Map<Integer, Client> clients = new TreeMap<>();

...

Client client = clients.computeIfAbsent(clientNumber, key -> new Client(clientNumber, clientName));

When the lambda is executed, key is equal to clientNumber, so it can be ignored. Note here that the lambda is only executed when the client is not in the map, so don't fear about creting too many objects. Not that it matters since it's also creating boxed Integer objects if clientNumber is larger than the caching threshold (255 in my VM). Luckily Java is very efficient when dealing with short-lived objects.

Answer 2

Is there any way at all that provides a possibility of directly adding a new instance ... to the Set?

See this now:

For example, it is not generally permissible for one thread to modify a Collection while another thread is iterating over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator implementations (including those of all the general purpose collection implementations provided by the JRE) may choose to throw this exception if this behavior is detected. Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will throw this exception.

Quoting from ConcurrentModificationException.

Thing is: adding to a Set while iterating it is simply not a good idea. Most likely, an instance of the above exception would be thrown at you. See here for some more thoughts.

Also, note, conceptually: would you want a freshly added object to show up in that stream, too? What if your Set is sorted, and the new object goes somewhere in the set ... that was "already" streamed?!

Long story short: what you intend to do is bad practice. Rather collect all new Client objects in a separate set, and process that one by itself later on.

And note: it isn't mandatory, but the whole "streaming" API suggests you to follow functional programming paradigms. In functional programming, you don't modify things, you rather create new things. So, as said: collect new objects in a new set, and then finally, create a new merged set that contains old and new objects.

Answer 3

If the process of creating a client is light enough to not worry about creating a dup, you can just let Set control it for you.

Set<Client> clients = new TreeSet<>(); 
ResultSet rs = ps.executeQuery();

while (rs.next()) {
    int clientNumber = rs.getInt(...);
    String clientName = rs.getString(...);
    clients.add(new Client(clientNumber, clientName))
}

Answer 4

If you are really wants to use TreeSet to maintain the sorting order of clients and wants to add the non existing client to clients collection set then try the following

Step 1

Since TreeSet maintains the sorted order, the Client object need to implement java.lang.Comparable's compareTo() method like the following:

public class Client implements Comparable<Client>{

    private int clientNumber;
    private String clientName;

    public Client(int clientNumber, String clientName) {
        this.clientNumber = clientNumber;
        this.clientName = clientName;
    }

    @Override
    public int compareTo(Client client) {
        return clientNumber - client.getClientNumber();
    }

    // getters and setters
}

Step 2

Since Set handles the duplicates internally just use

while (rs.next()) {
    int clientNumber = rs.getInt(...);
    String clientName = rs.getString(...);
    clients.add(new Client(clientNumber, clientName));
}

Step 3

For List collection Stream, Filter and add the non existing client to our clients collection set using the following way

while (rs.next()) {
    int clientNumber = rs.getInt(...);
    String clientName = rs.getString(...);
    clients.addAll(Lists.newArrayList(new Client(clientNumber, clientName)).stream()
            .filter(client -> !clients.contains(client))
            .collect(toList()));
}