JDK8 (三) API Java flux

Others 2020-04-03 11:45:41 views: null

article Annuaire

Tout d'abord, quelle est l'API Java Stream?

1.1 introduction

fonction Stream interfaces de programmation Java en Java. 8 est d' abord introduit et ensemble dans les caractéristiques historiques du développement Java et lambda, ce qui facilite grandement l'efficacité de la collecte des données de type ouvert de traitement art.
Java flux est un flux de données à travers le pipeline, et la manipulation des données dans le pipeline, un tuyau et passe ensuite dans l'autre.
pipeline de fonction comprenant: Filter (filtre), la carte (mapping), Sort (tri) ou analogue, puis à travers un ensemble de données de flux Java pipeline de traitement, ou converti en un autre sortie de données d'ensemble de groupe.
Insérer ici l'image Description

En second lieu, comment obtenir le flux Stream?

(Code complet ci-dessous, placé à l'intérieur d'une classe)

package com.zicheng.stream;

import java.util.*;
import java.util.stream.Stream;

/**
 * 子诚
 * Description：集合、map、数组 获取流
 * 时间：2020/4/1 16:44
 */
public class Demo_GetStream {
    public static void main(String[] args) {
        //list获取Stream流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        //set获取Stream流
        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //获取Map的Stream流
        Map<String, String> map = new HashMap<>();
        //获取map中 key 的Stream流
        Stream<String> keyStream = map.keySet().stream();
        //获取map中 value 的Stream流
        Stream<String> valueStream = map.values().stream();
        //获取 entry 的Stream流
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();

        //数组获取Stream流
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
    }
}

2.1, les flux de pipeline Collection est converti en

REMARQUE:
java.util.Collection ajouté à la méthode d'interface par défaut utilisée pour obtenir le flux d'écoulement, de sorte que toutes les classes peuvent être réalisées flux d'acquisition.

Code de la clé
list.stream (); set.stream ();

2.2, le débit de pipeline Carte est converti en

Remarque:
la sous-Interface Interface java.util.Map est pas, de la collection et est caractérisé en ce qu ' une structure unique de données ne sont pas conformes éléments de flux de KV, il est nécessaire d'obtenir un courant correspondant, respectivement, où les points qui nécessitent une clé, la valeur ou l' entrée.

Code de la clé
map.keySet () Stream () ;.
Map.values () Stream () ;.
EnumMap.entrySet () Stream () ;.

3,3, est converti en un réseau de tuyaux d'écoulement

REMARQUE:
Si vous n'êtes pas défini (Collection) ou d'une carte réseau (carte) mais, puisque l'objet de tableau ne peut pas ajouter la méthode par défaut, l'interface flux de méthodes statiques

Code de la clé
Stream.of (Array);

3.4, le fichier texte dans un flux de pipeline

méthode Files.lines en convertissant un fichier texte pour le flux de pipeline, la méthode figure Paths.get () est d'obtenir l'effet du fichier, l'API est un Java NIO!

Stream<String> lines = Files.lines(Paths.get("file.txt"));

En troisième lieu, la méthode commune

3.0, tout le code

package com.zicheng.stream;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

/**
 * 子诚
 * Description：Stream中的常用方法
 * 时间：2020/4/1 18:27
 */
public class StreamFunctionDemo {
    public static void main(String[] args) {
        StreamFunctionDemo demo = new StreamFunctionDemo();
        //方法1：逐一处理：forEach
        demo.test_forEach();

        //方法2：过滤：filter
        demo.test_filter();

        //方法3：映射：map
        demo.test_map();

        //方法4：排序：sorted
        demo.test_sorted();

        //方法6：统计个数test_count()
        demo.test_count();
        
        //方法7：测试截取：limit
        demo.test_limit();
        
        //方法8：跳过：skip
        demo.test_skip();
        
        //方法9：组合：concat
        demo.test_concat();
    }

    //方法1：逐一处理：forEach
    void test_forEach() {
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
        /**
         * parallel()函数表示对管道中的元素进行并行处理而不是串行处理。
         * 但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。
         * 数据量大的话，就能观察到数据顺序是无法保证的.
         * 不想用，不用
         */
        arrayStream.parallel().forEach(item -> System.out.println(item));

        arrayStream.forEach(item -> {
            //在这个地方可以对每个item进行操作
            System.out.println(item);
        });
    }

    //方法2：过滤：filter
    void test_filter() {
        // 获取以“河南”开头的数据项
        List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> list = nameStrs.stream()
                .filter(s -> s.startsWith("河南"))
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

    //方法3：映射：map；将集合中的每一个字符串全部大写
    void test_map() {
        // Arrays.asList(),将数组转换为字符串
        List<String> players = Arrays.asList("Kobe Bean Bryant", "James", "Harden", "Curry", "Durant");
        List<String> list = players.stream()
                //s-> s.toUpperCase(),可以替换为String::toUpperCase(方法引用)
                .map(String::toUpperCase)
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

    //方法4：排序：sorted
    void test_sorted() {
        List<Integer> nums = Arrays.asList(2, 6, 5, 4, 8, 7, 9);
        //sorted，默认是升序
        List<Integer> list = nums.stream().sorted().collect(toList());
        System.out.println(list);
        //如果想要降序的话
        Collections.reverse(list);
        System.out.println(list);
    }

    //方法5：转换：collect
    void test_collect() {
        //list，set可以互转。
        //list转成map的话，index当做key，元素就当做value
        //具体，有时间再写
    }

    //方法6：统计个数：count
    void test_count() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        long count = school.stream()
                .filter(s -> s.startsWith("河南"))
                .count();
        //打印个数
        System.out.println(count);
    }

    //方法7：截取：limit
    void test_limit() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> limit = school.stream()
                .limit(2)
                .collect(toList());
        //打印结果
        System.out.println(limit);
    }

    //方法8：跳过：skip
    void test_skip() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> skip = school.stream()
                //跳过前两个
                .skip(2)
                .collect(toList());
        //打印结果
        System.out.println(skip);
    }

    //方法9：组合：concat
    void test_concat() {
        List<String> country = Arrays.asList("地球", "中华人民共和国");
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        //将上面的两个集合拼接
        List<String> address = Stream.concat(country.stream(), school.stream())
                .collect(toList());
        //打印结果
        System.out.println(address);
    }
}

3.1, un par un processus: forEash

Note:
Bien que le nom et le fonctionnement, et pour tous les autres, mais le principe est pas la même chose.
Un tuyau d'écoulement est une traversée.

//方法1：逐一处理
 void test_forEach() {
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
        /**
         * parallel()函数表示对管道中的元素进行并行处理而不是串行处理。
         * 但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。
         * 数据量大的话，就能观察到数据顺序是无法保证的.
         * 不想用，不用
         */
        arrayStream.parallel().forEach(item -> System.out.println(item));

        arrayStream.forEach(item -> {
            //在这个地方可以对每个item进行操作
            System.out.println(item);
        });
    }

Insérer ici l'image Description

3.2 Filtre: filtre

Note:
par le procédé de filtration, un courant converti en un autre sous - ensemble de flux

//方法2：过滤
void testFilter() {
    List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
    List<String> list = nameStrs.stream()
            .filter(s -> s.startsWith("河南"))
            //转换成了List的数据结构，方便接受和打印
            .collect(toList());
    System.out.println(list);
}

Insérer ici l'image Description

3,3 cartographie: Carte

Remarque:
Si vous devez mapper l'élément d'écoulement à un autre flux, la méthode de carte peut être utilisée.

	//方法3：映射：map；将集合中的每一个字符串全部大写
    void test_map() {
        // Arrays.asList(),将数组转换为字符串
        List<String> players = Arrays.asList("Kobe Bean Bryant", "James", "Harden", "Curry", "Durant");
        List<String> list = players.stream()
                //s-> s.toUpperCase(),可以替换为String::toUpperCase(方法引用)
                .map(String::toUpperCase)
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

Insérer ici l'image Description

3.4, le tri: trier

	//方法4：排序：sorted
    void test_sorted() {
        List<Integer> nums = Arrays.asList(2, 6, 5, 4, 8, 7, 9);
        //sorted，默认是升序
        List<Integer> list = nums.stream().sorted().collect(toList());
        System.out.println(list);
        //如果想要降序的话
        Collections.reverse(list);
        System.out.println(list);
    }

Insérer ici l'image Description

3.5 Conversion: Collect

Généralement utilisé pour déjà mentionné ci-dessus.

	//方法5：转换：collect
    void test_collect() {
        //list，set可以互转。
        //list转成map的话，index当做key，元素就当做value
        //具体，有时间再写
    }

3.6, le nombre de statistiques: nombre

//方法6：统计个数：count
    void test_count() {
        List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
        long count = nameStrs.stream()
                .filter(s -> s.startsWith("河南"))
                .count();
        //打印个数
        System.out.println(count);
    }

Insérer ici l'image Description

3.7 interception: limite

	//方法7：测试截取：limit
    void test_limit(){
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> limit= school.stream()
        		// 截取前两个
                .limit(2)
                .collect(toList());
        //打印结果
        System.out.println(limit);
    }

Insérer ici l'image Description

3.8, sauter: sauter

	//方法8：跳过：skip
    void test_skip(){
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> skip = school.stream()
                //跳过前两个
                .skip(2)
                .collect(toList());
        //打印结果
        System.out.println(skip);
    }

Insérer ici l'image Description

3.9, une combinaison de couture: concat

	//方法9：组合：concat
    void test_concat() {
        List<String> country = Arrays.asList("地球", "中华人民共和国");
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        //将上面的两个集合拼接
        List<String> address = Stream.concat(country.stream(), school.stream())
        .collect(toList());
        //打印结果
        System.out.println(address);
    }

Insérer ici l'image Description

Quatrièmement, les liens recommandés

Suave Rego : https: //ke.qq.com/teacher/316518226 (classe Tencent, bien parler, a recommandé une vague)
coquet frère prolongé : https: //ke.qq.com/teacher/1579106394 ( classe de Tencent, drôle aromatisée, bien informé)

★ Cheng enfant
Publié 44 articles originaux · louange gagné 5 · Vues 886
lettre privée préoccupations

Je suppose que tu aimes

Origine blog.csdn.net/qq_40634246/article/details/105248150
conseillé
Classement
du quotidien
Plus
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)

Code World

© 2018 codetd.com