Java8 nouvelles fonctionnalités ------ API Stream et classe en option

API flux

1, la compréhension API Stream

①, le souci Stream est l'exploitation des données, traitant de la CPU. Collection souci est de stocker des données, le traitement de la mémoire

②, java8 fournit un api, api peut utiliser ce filtre, trier les données dans le mappage de la mémoire, et une autre opération de réduction. opérations connexes similaires aux tables de base de données sql.

2, notes

①, les éléments eux-mêmes flux ne sont pas stockés

②, Stream ne change pas l'objet source. Au lieu de cela, ils retourneront le résultat de la tenue d'un nouveau flux

③, opération de retard flux est effectuée. Cela signifie qu'ils devront attendre les résultats avant l'exécution

3, le flux d'exécution Torrent

①, instanciation flux

②, une série intermédiaire d'opérations (filtrage, cartographie, ...)

③, l'opération se terminant

4, Description:

Une chaîne intermédiaire des opérations, sur la source de données sont traitées

À la cessation d'opérations effectuées, l'opération est exécutée chaîne intermédiaire, et produire des résultats. Après cela, il ne sera pas utilisé

5, le fonctionnement du flot intermédiaire:

①, le dépistage de la tranche

code est le suivant:

@Test
public void test4(){
    List<Employee> list = EmployeeData.getEmployees();
    Stream<Employee> stream = list.stream();
    //filter
    stream.filter(e ->e.getSalary() > 7000).forEach(System.out::println);
    //limit
    list.stream.limit(3).forEach(System.out::println);
    //limit
    list.stream.skip(3).forEach(System.out::println);
    //distinct
    list.stream.distinct().forEach(System.out::println);
}

②, le mappage

de code est ensuit que:

  @Test
    public void test4(){
        List<String> list = Arrays.asList("AA","BB","cc","dd");
        list.stream().map(str -> str.toLowerCase()).forEach(System.out::println);
        //获取员工姓名长度大于3的员工姓名
        List<Employee> employees = EmployeeData.getEmployees();
        //map和filter
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);

        //map
        Stream<Stream<Character>> streamStream = list.stream().map(ProxyTest::fromStringToStream);
        streamStream.forEach(s -> s.forEach(System.out::println));
        //flatMap
        Stream<Character> characterStream = list.stream().flatMap(ProxyTest::fromStringToStream);
        characterStream.forEach(System.out::println);
        
    }

    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character character : str.toCharArray()){
            list.add(character);
        }
        return  list.stream();
    }

③, sorte

de code est suit comme:

@Test
public void test7() {
    //sorted()-自然排序
    List<Integer> list = Arrays.asList(12, 43, 34, 87, -98, 7);
    list.stream().sorted().forEach(System.out::println);
    //sorted(Comployee com)-定制排序
    List<Employee> employees = EmployeeData.getEmployees();
    employees.stream().sorted((e1, e2) -> {
        int ageValue = Integer.compare(e1.getAge(), e2.getAge());
        if (ageValue != 0) {
            return ageValue;
        } else {
            return -Double.compare(e1.getSalary(), e2.getSalary());
        }
    }).forEach(System.out::println);
    
}

6, les opérations de terminaison de flux:

① et trouver correspondant

à code suit comme:

@Test
public void test7() {
    List<Employee> employees = EmployeeData.getEmployees();
    //allMatch(predicate p)-检查是否匹配所有元素
    boolean allMatch = employees.stream().allMatch(e -> e.getAge() >18);
    //anyMatch(Predicate P)-检查是否至少匹配一个元素。
    boolean anyMatch = employees.stream().anyMatch(e ->e.getSalary() > 10000);
    //noneMatch(Predicate p)一 检查是否没有匹配的元素。
    boolean noneMatch = employees.stream().noneMatch(e -> e.getName().tartsWith("周"));
    ///findFirst- 返回第一 个元囊
    Optional<Employee> employee = employees.stream().findFirst();
    //findAny- -返回当前流中的任意元素
    optiona1<Employee> employee1 = employees.paralle1Stream().findAny();
    // count- 返回流 中元素的总个数
    long count = employees. stream().filter(e -> e.getSalary() > 5000).count();
    //max(Comparator c)一返回流中最大值
    Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
    Optional<Double> maxsalary = salaryStream.max(Double :: compare);
    //min(Comparator c)-返回流 中最小值
    Optional<Employee> minsalary = employees.stream().min((e1,e2) -> Double.compare(e1.getSalary(), e2.getsalary()));
    //forEach(Consumer c)一内部迭代
    employees.stream().forEach(System.out :: print1n);
}

②, la réduction

de code est le suivant:

@Test
public void test7() {
    //reduce(T identity, BinaryOperator)- 可以将流中元素反复结合起来，得到一个值。返回T
    //计算1-10的自然数的和
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list. stream().reduce( 0, Integer :: sum);//sun-->55
    //reduce(BinaryOperator)一可以将流中元素反复结合起来，得到一个值。返回optional<T>
    //计算公司所有员工工资的总和
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<Double> salaryStream = emp1oyees.stream().map(Emp1oyee :: getSalary);
    Optional <Double> sumMoney = salaryStream. reduce(Double::sum);
}

③, collection

code suit comme:

@Test
public void test7() {
    List<Employee> employees = Emp1oyeeData.getEmployees();
    List<Employee> employeelist = employees.stream().filter(e -> e.getSalary() > 8000).collect(Collectors.toList());
}

classe en option

1, classe introduction facultative

      classe optionnelle (java.util.Optional) est une classe de conteneur, il peut maintenir la valeur de type T, la valeur représentative est présent. Ou tout simplement ECONOMISEZ null, il indique que la valeur n'existe pas. A l'origine représenté par une valeur nulle n'existe pas, maintenant en option peut mieux exprimer ce concept. Et éviter une exception de pointeur NULL.

2, la méthode de l'objet de classe en option

• Optional.of (T t): Création d'une instance en option, t doit être vide;
• Optional.empty (): créer une instance vide en option
• Optional.ofNullable (T t): t peut être nul

3, détermine si l'objet contenu dans le récipient facultatif:

• boolean IsPresent (): déterminer si un objet comprenant
• vide IfPresent (consommation <super T? consommateur>): S'il y a une valeur, exécute la consommation
  code qui implémente l'interface, et cette valeur est passée à elle comme argument.
• Obtenez objet conteneur en option:
• T get (): Si vous appelez l'objet contient la valeur, de retour cette valeur, sinon Lancers
• T OrElse (T autre): Si la valeur sera retournée, sinon tout autre objet spécifié.
• T orElseGet (autre fournisseur <T étend?>) :: En cas de valeur sera retourné, sinon la

4, l'objet d'interface de fournisseur fournit

• T orElseThrow (Fournisseur exceptionSupplier <étend X ?>) :: S'il y a une valeur alors il est de retour à
  dos, ou jeté par l'interface fournisseur fournit.

5, Utilisation facultative de classe

@Test
public void test7() {
    Girl girl = new Gir1();
    girl = nu11;
    //of(T t):保证t是非空的
    optional<Girl> optiona1Girl = Optional.of(gir1);
    //ofNullable(T t): t可以为null
    optional<Girl> optiona1Girl1 = Optional.ofNullable(gir1);
}

@Test
public void test2() {
    Boy b = new Boy("张三");
    Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
    // 如果有女朋友就返回他的女朋友，否则只能欣赏“嫦娥”了
    Girl girl = opt.orElse(new Girl("嫦娥"));
    System.out.println("他的女朋友是：" + girl.getName());