JAvaステップ--関数インタフェースとStreamストリーム

65811 ワード
Java階段
関数インタフェース
  • 概念:抽象的な方法が1つしかないインタフェースを関数インタフェースと呼ぶ.@FunctionalInterface注記チェックを使用できます.注意:1つのインタフェースが関数インタフェースであるかどうかは@FunctionalInterfaceとは何の関係もなく、抽象メソッドの個数にのみ関係しています.このインタフェースが関数インタフェースでない場合、この注釈を加えるとコンパイルエラーが発生します.
            ：JDK  Runnable           
          @FunctionalInterface
          public interface Runnable {
              public abstract void run();
          }
  • 使用シーン:メソッドとしてのパラメータまたは戻り値
  • JDKで一般的な関数インタフェース
  • Supplier:本番インタフェースT get():get()メソッドはパラメータを与える必要はなく、逆にTタイプの値を返します.
    		package com.jxufe_ldl.class02.supplier;

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        //        
        String str = getString(() -> "   ");
        System.out.println("str = " + str);

        //       
        int num = getInt( () -> 666);
        System.out.println("num = " + num);
    }

    private static String getString(Supplier<String> sup) {
        return sup.get();
    }

    private static int getInt(Supplier<Integer> sup) {
        return sup.get();
    }
}
  • Consumer:コンシューマインタフェースvoid accept(T t)：にはTタイプのパラメータが必要で、戻り値はありません.acceptでTタイプのデータを私たちに渡します.default Consumer andThen(Consumer super T> after):2つのConsumerを接続し、それぞれ消費データ
           ：
         //      (T t)
         list.forEach(num->System.out.println(num));
         System.out.println("--------------");
         //    
         list.forEach(System.out::println);
 ```java
 package com.jxufe_ldl.class01;
 
 import java.util.function.Consumer;
 
 public class ConsumerDemo {
     public static void main(String[] args) {
         //          
         String[] strArr = {"   ,30", "   ,35", "   ,33"};
 
         //     
         printInfo(strArr, (String s) -> {
             String name = s.split(",")[0];
             System.out.print("  :" + name);
         }, (String s) -> {
             int age = Integer.parseInt(s.split(",")[1]);
             System.out.println(",  :" + age);
         });
     }
     // Consumer           ,accept             
     private static void printInfo(String[] strArr, Consumer con1, Consumer con2) {
         for (String str : strArr) {
             con1.andThen(con2).accept(str);
         }
     }
 }
 
 ```
  • Predicate:判定型インタフェースboolean test(T t):与えられたT型のパラメータをtestメソッドで条件判定し、判定結果を返す.
    package com.jxufe_ldl.class01;

import java.util.function.Predicate;

public class PredicateDemoo02 {
    public static void main(String[] args) {
        boolean b1= checkString("hello", (String str) -> {
            return str.length() > 8;
        });

        System.out.println(b1);

        boolean b2 = checkString("hello", str -> str.length() > 8, str -> str.length() < 15);
        System.out.println(b2);
    }

    //               
    private static boolean checkString(String str, Predicate<String> pre) {
//        return pre.test(str);

        return pre.negate().test(str);
    }

    private static boolean checkString(String str, Predicate<String> pre1, Predicate<String> per2){
//        return pre1.or(per2).test(str);
        return pre1.and(per2).test(str);
    }
}
  • Function:変換インタフェースR apply(T t):Tタイプのパラメータをメソッドに渡し、Rタイプに変換して戻ってくる.
    package com.jxufe_ldl.class02.supplier;

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        String str = "   ,18";
        /*convert(str, (String s) -> {
            return str.split(",")[1];
        }, (String s) -> {
            return Integer.parseInt(s);
        }, (Integer i) -> {
            return i + 70;
        });*/

        convert(str, s -> str.split(",")[1], Integer::parseInt, i -> i + 70);

    }
    private static void convert(String str, Function<String,String> fun1, Function<String, Integer> fun2,
                                Function<Integer, Integer> fun3) {
        int i = fun1.andThen(fun2).andThen(fun3).apply(str);

        System.out.println(i);
    }
}


    • ストリームストリーム
  • コンセプト:Streamストリームは、操作セットのツールセットです.ツールセット:Streamストリームに多くの操作セットがカプセル化されている方法を指し、ツールとして直接使用すればいいです.
  • Streamsフロー操作の対象:単列集合、配列、Map集合(間接操作のみ).使用上の注意:Streamsオブジェクトは1回しか使用できません.そうしないと、java.lang.IllegalStateException: stream has already been operated upon or closed
    • という異常が発生します.
  • Streamフロー操作の手順:
  • は、StreamsストリームオブジェクトStreams stream=単列集合オブジェクトを生成する.stream(); Stream stream=Stream.of(T… t); 注記:Mapコレクションは、Streamストリームオブジェクトを生成するには、単一のカラムセット(keySet()またはentrySet())に変換する必要があります.
  • Streamストリームオブジェクトを呼び出す方法Stream filter​(Predicate predicate)：対流中のデータをフィルタリングするには、Predicateインタフェースを使用してフィルタ条件Stream limit​(long maxSize)：を渡す前に指定したパラメータ個数のデータを切り出し、切り出した要素からなる新しいストリームStream skip​(long n)：を返して指定したパラメータ個数のデータをスキップし、ストリームの残りの要素からなる新しいストリームstatic Stream concat​(Stream a, Stream b)：を返し、aとbの2つのストリームを1つのストリームStream distinct​()：の対流中の要素の重量除去(Object.equals(Object))からなるストリームStream sorted​()：を合成して、ストリームの要素からなるストリームを返し、自然順序に従ってStream sorted​(Comparator comparator)：を並べてストリームの要素からなるストリームを返し、提供されたComparatorの順序付けStream map​(Function mapper)：に従ってストリーム中のデータを別のタイプに変換して記憶し、新しいストリームオブジェクトを返す.Function変換型インタフェースにおける方法R apply(T t)void forEach​(Consumer action)：は、消費ストリーム中のデータlong count​()：を巡回し、このストリーム中の要素の個数
    • を返す.
  • ストリーム中のデータを集合List listA=streamAに変換する.collect(Collectors.toList()); Set setB = streamB.collect(Collectors.toSet()); 

    • package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
         ArrayList  ，    6       6      ，         ：
        1:        3      
        2:        ，       
        3:                     
        4:                         ,    
               Actor    ，         ，        ，         get/set  
*/
public class Streamdemo06 {
    public static void main(String[] args) {
        //    
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("   ");
        manList.add("  ");
        manList.add("   ");
        manList.add("  ");
        manList.add("   ");
        manList.add("   ");


        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("   ");
        womanList.add("   ");
        womanList.add("   ");
        womanList.add("  ");
        womanList.add("   ");
        womanList.add("   ");

        // 1:        3      
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        // 2:        ，       
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith(" ")).skip(1);

        // 3:                     
        Stream<String> concatStream = Stream.concat(manStream, womanStream);

        // 4:                         ,    
//        concatStream.map(Actor::new).forEach(System.out::println);
        concatStream.map(s -> new Actor(s)).forEach(System.out::println);

    }
}


    package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo05 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("123");
        list.add("223");
        list.add("333");
        list.add("444");
        list.add("555");

        // R apply(T t);
        list.stream().map(s -> {
            return Integer.parseInt(s);
        }).forEach(System.out::println);
    }
}


    package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("liuxiaoyu");
        list.add("liudaliang");
        list.add("yumanli");
        list.add("liukun");
        list.add("liuxiaoliang");
        list.add("caixukun");

        //       
        list.stream().sorted().forEach(System.out::println);
        System.out.println("---------");

        //            
        list.stream().sorted((s1, s2) -> s1.length() - s2.length()).forEach(System.out::println);
        System.out.println("---------");

        //            
        list.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            num = num == 0 ? s1.compareTo(s2) : num;
            return num;
        }).forEach(System.out::println);

    }
}


    package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
      :          .
    static Stream concat(Stream a, Stream b) :        ,      Stream   ,    Stream  
                :    Stream      Stream
    Stream distinct() :    , Stream          .
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("   ");
        list.add("   ");
        list.add("   ");
        list.add("  ");
        list.add("   ");
        list.add("   ");

        //      4   
        Stream<String> streamA = list.stream().limit(4);

        //        ,        
        Stream<String> streamB = list.stream().skip(2);

        //           
        Stream<String> streamC = Stream.concat(streamA, streamB);
//        streamC.forEach(System.out::println);

        //           ,        
        Stream<String> streamD = streamC.distinct();
        streamD.forEach(System.out::println);
    }
}


    package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("   ");
        list.add("   ");
        list.add("   ");
        list.add("  ");
        list.add("   ");
        list.add("   ");

        //   3   
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");

        //    2   
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("--------");

        //    2   ,   3   
        list.stream().skip(2).limit(3).forEach(System.out::println);

    }
}


    package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class StreamDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("   ");
        list.add("   ");
        list.add("   ");
        list.add("  ");
        list.add("   ");

        // list.stream().filter(s->s.startsWith(" ")).filter(s->s.length() == 3).forEach(System.out::println);
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith(" ");
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 3;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        list.stream().filter((String s) -> {
                return s.startsWith(" ");
            }
        ).filter((String s) -> {
                return s.length() == 3;
            }
        ).forEach((String s) -> {
                System.out.println(s);
            }
        );
    }
}


    package com.jxufe_ldl.class03;

/*
       
 */
public class Actor {
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                '}';
    }
}
    ヒルソート(python)
    RotateAnimationクラスRotateAnimationクラスRotateAnimationクラス:回転変化アニメーションクラス