Java : LongStream with Examples

final var stream = LongStream.range(0, 5);

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//0
//1
//2
//3
//4

final var stream = LongStream.of(10, 20, 30);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30]

boolean allMatch (LongPredicate predicate)

Returns whether all elements of this stream match the provided predicate.

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

{
    final var stream = LongStream.of(0, 2, 4);

    final var ret = stream.allMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = LongStream.of(0, 1, 2, 3, 4);

    final var ret = stream.allMatch(predicate);
    System.out.println(ret); // false
}

boolean anyMatch (LongPredicate predicate)

Returns whether any elements of this stream match the provided predicate.

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

{
    final var stream = LongStream.of(0, 2, 4);

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = LongStream.of(1, 2, 3);

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = LongStream.of(1, 3, 5);

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // false
}

DoubleStream asDoubleStream ()

Returns a DoubleStream consisting of the elements of this stream, converted to double.

final var stream = LongStream.of(1, 2, 3);
final var doubleStream = stream.asDoubleStream().map(v -> v / 2.0);

final var ret = doubleStream.toArray();
System.out.println(Arrays.toString(ret)); // [0.5, 1.0, 1.5]

OptionalDouble average ()

Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.

final var stream = LongStream.of(1, 2, 3, 4, 5, 6);

final var opt = stream.average();
opt.ifPresent(value -> {
    System.out.println(value); // 3.5
});

final var opt = LongStream.empty().average();
System.out.println(opt.isEmpty()); // true

Stream<Long> boxed ()

Returns a Stream consisting of the elements of this stream, each boxed to a Long.

final Stream<Long> stream = LongStream.range(0, 5).boxed();

final var ret = stream.toList();
System.out.println(ret); // [0, 1, 2, 3, 4]

static LongStream.Builder builder ()

Returns a builder for a LongStream.

final var builder = LongStream.builder();
builder.add(0).add(2).add(4);

final var stream = builder.build();

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0, 2, 4]

<R> R collect (Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R,R> combiner)

Performs a mutable reduction operation on the elements of this stream.

final var supplier = new Supplier<List<String>>() {
    @Override
    public List<String> get() {
        System.out.println("-- supplier --");
        return new ArrayList<>();
    }
};

final var accumulator = new ObjLongConsumer<List<String>>() {
    @Override
    public void accept(List<String> list, long value) {
        System.out.println("-- accumulator --");
        System.out.println("  list = " + list);
        System.out.println("  value = " + value);

        list.add("%#x".formatted(value));
    }
};

final var combiner = new BiConsumer<List<String>, List<String>>() {
    @Override
    public void accept(List<String> list1, List<String> list2) {
        System.out.println("-- combiner --");
        System.out.println("  list1 = " + list1);
        System.out.println("  list2 = " + list2);

        list1.addAll(list2);
    }
};

{
    final var stream = LongStream.of(1, 100, 255);

    final var ret = stream.collect(supplier, accumulator, combiner);
    System.out.println("collect = " + ret);

    // Result
    // ↓
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 1
    //-- accumulator --
    //  list = [0x1]
    //  value = 100
    //-- accumulator --
    //  list = [0x1, 0x64]
    //  value = 255
    //collect = [0x1, 0x64, 0xff]
}
{
    final var parallelStream = LongStream.of(1, 100, 255).parallel();
    System.out.println(parallelStream.isParallel()); // true

    final var ret = parallelStream.collect(supplier, accumulator, combiner);
    System.out.println("collect = " + ret);

    // Result
    // ↓
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 100
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 255
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 1
    //-- combiner --
    //  list1 = [0x64]
    //  list2 = [0xff]
    //-- combiner --
    //  list1 = [0x1]
    //  list2 = [0x64, 0xff]
    //collect = [0x1, 0x64, 0xff]
}

static LongStream concat (LongStream a, LongStream b)

Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.

final var stream1 = LongStream.of(1, 2, 3);
final var stream2 = LongStream.of(100, 200, 300);

System.out.println(stream1.isParallel()); // false
System.out.println(stream2.isParallel()); // false

final var concatStream = LongStream.concat(stream1, stream2);

System.out.println(concatStream.isParallel()); // false

final var ret = concatStream.toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 100, 200, 300]

final var stream1 = LongStream.of(1, 2, 3).parallel();
final var stream2 = LongStream.of(100, 200, 300).parallel();

System.out.println(stream1.isParallel()); // true
System.out.println(stream2.isParallel()); // true

final var concatStream = LongStream.concat(stream1, stream2);

System.out.println(concatStream.isParallel()); // true

final var ret = concatStream.toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 100, 200, 300]

long count ()

Returns the count of elements in this stream.

final var stream = LongStream.of(0, 2, 4, 6);
System.out.println(stream.count()); // 4

final var stream = LongStream.empty();
System.out.println(stream.count()); // 0

LongStream distinct ()

Returns a stream consisting of the distinct elements of this stream.

final var stream = LongStream.of(1, 2, 2, 3, 3, 3);

final var ret = stream.distinct().toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3]

default LongStream dropWhile (LongPredicate predicate)

Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.

final var stream = LongStream.of(1, 2, 3, 4, 5);

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        return value != 3;
    }
};

final var ret = stream.dropWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [3, 4, 5]

final var stream = LongStream.of(-1, -2, -3, -4, -5);

final var ret = stream.dropWhile(v -> v != -4).toArray();
System.out.println(Arrays.toString(ret)); // [-4, -5]

static LongStream empty ()

Returns an empty sequential LongStream.

final var stream = LongStream.empty();
System.out.println(stream.count()); // 0

final var stream = LongStream.empty();
final var array = stream.toArray();
System.out.println(Arrays.toString(array)); // []

LongStream filter (LongPredicate predicate)

Returns a stream consisting of the elements of this stream that match the given predicate.

final var stream = LongStream.of(0, 1, 2, 3, 4, 5);

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

final var ret = stream.filter(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [0, 2, 4]

final var stream = LongStream.of(0, 1, 2, 3, 4, 5);

final var ret = stream.filter(v -> v % 2 == 1).toArray();
System.out.println(Arrays.toString(ret)); // [1, 3, 5]

OptionalLong findAny ()

Returns an OptionalLong describing some element of the stream, or an empty OptionalLong if the stream is empty.

int count1 = 0;
int count2 = 0;
int count3 = 0;

for (int i = 0; i < 1000; i++) {

    final var stream = LongStream.of(1, 2, 3).parallel();
    System.out.println(stream.isParallel()); // true

    // 1 or 2 or 3
    final var opt = stream.findAny();
    if (opt.isEmpty()) {
        throw new IllegalStateException();
    }

    final var value = opt.orElseThrow();
    if (value == 1) {
        count1++;
    } else if (value == 2) {
        count2++;
    } else if (value == 3) {
        count3++;
    }
}

System.out.println("count1 : " + count1);
System.out.println("count2 : " + count2);
System.out.println("count3 : " + count3);

// Result
// ↓
//count1 : 77
//count2 : 918
//count3 : 5

final var stream = LongStream.empty();

final var opt = stream.findAny();
System.out.println(opt.isEmpty()); // true

OptionalLong findFirst ()

Returns an OptionalLong describing the first element of this stream, or an empty OptionalLong if the stream is empty.

final var stream = LongStream.of(1, 2, 3);

final var opt = stream.findFirst();
opt.ifPresent(value -> {
    System.out.println(value); // 1
});

// parallel
final var stream = LongStream.of(1, 2, 3).parallel();
System.out.println(stream.isParallel()); // true

final var opt = stream.findFirst();
opt.ifPresent(value -> {
    System.out.println(value); // 1
});

int count1 = 0;
int count2 = 0;
int count3 = 0;

for (int i = 0; i < 1000; i++) {

    // unordered and parallel
    final var stream = LongStream.of(1, 2, 3).unordered().parallel();

    // 1 or 2 or 3
    final var opt = stream.findFirst();
    if (opt.isEmpty()) {
        throw new IllegalStateException();
    }

    final var value = opt.orElseThrow();
    if (value == 1) {
        count1++;
    } else if (value == 2) {
        count2++;
    } else if (value == 3) {
        count3++;
    }
}

System.out.println("count1 : " + count1);
System.out.println("count2 : " + count2);
System.out.println("count3 : " + count3);

// Result
// ↓
//count1 : 162
//count2 : 834
//count3 : 4

final var stream = LongStream.empty();

final var opt = stream.findFirst();
System.out.println(opt.isEmpty()); // true

LongStream flatMap (LongFunction<? extends LongStream> mapper)

Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.

final var stream = LongStream.of(100, 200, 300);

final var mapper = new LongFunction<LongStream>() {
    @Override
    public LongStream apply(long value) {
        return LongStream.of(value, value + 1, value + 2);
    }
};

final var ret = stream.flatMap(mapper).toArray();

// [100, 101, 102, 200, 201, 202, 300, 301, 302]
System.out.println(Arrays.toString(ret));

void forEach (LongConsumer action)

Performs an action for each element of this stream.

Please see also : forEachOrdered(LongConsumer action)

final var stream = LongStream.of(10, 20, 30);

final var action = new LongConsumer() {
    @Override
    public void accept(long value) {
        System.out.println(value);
    }
};

System.out.println("-- forEach --");
stream.forEach(action);

// Result
// ↓
//-- forEach --
//10
//20
//30

// An example with a lambda expression.
final var stream = LongStream.of(-10, -20, -30);

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//-10
//-20
//-30

final var stream = LongStream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//30
//50
//40
//10
//20

void forEachOrdered (LongConsumer action)

Performs an action for each element of this stream, guaranteeing that each element is processed in encounter order for streams that have a defined encounter order.

final var stream = LongStream.of(10, 20, 30);

final var action = new LongConsumer() {
    @Override
    public void accept(long value) {
        System.out.println(value);
    }
};

System.out.println("-- forEach --");
stream.forEachOrdered(action);

// Result
// ↓
//-- forEach --
//10
//20
//30

final var stream = LongStream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true

System.out.println("-- forEach --");
stream.forEachOrdered(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//10
//20
//30
//40
//50

static LongStream generate (LongSupplier s)

Returns an infinite sequential unordered stream where each element is generated by the provided LongSupplier.

final var supplier = new LongSupplier() {
    long count = 0;

    @Override
    public long getAsLong() {
        count += 10;
        return count;
    }
};

final var stream = LongStream.generate(supplier);

final var ret = stream.limit(5).toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30, 40, 50]

static LongStream iterate (long seed, LongPredicate hasNext, LongUnaryOperator next)

Returns a sequential ordered LongStream produced by iterative application of the given next function to an initial element, conditioned on satisfying the given hasNext predicate.

final var hasNext = new LongPredicate() {
    @Override
    public boolean test(long value) {
        return value <= 100;
    }
};

final var next = new LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

final var stream = LongStream.iterate(1, hasNext, next);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 4, 8, 16, 32, 64]

static LongStream iterate (long seed, LongUnaryOperator f)

Returns an infinite sequential ordered LongStream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.

final var next = new LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

final var stream = LongStream.iterate(1, next);
final var ret = stream.limit(10).toArray();

// [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
System.out.println(Arrays.toString(ret));

LongStream limit (long maxSize)

Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.

final var stream = LongStream.of(10, 20, 30, 40, 50, 60);

final var ret = stream.limit(3).toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30]

LongStream map (LongUnaryOperator mapper)

Returns a stream consisting of the results of applying the given function to the elements of this stream.

final var stream = LongStream.of(1, 2, 3);

final var mapper = new LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

final var ret = stream.map(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [2, 4, 6]

final var stream = LongStream.range(0, 4);

final var ret = stream.map(v -> v * 100).toArray();
System.out.println(Arrays.toString(ret)); // [0, 100, 200, 300]

default LongStream mapMulti (LongStream.LongMapMultiConsumer mapper)

Returns a stream consisting of the results of replacing each element of this stream with multiple elements, specifically zero or more elements.

final var stream = LongStream.of(100, 200, 300);

final var mapper = new LongStream.LongMapMultiConsumer() {
    @Override
    public void accept(long value, LongConsumer lc) {
        lc.accept(value);
        lc.accept(value + 1);
        lc.accept(value + 2);
    }
};

final var ret = stream.mapMulti(mapper).toArray();

// [100, 101, 102, 200, 201, 202, 300, 301, 302]
System.out.println(Arrays.toString(ret));

DoubleStream mapToDouble (LongToDoubleFunction mapper)

Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.

final var stream = LongStream.of(100, 125, 200);

final var mapper = new LongToDoubleFunction() {
    @Override
    public double applyAsDouble(long value) {
        return value / 2.0;
    }
};

final var ret = stream.mapToDouble(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [50.0, 62.5, 100.0]

IntStream mapToInt (LongToIntFunction mapper)

Returns an IntStream consisting of the results of applying the given function to the elements of this stream.

final var stream = LongStream.of(10000000000L, 20000000000L, 30000000000L);

final var mapper = new LongToIntFunction() {
    @Override
    public int applyAsInt(long value) {
        return Math.toIntExact(value / 1000000000);
    }
};

final var ret = stream.mapToInt(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30]

<U> Stream<U> mapToObj (LongFunction<? extends U> mapper)

Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.

final var stream = LongStream.of(1, 2, 3);

final var mapper = new LongFunction<String>() {
    @Override
    public String apply(long value) {
        return "num=" + value;
    }
};

final var ret = stream.mapToObj(mapper).toList();
System.out.println(ret); // [num=1, num=2, num=3]

OptionalLong max ()

Returns an OptionalLong describing the maximum element of this stream, or an empty optional if this stream is empty.

final var stream = LongStream.of(10, 5, 100, 30);

final var opt = stream.max();
opt.ifPresent(value -> {
    System.out.println(value); // 100
});

final var stream = LongStream.empty();

final var opt = stream.max();
System.out.println(opt.isEmpty()); // true

OptionalLong min ()

Returns an OptionalLong describing the minimum element of this stream, or an empty optional if this stream is empty.

final var stream = LongStream.of(10, 5, 100, 30);

final var opt = stream.min();
opt.ifPresent(value -> {
    System.out.println(value); // 5
});

final var stream = LongStream.empty();

final var opt = stream.min();
System.out.println(opt.isEmpty()); // true

boolean noneMatch (LongPredicate predicate)

Returns whether no elements of this stream match the provided predicate.

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

{
    final var stream = LongStream.of(0, 2, 4);

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = LongStream.of(1, 2, 3);

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = LongStream.of(1, 3, 5);

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // true
}

static LongStream of (long t)

Returns a sequential LongStream containing a single element.

final var stream = LongStream.of(0);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0]

final var stream = LongStream.of(123456789000L);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [123456789000]

static LongStream of (long... values)

Returns a sequential ordered stream whose elements are the specified values.

final var stream = LongStream.of(10000000000L, 20000000000L, 30000000000L);
final var ret = stream.toArray();

// [10000000000, 20000000000, 30000000000]
System.out.println(Arrays.toString(ret));

LongStream peek (LongConsumer action)

Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.

final var stream = LongStream.of(10, 20, 30);

final var action = new LongConsumer() {
    @Override
    public void accept(long value) {
        System.out.println("peek : value = " + value);
    }
};

final var array = stream.peek(action).toArray();
System.out.println("array = " + Arrays.toString(array));

// Result
// ↓
//peek : value = 10
//peek : value = 20
//peek : value = 30
//array = [10, 20, 30]

static LongStream range (long startInclusive, long endExclusive)

Returns a sequential ordered LongStream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.

final var stream = LongStream.range(0, 10);
final var ret = stream.toArray();

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
System.out.println(Arrays.toString(ret));

final var stream = LongStream.range(-5, 5);
final var ret = stream.toArray();

// [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
System.out.println(Arrays.toString(ret));

static LongStream rangeClosed (long startInclusive, long endInclusive)

Returns a sequential ordered LongStream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.

final var stream = LongStream.rangeClosed(0, 10);
final var ret = stream.toArray();

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
System.out.println(Arrays.toString(ret));

final var stream = LongStream.rangeClosed(-5, 5);
final var ret = stream.toArray();

// [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
System.out.println(Arrays.toString(ret));

long reduce (long identity, LongBinaryOperator op)

Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.

final var stream = LongStream.of(1, 2, 3, 4);
final long identity = 0;

final var op = new LongBinaryOperator() {
    @Override
    public long applyAsLong(long left, long right) {
        if (identity == left) {
            return right;
        }

        return left + right;
    }
};

// 1 + 2 + 3 + 4 = 10
final var ret = stream.reduce(identity, op);
System.out.println(ret); // 10

final var stream = LongStream.empty();
final long identity = 0;

final var ret = stream.reduce(identity, (left, right) -> {
    if (identity == left) {
        return right;
    }

    return left + right;
});

System.out.println(ret); // 0

OptionalLong reduce (LongBinaryOperator op)

Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalLong describing the reduced value, if any.

final var stream = LongStream.of(1, 2, 3, 4);

final var op = new LongBinaryOperator() {
    @Override
    public long applyAsLong(long left, long right) {
        return left + right;
    }
};

// 1 + 2 + 3 + 4 = 10
final var opt = stream.reduce(op);
opt.ifPresent(value -> {
    System.out.println(value); // 10
});

final var stream = LongStream.empty();

final var opt = stream.reduce((left, right) -> left + right);
System.out.println(opt.isEmpty()); // true

LongStream skip (long n)

Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.

final var stream = LongStream.of(10, 20, 30, 40, 50, 60, 70);

final var ret = stream.skip(4).toArray();
System.out.println(Arrays.toString(ret)); // [50, 60, 70]

LongStream sorted ()

Returns a stream consisting of the elements of this stream in sorted order.

final var stream = LongStream.of(5, 3, 2, 4, 1);

final var ret = stream.sorted().toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5]

final var stream = LongStream.of(5, 3, 2, 4, 1).parallel();
System.out.println(stream.isParallel()); // true

final var ret = stream.sorted().toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5]

long sum ()

Returns the sum of elements in this stream.

final var stream = LongStream.of(1, 2, 3, 4, 5);
System.out.println(stream.sum()); // 15

final var stream = LongStream.of(-10, -20, -30);
System.out.println(stream.sum()); // -60

LongSummaryStatistics summaryStatistics ()

Returns a LongSummaryStatistics describing various summary data about the elements of this stream.

final var stream = LongStream.of(1, 2, 3, 4, 5);
final var ret = stream.summaryStatistics();

// LongSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}
System.out.println(ret);

default LongStream takeWhile (LongPredicate predicate)

Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.

final var stream = LongStream.of(1, 2, 3, 4, 5);

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        return value != 4;
    }
};

final var ret = stream.takeWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3]

final var stream = LongStream.of(-1, -2, -3, -4, -5);

final var ret = stream.takeWhile(v -> v != -3).toArray();
System.out.println(Arrays.toString(ret)); // [-1, -2]

long[] toArray ()

Returns an array containing the elements of this stream.

final var stream = LongStream.of(1, 2, 3, 4, 5);
final long[] ret = stream.toArray();

System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5]

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

Please see the link below.

• BaseStream with Examples