A sequence of elements supporting sequential and parallel aggregate

* operations.  The following example illustrates an aggregate operation using

* {@link Stream} and {@link IntStream}:

*

* <pre>{@code

*     int sum = widgets.stream()

*                      .filter(w -> w.getColor() == RED)

*                      .mapToInt(w -> w.getWeight())

*                      .sum();

* }</pre>

* In this example, {@code widgets} is a {@code Collection<Widget>}.  We create

* a stream of {@code Widget} objects via {@link Collection#stream Collection.stream()},

* filter it to produce a stream containing only the red widgets, and then

* transform it into a stream of {@code int} values representing the weight of

* each red widget. Then this stream is summed to produce a total weight.

* <p>In addition to {@code Stream}, which is a stream of object references,

* there are primitive specializations for {@link IntStream}, {@link LongStream},

* and {@link DoubleStream}, all of which are referred to as "streams" and

* conform to the characteristics and restrictions described here.

* <p>To perform a computation, stream

* <a href="package-summary.html#StreamOps">operations</a> are composed into a

* <em>stream pipeline</em>.  A stream pipeline consists of a source (which

* might be an array, a collection, a generator function, an I/O channel,

* etc), zero or more <em>intermediate operations</em> (which transform a

* stream into another stream, such as {@link Stream#filter(Predicate)}), and a

* <em>terminal operation</em> (which produces a result or side-effect, such

* as {@link Stream#count()} or {@link Stream#forEach(Consumer)}).

* Streams are lazy; computation on the source data is only performed when the

* terminal operation is initiated, and source elements are consumed only

* as needed.

/**

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

 *

 * @param <T> the type of stream elements

 * @param values the elements of the new stream

 * @return the new stream

 */

@SafeVarargs

@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {

    return Arrays.stream(values);

}

Stream stream1 = Stream.of("zhangsan", "lisi", "wangwu");

String[] str2 = {"zhangsan", "lisi", "wangwu"};

Stream stream2 = Stream.of(str2);

List list3 = Arrays.asList("zhangsan", "lisi", "wangwu");

Stream stream3 = list3.stream();

IntStream.of(3,1,4,9).forEach(System.out::println);

IntStream.range(1,4).forEach(System.out::println);

System.out.println("---");

IntStream.rangeClosed(1,4).forEach(System.out::println);

List<Integer> partList3 = Arrays.asList(1,2,3);

Integer sum3 = 0;

for (Integer o : partList3) {

    sum3 += o * 2;

}

Integer sum33 = partList3.stream().map(integer -> integer * 2).reduce(0,Integer::sum);

/**

 * Returns a stream consisting of the results of applying the given

 * function to the elements of this stream.

 *

 * <p>This is an <a href="package-summary.html#StreamOps">intermediate

 * operation</a>.

 *

 * @param <R> The element type of the new stream

 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

 *               <a href="package-summary.html#Statelessness">stateless</a>

 *               function to apply to each element

 * @return the new stream

 */

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

  T reduce(T identity, BinaryOperator<T> accumulator);

T result = identity;

for (T element : this stream)

    result = accumulator.apply(result, element)

    return result;

}

Stream<String> stream4 = Stream.of("a", "k", "g", "b");

/**

 * Returns an array containing the elements of this stream, using the

 * provided {@code generator} function to allocate the returned array, as

 * well as any additional arrays that might be required for a partitioned

 * execution or for resizing.

 *

 * <p>This is a <a href="package-summary.html#StreamOps">terminal

 * operation</a>.

 *

 * @apiNote

 * The generator function takes an integer, which is the size of the

 * desired array, and produces an array of the desired size.  This can be

 * concisely expressed with an array constructor reference:

 * <pre>{@code

 *     Person[] men = people.stream()

 *                          .filter(p -> p.getGender() == MALE)

 *                          .toArray(Person[]::new);

 * }</pre>

 *

 * @param <A> the element type of the resulting array

 * @param generator a function which produces a new array of the desired

 *                  type and the provided length

 * @return an array containing the elements in this stream

 * @throws ArrayStoreException if the runtime type of the array returned

 * from the array generator is not a supertype of the runtime type of every

 * element in this stream

 */

<A> A[] toArray(IntFunction<A[]> generator)

String[] streamArr1 = stream4.toArray(len -> new String[len]);

String[] streamArr2 = stream4.toArray(String[]::new);

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);

Performs a <a href="package-summary.html#MutableReduction">mutable

* reduction</a> operation on the elements of this stream.  A mutable

* reduction is one in which the reduced value is a mutable result container,

* such as an {@code ArrayList}, and elements are incorporated by updating

* the state of the result rather than by replacing the result.  This

* produces a result equivalent to:

* <pre>{@code

*     R result = supplier.get();

*     for (T element : this stream)

*         accumulator.accept(result, element);

*     return result;

* }</pre>

R result = supplier.get();

   for (T element : this stream)

        accumulator.accept(result, element);

   return result;

 }

Stream<String> stream5 = Stream.of("hello", "world", "good", "morning");

List<String> list5 = stream5.collect(() -> new ArrayList<>(),(list1,item) -> list1.add(item),(list2,list1) -> list2.addAll(list1));

list5.forEach(System.out::println);

Stream<String> stream444 = Stream.of("list1", "list2", "list3");

List<String> list444 = stream444.collect(Collectors.toList());

list444.forEach(System.out::println);

Collectors.toCollection(LinkedList::new)

Collectors.joining()

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

Stream<List<Integer>> stream7 = Stream.of(Arrays.asList(1,2), Arrays.asList(3), Arrays.asList(4,5));

List<Integer> list7 = stream7.flatMap(list -> list.stream()).collect(Collectors.toList());

System.out.println(list7);