共通のインタフェース機能

その他 2019-10-04 10:35:43 訪問数: null

共通のインタフェース機能

  • インタフェース（だけではなく片道）のみ抽象メソッドが含まれています
  • インターフェースは、多くの場合、ラムダ式に関連しています
  • ラムダは、パフォーマンスの浪費を避けるために、遅延ロードを表現します

サプライヤー - 生産・インタフェース

  • TのGET（）、一般的なパラメータを得るために使用されるオブジェクト・データのタイプを指定：java.util.function.Supplierは<汎用T>は、ノンパラメトリックインターフェースのメソッドを含みます。これは、対応するラムダ式を意味機能インタフェースであるため、対象データの一般的なタイプに合わせて「外部提供」する必要があります。

  • サプライヤー<>インターフェイスは、戻り値があり、一般的なインタフェースは、その後、インターフェイスメソッドが生成されるデータの種類種類を取得します指定するには、生産・インタフェースと呼ばれています。

package cn.learn;

import java.util.function.Supplier;

public class function {
    //定义一个方法，方法参数传递Supplier<>接口，泛型执行String.get方法就会返回一个String
    public static String getString(Supplier<String> stringSupplier){
        return stringSupplier.get();
    }

    public static void main(String[] args) {
        //调用getString方法，方法的参数是一个函数式表达接口，所以传递lambda表达式
        String str = getString(() ->{
           //生产一个字符串，并返回
           return "aaa"; 
        });

        System.out.println(str);

        //优化Lambda表达式
        str = getString(() -> "aaa");

        System.out.println(str);
        
    }
}

演習：最大配列要素を探します

package cn.learn;

import java.util.function.Supplier;

public class function {
    public static Integer getMax(Supplier<Integer> stringSupplier){
        return stringSupplier.get();
    }

    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[]{3,55,66,77,88,-5};

        //调用getMax方法,使用Lambda表达式简写
        int integermax = getMax(() ->{
           //获取数组最大值并返回
           int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (max < arr[i]){
                    max = arr[i];
                }
            }
            return max;
        });

        /******
        //调用getMax方法
        getMax(new Supplier<Integer>() {
            @Override
            public Integer get() {
                //获取数组最大值并返回
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) {
                    if (max < arr[i]) {
                        max = arr[i];
                    }
                }
                return max;
            }
        });
        *******/

        System.out.println(integermax);
    }
}

消費者 - 消費者インタフェース

  • java.util.function.Consumer正確に反しインタフェースを持つ<一般>サプライヤーインタフェースは、それが生産データ、消費データではなく、データ型がジェネリックによって決定されることを

  • 消費者インターフェースは、抽象メソッドの空隙は、意図した消費データは、一般的な、非戻り値として指定される（T tを）受け入れる含みます

package cn.learn;

import java.util.function.Consumer;

public class function {
    //accept方法接受的数据可以输出、计算等
    public static void print(Integer year,Consumer<Integer> age){
        age.accept(year);
    }

    public static void main(String[] args) {

        //消费方式：直接输出
        print(2018,(year) -> System.out.println("你的出生年是"+year));

        //消费方式：反转字符串
        print(2018,(year) -> {
            String string = year.toString();
            String re = new StringBuilder(string).reverse().toString();
            System.out.println(re);
        });
    }
}

  • デフォルトの方法--andThen消費者法

  • その後、組み合わせを達成するために、操作を行うには、アクションを行うには、まず最初に消費データを、そしてこの方法は、デフォルトの方法消費者インタフェースです：メソッドのパラメータと戻り値は、すべての消費者のタイプがある場合は、達成することができます

  • JDKのソースコード

   default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

注：requireNonNull静的メソッドのjava.util.Objectは、文とnullポインタ例外のトラブルをスローした場合に記述する必要がなくなりれ、異常なパラメータがnullのときにNullPointerExceptionをスローするためのイニシアチブをとるだろう。

  • 組み合わされた効果を達成するために、2つのラムダ式をすることができ、およびセマンティクスが「ステップステップによって」操作andThenされ、例えば、組合せ中の2つのステップの場合：

    • 消費者<泛型文字列> CON1。
      消費者<泛型文字列> CON2。
      文字列str = "こんにちは";
      con1.accept（STR）。
      con2.accept（STR）。 

package cn.learn;

import java.util.function.Consumer;

public class function {
    //把两个Consumer接口组合到一起，再对数据进行消费
    public static void method(String str,Consumer<String> con1,Consumer<String> con2){
        
        //使用原始方式
        con1.accept(str);
        con2.accept(str);
        
    }

    public static void main(String[] args) {
        
        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method("Hello",(str) -> {
            //消费方式：转为大写
            System.out.println(str.toUpperCase());
        },(str) ->{
            //消费方式：转为小写
            System.out.println(str.toLowerCase());
        });
        
    }
}
  • 次に、2つのインターフェイスの消費を接続（WHO最初、誰でも消費）することができる代わり
    con1.andThen（CON2）.accept（STR） 。
package cn.learn;

import java.util.function.Consumer;

public class function {
    //andThen需要两个Consumer接口，可以把两个Consumer接口组合到一起，再对数据进行消费
    public static void method(String str,Consumer<String> con1,Consumer<String> con2){
        
        //先使用con1消费数据，再使用con2
        con1.andThen(con2).accept(str);

    }

    public static void main(String[] args) {

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method("Hello",(str) -> {
            //消费方式：转为大写
            System.out.println(str.toUpperCase());
        },(str) ->{
            //消费方式：转为小写
            System.out.println(str.toLowerCase());
        });

    }
}

演習：フォーマットされた印刷情報

package cn.learn;

import java.util.function.Consumer;

public class function {
    //使用两个Consumer来消费字符串，泛型为字符数组
    public static void method(String[] str,Consumer<String[]> con1,Consumer<String[]> con2){

        //先使用con1消费数据，再使用con2
        con1.andThen(con2).accept(str);

    }

    public static void main(String[] args) {

        //定义一个字符串数组
        String[] person ={"小王,男","大王,女"};

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method(person,(str) -> {
            //消费方式：取人名
            for (String name:str) {
                //取第一个元素
                System.out.println(name.split(",")[0]);
            }
        },(str) ->{
            //消费方式：取性别
            for (String name:str) {
                //取第一个元素
                System.out.println(name.split(",")[1]);
            }
        });
    }
}

結果：
エイミー
キング
男性
女性

  • もう一つの方法
package cn.learn;

import java.util.function.Consumer;

public class function {
    //使用两个Consumer来消费字符串，泛型为字符数组
    public static void method(String[] str,Consumer<String> con1,Consumer<String> con2){
        //将遍历写在此处，预防重复造轮子
        for (String message:str) {
            //先使用con1消费数据，再使用con2
            con1.andThen(con2).accept(message);
        }


    }

    public static void main(String[] args) {

        //定义一个字符串数组
        String[] person ={"小王,男","大王,女"};

        //原始使用方式，调用method方法，需要传递两个Lambda表达式
        method(person,(message) -> {
            //消费方式：取人名
                System.out.println(message.split(",")[0]);
        },(message) ->{
            //消费方式：取性别
                System.out.println(message.split(",")[1]);
        });
    }
}

結果：
王
男性の
王の
女性

述語 - 裁判官インタフェース

  • 時々、私たちは、あなたがjava.util.function.predicate <ジェネリック>インタフェースを使用することができ、それによって、ブール値の結果を得るために、データ型決意データである必要

  • ブーリアンテスト（T tの）：述語インタフェースは抽象メソッドを含みます。シーンを決定するための条件は、ブール値を返します。

`` `Javaの
パッケージcn.learn。

輸入java.util.function.Predicate。

パブリッククラス機能{
//
パブリック静的ブールcheckMethod（文字列str、述語 PRE）{
戻りpre.test（STR）。
} 

public static void main(String[] args) {

    String str = "hello"; 

    //对字符串进行校验
    boolean check = checkMethod(str,(String str01) ->{
       return str01.length()>5;
    });

    boolean check1 = checkMethod(str,str01 -> str01.length()>3);

    System.out.println(check);
    System.out.println(check1);
}

}

  • デフォルトの方法：と - ほとんどより多くの判断条件を判断し、「&&」することができます
package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1, Predicate<String> pre2){
        //等价于return pre1.test(str) && pre2.test(str);
        return pre1.and(pre2).test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        },(str01) ->{
            return str01.contains("1");
        });


        System.out.println(check);
    }
}

偽

  • デフォルトの方法：または - 複数の条件や判断を決定することができ、「||」はほとんど
package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1, Predicate<String> pre2){
        //等价于return pre1.test(str) || pre2.test(str);
        return pre1.or(pre2).test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        },(str01) ->{
            return str01.contains("1");
        });


        System.out.println(check);
    }
}

真

  • デフォルトの方法：ネゲート - より多くの判定条件を判断し、ほとんどのことができます「！」

package cn.learn;

import java.util.function.Predicate;

public class function {
    //
    public static boolean checkMethod(String str, Predicate<String> pre1){
        //等价于return !pre1.test(str);
        return pre1.negate().test(str);
    }

    public static void main(String[] args) {

        String str = "hello";

        //对字符串进行校验
        boolean check = checkMethod(str,(String str01) ->{
           return str01.length()>3;
        });


        System.out.println(check);
    }
}

偽

演習：情報フィルタリングのコレクション

  • 名前はセットから選択された2つの文字と女性の文字列で、文字列は必要の注目を決定しているequalsメソッドを
package cn.learn;

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

public class function {

    public static ArrayList<String> filter(String[] str, Predicate<String> pre1, Predicate<String> pre2) {

        //放外边，里边会重复申请
        ArrayList<String> correct = new ArrayList<>();
        //遍历数组
        for (String message : str) {
            boolean ifCorr = pre1.and(pre2).test(message);
            //满足条件的放入集合
            if (ifCorr) {
                correct.add(message);
            }
        }
        return correct;

    }

    public static void main(String[] args) {

        String[] str = {"小王,女", "大王,男", "小白,男", "王小白,女"};

        //对字符串进行筛选,并返回需要的集合
        ArrayList<String> list = filter(str, (String str01) -> {
            return str01.split(",")[0].length() == 2;
        }, (str01) -> str01.split(",")[1].equals("女") );


        System.out.println(list);
    }
}

[王、女性]

機能 - データ型変換インタフェース

  • java.util.function.Function <T、R>インターフェイスは、事後条件と呼ばれ、前者が前提条件と呼ばれる別のデータ型へのデータ型を得るために使用されます。

  • 抽象メソッドは：Rが適用され、適用されます 型Tのパラメータに従って結果R型を得る、それは別の型の値を返します。 

package cn.learn;


import java.util.function.Function;

public class function {

    public static Integer convert(String str, Function<String,Integer> function){
        //返回一个Integer类型
        return function.apply(str);
    }

    public static void main(String[] args) {
        String str = "2018";
        //调用convert方法转换类型，并用Lambda表达式重写apply方法
        Integer strInt = convert(str,(String str01) ->{
           return  Integer.parseInt(str01);
        });

        System.out.println(strInt);
    }
}

  • デフォルトの方法：andThen、操作を組み合わせるために使用

  • 需要：文字列型整数、計算の結果を変換し、
    その後、整数を戻すように変換

package cn.learn;


import java.util.function.Function;

public class function {

    public static String convert(String str, Function<String,Integer> fun1,Function<Integer,String> fun2){
        //返回一个String类型
        return fun1.andThen(fun2).apply(str);
    }

    public static void main(String[] args) {
        String str = "2018";
        //调用convert方法转换类型，取出字符串对应的值并进行运算，再转换为String
        str = convert(str,str01 ->Integer.parseInt(str01)+10,int01 -> int01.toString());
        System.out.println(str);
    }
}

2028

おすすめ

転載: www.cnblogs.com/huxiaobai/p/11621436.html
おすすめ
ランキング
Oracleのクエリ重複フィールド
An error occurred when ssm used count to query data
【Leyes de la Naturaleza】La sabiduría de las multitudes
JavaWebの研究では、（13）を締結 - セッションの使用は、重複送信フォームを防ぎます
Firebase増加サインアップクォータ
[MyBatisフレームワーク]mybatis入門
ハートレスの世界
Djangoのインストールと使用について
[转] UiPath展開アーキテクチャ
mybatis-plusは楽観的なロック変更を使用します
アーカイブ
もっと
2024-05-14(9)
2024-05-13(8)
2024-05-12(27)
2024-05-11(31)
2024-05-10(33)
2024-05-09(30)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)

コードワールド

© 2018 codetd.com