What are Spliterator characteristics?

package com.bank.demo;

import java.util.*;

public class CharacteristicsDemo {
    public static void main(String[] args) {
        // ArrayList: ORDERED, SIZED, SUBSIZED
        printCharacteristics("ArrayList", new ArrayList<>(List.of("SAV2001", "CUR3001")));

        // HashSet: DISTINCT, SIZED
        printCharacteristics("HashSet", new HashSet<>(List.of("SAV2001", "CUR3001")));

        // TreeSet: ORDERED, DISTINCT, SORTED, SIZED
        printCharacteristics("TreeSet", new TreeSet<>(List.of("SAV2001", "CUR3001")));

        // LinkedHashSet: ORDERED, DISTINCT, SIZED
        printCharacteristics("LinkedHashSet", new LinkedHashSet<>(List.of("SAV2001", "CUR3001")));

        // List.of: ORDERED, SIZED, SUBSIZED, IMMUTABLE
        printCharacteristics("List.of", List.of("SAV2001", "CUR3001"));
    }

    static void printCharacteristics(String name, Collection<?> coll) {
        Spliterator<?> sp = coll.spliterator();
        int chars = sp.characteristics();
        List<String> flags = new ArrayList<>();

        if ((chars & Spliterator.ORDERED) != 0) flags.add("ORDERED");
        if ((chars & Spliterator.DISTINCT) != 0) flags.add("DISTINCT");
        if ((chars & Spliterator.SORTED) != 0) flags.add("SORTED");
        if ((chars & Spliterator.SIZED) != 0) flags.add("SIZED");
        if ((chars & Spliterator.SUBSIZED) != 0) flags.add("SUBSIZED");
        if ((chars & Spliterator.NONNULL) != 0) flags.add("NONNULL");
        if ((chars & Spliterator.IMMUTABLE) != 0) flags.add("IMMUTABLE");
        if ((chars & Spliterator.CONCURRENT) != 0) flags.add("CONCURRENT");

        System.out.println(name + ": " + flags);
    }
}

ArrayList: [ORDERED, SIZED, SUBSIZED]
HashSet: [DISTINCT, SIZED]
TreeSet: [ORDERED, DISTINCT, SORTED, SIZED]
LinkedHashSet: [ORDERED, DISTINCT, SIZED]
List.of: [ORDERED, SIZED, SUBSIZED, IMMUTABLE]

package com.bank.demo;

import java.util.Set;
import java.util.TreeSet;

public class StreamOptimisationDemo {
    public static void main(String[] args) {
        // TreeSet is SORTED + DISTINCT
        Set<String> accounts = new TreeSet<>(Set.of("FD4001", "SAV2001", "CUR3001"));

        // sorted() is a no-op: TreeSet is already SORTED
        // distinct() is a no-op: TreeSet is already DISTINCT
        long count = accounts.stream()
            .sorted()     // no-op (SORTED)
            .distinct()   // no-op (DISTINCT)
            .count();     // uses SIZED: returns estimateSize directly

        System.out.println("Count: " + count);

        // ArrayList is SIZED: count() is O(1)
        var list = java.util.List.of("SAV2001", "CUR3001", "FD4001");
        long listCount = list.stream().count(); // O(1): returns size directly
        System.out.println("List count: " + listCount);
    }
}

Count: 3
List count: 3

package com.bank.demo;

import java.util.List;
import java.util.Spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class CharacteristicsChangeDemo {
    public static void main(String[] args) {
        List<String> accounts = List.of("SAV2001", "CUR3001", "FD4001", "SAV2001");

        // Original: ORDERED, SIZED, SUBSIZED, IMMUTABLE
        System.out.println("Source SIZED: " + accounts.spliterator().hasCharacteristics(Spliterator.SIZED));

        // After filter: SIZED is REMOVED (count unknown after filtering)
        Stream<String> filtered = accounts.stream().filter(a -> a.startsWith("SAV"));
        Spliterator<String> filteredSp = filtered.spliterator();
        System.out.println("After filter SIZED: " + filteredSp.hasCharacteristics(Spliterator.SIZED));

        // After sorted: SORTED is ADDED
        Stream<String> sorted = accounts.stream().sorted();
        Spliterator<String> sortedSp = sorted.spliterator();
        System.out.println("After sorted() SORTED: " + sortedSp.hasCharacteristics(Spliterator.SORTED));

        // After distinct: DISTINCT is ADDED
        Stream<String> distinct = accounts.stream().distinct();
        Spliterator<String> distinctSp = distinct.spliterator();
        System.out.println("After distinct() DISTINCT: " + distinctSp.hasCharacteristics(Spliterator.DISTINCT));
    }
}

Source SIZED: true
After filter SIZED: false
After sorted() SORTED: true
After distinct() DISTINCT: true

// WRONG assumption: forEachOrdered is as fast as forEach in parallel
accounts.parallelStream()
    .forEachOrdered(System.out::println); // must wait for correct order!
// Parallel threads must coordinate to maintain ORDERED sequence.
// This often makes parallel forEachOrdered SLOWER than sequential.

// CORRECT: use forEach if order does not matter
accounts.parallelStream()
    .forEach(System.out::println); // unordered, faster

// INEFFICIENT but not wrong: the stream recognises SORTED and skips the sort
new TreeSet<>(accounts).stream()
    .sorted()   // no-op because source is SORTED
    .toList();
// But it is confusing to readers. Remove the redundant sorted() call.

package com.bank.demo;

import java.util.List;
import java.util.Set;
import java.util.HashSet;

public class OrderedParallelDemo {
    public static void main(String[] args) {
        List<String> orderedSource = List.of("SAV2001", "CUR3001", "FD4001");
        Set<String> unorderedSource = new HashSet<>(orderedSource);

        // ORDERED source: limit() must return first N in encounter order
        System.out.println("Ordered limit(2): " +
            orderedSource.parallelStream().limit(2).toList());

        // Unordered source: limit() can return any N elements
        System.out.println("Unordered limit(2): " +
            unorderedSource.parallelStream().limit(2).toList());
    }
}

Ordered limit(2): [SAV2001, CUR3001]
Unordered limit(2): [CUR3001, FD4001]