Java 8新機能まとめ

かんすうしきプログラミング
演算プロセスを関数にカプセル化し,関数呼び出しにより対応する機能を実現する

//      
Integer result=(a+b)*c-d;
//      
Integer result = subtract(multiply(add(a,b), c), d);

関数インタフェース
インタフェースに抽象的なメソッドが1つしか含まれていないインタフェースを関数インタフェースと呼ぶ
JAva 8の新しい関数インタフェースはjavaにあります.util.funtionパッケージでよく使われるのは以下の通りです.

BiConsumer<T,U>  //            
BiFuction<T,U,R> //     ,    
Consumer<T>  //          

default:インタフェースではdefaultキーワードを使用して、インタフェースにデフォルトのメソッドの実装を含ませることができます.このような設計は、互換性と拡張のために、1つのインタフェースが万以上のクラス実装され、インタフェースに抽象的なメソッドを追加すると、万以上のクラスが変更されますが、defaultメソッドでこれらのクラスを変更する必要はありません.シームレスな拡張機能を実現することができる.
Lambda式
コードの作成をより速く、より優雅にするためのプロパティ構文は、次のとおりです.

(arg1,arg2)->{ //   }

関数インタフェースを使用する場所でlambda式を使用することができます.関数インタフェースには抽象的な方法が1つしかないので、方法のパラメータタイプを決定することができます.->後に続くのはパラメータに対する操作です.
匿名の内部クラスとlambdaの比較を使用する

@FunctionalInterface
public interface MyInterface {
    void m1();
}

//           labmda   ,       
        MyInterface myInterface = new MyInterface() {
            @Override
            public void m1() {
                System.out.println("no lambda");
            }
        };

        myInterface.m1();

        // use lambda
        MyInterface myInterface1 = () -> System.out.println("lambda!");
        myInterface1.m1();

パラメータ付き戻り値付き

public interface MyInterfaceWithParam {
    int sum(int a,int b);
}
MyInterfaceWithParam param = (a, b) -> a + b; //   return

System.out.println(param.sum(1, 2));

注意:関数インタフェースは1つの入力カッコで省略でき、1つの文のカッコで省略できます.戻り値付きインタフェースは、1つの文だけが値を返す場合は省略できます.
Stream
コレクションの操作が容易

public class Student {
    private String name;
    private Integer score;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    public Student(String name, Integer score) {

        this.name = name;
        this.score = score;
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }
}

public class InitData {
    public static List<Student>  getList(){
        List<Student> stuList = new ArrayList<>(10);
        stuList.add(new Student("  ", 85));
        stuList.add(new Student("  ", 90));
        stuList.add(new Student("  ", 98));
        stuList.add(new Student("  ", 88));
        stuList.add(new Student("  ", 83));
        stuList.add(new Student("  ", 95));
        stuList.add(new Student("  ", 87));
        stuList.add(new Student("  ", 84));
        stuList.add(new Student("  ", 100));
        stuList.add(new Student("  ", 95));
        return stuList;
    }
}
List<Student> list=InitData.getList();
public static void main(String[] args) {
	List<Student> list=InitData.getList();
	 //          90         
        List<Student> result=new ArrayList<>(10);
        for (Student s:stuList){
            if (s.getScore()>=90){
                result.add(s);
            }
        }
        result.sort((s1,s2)->Integer.compare(s2.getScore(),s1.getScore()));
        System.out.println(result);

        //   stream  
        result=stuList.stream()
                .filter(student -> student.getScore()>=90)
//                .sorted((s1,s2)->Integer.compare(s2.getScore(),s1.getScore()))
                .sorted(Comparator.comparing(Student::getScore).reversed())
                .collect(Collectors.toList());
        System.out.println(result);
}

// stream       
 public static void main(String[] args) {
        List<Student> list=InitData.getList();
        Stream<Student>studentStream= list.stream();
        studentStream.forEach(System.out::println);
        studentStream.forEach(System.out::println); //     
    }

 public static void main(String[] args) {
        List<Student> list=InitData.getList();
        //   map        
        List<Integer> scoreList=list.stream()
                .map(Student::getScore)
                .collect(Collectors.toList());
        System.out.println(scoreList);
        //   map      
        List<Integer> len=list.stream()
                .map(Student::getName)
                .map(String ::length)
                .collect(Collectors.toList());
        System.out.println(len);

        //      -10
        List<Integer> score10List=list.stream()
                .map(Student::getScore)
                .map(integer -> integer-10)
                .collect(Collectors.toList());
        System.out.println(score10List);
        //       
        int count=list.stream()
                .map(Student::getScore)
                .reduce(0,(a,b)->a+b);
        System.out.println(count);

        //       
        Optional<Integer> count1=list.stream()
                .map(Student::getScore)
                .reduce((a,b)->a+b);
        System.out.println(count1.get());

        //      
        Optional<Integer> max=list.stream()
                .map(Student::getScore)
                .reduce(Integer::max);
        System.out.println(max.get());

        //      
        Optional<Integer> min=list.stream()
                .map(Student::getScore)
                .reduce(Integer::min);
        System.out.println(min.get());
//        list.stream().reduce(Comparator.comparing())
    }

 public static void main(String[] args) {
        List<Student> list = InitData.getList();
        int sum = list.stream().mapToInt(Student::getScore).sum();
        System.out.println(sum);

        //      
        OptionalDouble avg = list.stream().mapToInt(Student::getScore).average();
        System.out.println(avg.getAsDouble());

        //     
        IntStream is = IntStream.rangeClosed(1, 100);// closed     

        //   1-100       
        long l= IntStream.rangeClosed(1, 100)
                        .filter(s -> s % 2 == 0)
                        .count();
        System.out.println(l);
    }
 public static void main(String[] args) {
        //   stream of  
        String[] arr = {"i", "love", "this", "game"};
        Stream.of(arr).map(String::toUpperCase).forEach(System.out::println);

        //   Arrays.stream
        int[] nums = {2, 3, 7, 5};
        int a = Arrays.stream(nums).sum();
        System.out.println(a);

        //                ,  10 
        Stream.iterate(0,n -> n + 2).limit(10).forEach(System.out::println);
    }