package com.bwwei;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.*;
import java.util.stream.*;

/**
 * @Classname ${NAME}
 * @Description TODO
 * @Date 2024/8/8 上午8:35
 * @Created by 杨旭飞
 */
public class Main {
    public static void main(String[] args) {

        String name1 = "1 张三 语文 100";
        int score1 = 100;
        String name2 = "2 李四 数学 90";
        int score2 = 90;
        String name3 = "3 王五 英语 80";
        int score3 = 80;
        String name4 = "4 赵六 化学 60";
        int score4 = 60;
        String name5 = "5 田七 物理 55";
        int score5 = 50;

        Stream<Object> objectStream = new Stream<>() {
            @Override
            public Stream<Object> filter(Predicate<? super Object> predicate) {
                return Stream.empty();
            }

            @Override
            public <R> Stream<R> map(Function<? super Object, ? extends R> mapper) {
                return Stream.empty();
            }

            @Override
            public IntStream mapToInt(ToIntFunction<? super Object> mapper) {
                return IntStream.empty();
            }

            @Override
            public LongStream mapToLong(ToLongFunction<? super Object> mapper) {
                return LongStream.empty();
            }

            @Override
            public DoubleStream mapToDouble(ToDoubleFunction<? super Object> mapper) {
                return DoubleStream.empty();
            }

            @Override
            public <R> Stream<R> flatMap(Function<? super Object, ? extends Stream<? extends R>> mapper) {
                return Stream.empty();
            }

            @Override
            public IntStream flatMapToInt(Function<? super Object, ? extends IntStream> mapper) {
                return IntStream.empty();
            }

            @Override
            public LongStream flatMapToLong(Function<? super Object, ? extends LongStream> mapper) {
                return LongStream.empty();
            }

            @Override
            public DoubleStream flatMapToDouble(Function<? super Object, ? extends DoubleStream> mapper) {
                return DoubleStream.empty();
            }

            @Override
            public Stream<Object> distinct() {
                return Stream.empty();
            }

            @Override
            public Stream<Object> sorted() {
                return Stream.empty();
            }

            @Override
            public Stream<Object> sorted(Comparator<? super Object> comparator) {
                return Stream.empty();
            }

            @Override
            public Stream<Object> peek(Consumer<? super Object> action) {
                return Stream.empty();
            }

            @Override
            public Stream<Object> limit(long maxSize) {
                return Stream.empty();
            }

            @Override
            public Stream<Object> skip(long n) {
                return Stream.empty();
            }

            @Override
            public void forEach(Consumer<? super Object> action) {

            }

            @Override
            public void forEachOrdered(Consumer<? super Object> action) {

            }

            @Override
            public Object[] toArray() {
                return new Object[0];
            }

            @Override
            public <A> A[] toArray(IntFunction<A[]> generator) {
                return null;
            }

            @Override
            public Object reduce(Object identity, BinaryOperator<Object> accumulator) {
                return null;
            }

            @Override
            public Optional<Object> reduce(BinaryOperator<Object> accumulator) {
                return Optional.empty();
            }

            @Override
            public <U> U reduce(U identity, BiFunction<U, ? super Object, U> accumulator, BinaryOperator<U> combiner) {
                return null;
            }

            @Override
            public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super Object> accumulator, BiConsumer<R, R> combiner) {
                return null;
            }

            @Override
            public <R, A> R collect(Collector<? super Object, A, R> collector) {
                return null;
            }

            @Override
            public Optional<Object> min(Comparator<? super Object> comparator) {
                return Optional.empty();
            }

            @Override
            public Optional<Object> max(Comparator<? super Object> comparator) {
                return Optional.empty();
            }

            @Override
            public long count() {
                return 0;
            }

            @Override
            public boolean anyMatch(Predicate<? super Object> predicate) {
                return false;
            }

            @Override
            public boolean allMatch(Predicate<? super Object> predicate) {
                return false;
            }

            @Override
            public boolean noneMatch(Predicate<? super Object> predicate) {
                return false;
            }

            @Override
            public Optional<Object> findFirst() {
                return Optional.empty();
            }

            @Override
            public Optional<Object> findAny() {
                return Optional.empty();
            }

            @Override
            public Iterator<Object> iterator() {
                return null;
            }

            @Override
            public Spliterator<Object> spliterator() {
                return null;
            }

            @Override
            public boolean isParallel() {
                return false;
            }

            @Override
            public Stream<Object> sequential() {
                return Stream.empty();
            }

            @Override
            public Stream<Object> parallel() {
                return Stream.empty();
            }

            @Override
            public Stream<Object> unordered() {
                return Stream.empty();
            }

            @Override
            public Stream<Object> onClose(Runnable closeHandler) {
                return Stream.empty();
            }

            @Override
            public void close() {

            }

        };

        System.out.println(name1);
        System.out.println(name2);
        System.out.println(name3);
        System.out.println(name4);
        System.out.println(name5);

        System.out.println("平均成绩为成绩单"+(score1+score2+score3+score4+score5)/5);
    }
}