Comment utiliser la nouvelle fonctionnalité Stream en Java8

Le concept de Stream flow

Pourquoi utiliser Stream flow ?

L'idée du flux Stream s'apparente à la chaîne de montage d'un atelier de production. Lorsque nous devons faire fonctionner plusieurs éléments (en particulier des opérations à plusieurs étapes), en tenant compte des performances et de la commodité, nous devons d'abord élaborer un plan par étapes « modèle », puis l'exécuter conformément au plan.

Stream(Stream) est une file d'attente d'éléments de la source de données

# 🎜 🎜#

les éléments sont des objets d'un type spécifique, formant une file d'attente. Stream in Lava ne stocke pas les éléments, mais les calcule à la demande.

Source des données La source du flux. Peut être une collection, un tableau, etc.

Deux caractéristiques fondamentales de Stream :

·Pipelining : Les opérations intermédiaires ne redistribueront pas l'objet lui-même. De cette façon, plusieurs opérations peuvent être connectées dans un pipeline, tout comme le style fluide. Cela peut optimiser des opérations telles que la paresse et les courts-circuits.

Itération interne : Dans le passé, le parcours de collection était explicitement itéré en dehors de la collection via un itérateur ou amélioré pour. Stream fournit une méthode d'itération interne et le flux peut appeler directement la méthode de traversée.

Lors de l'utilisation d'un flux, celui-ci comprend généralement trois étapes de base : Obtenir une source de données (source)→Conversion de données : Effectuer une opération pour obtenir le résultat souhaité, et à chaque fois les données d'origine est converti L'objet Stream ne change pas et un nouvel objet Stream est renvoyé (avec plusieurs conversions possibles), ce qui permet aux opérations sur celui-ci d'être organisées comme une chaîne et de devenir un pipeline.

Obtenir le flux Stream

Il existe 2 façons courantes d'obtenir le flux :

1. #🎜🎜 #

2. La méthode statique de l'interface Stream est obtenue

Acquis via la collection Collection

All Collection Les collections peuvent être obtenues via le flux La méthode par défaut consiste à obtenir le flux

//把集合转换为stream流

//list集合

List<String>list=new ArrayList<>();

Stream<String>stream=list.stream();

//set集合

Set<String>set=new HashSet<>();

Stream<String>stream2=set.stream();

//map集合（map集合需要间接的转换）

Map<String, String>map=new HashMap<>();

//方法一：获取键，存储到一个set集合中

Set<String>keySet=map.keySet();

Stream<String>stream3=keySet.stream();

//方法二：获取值，存储到一个collection集合中

Collection<String>values=map.values();

Stream<String>stream4=values.stream();

//方法三：获取键值对，，键与值的映射关系，entrySet()

Set<Map.Entry<String, String>>entries=map.entrySet();

Stream<Map.Entry<String, String>>stream5=entries.stream();

2 La méthode statique de l'interface Stream consiste à obtenir le flux correspondant au tableau.

Le paramètre est un paramètre variable, nous pouvons alors passer un tableau

//把数组转换成Stream流

Stream<Integer>stream6=Stream.of(1,2,3,4,5);

//可变参数可以传递数组

Integer[]arr={1,2,3,4,5};

Stream<Integer>stream7=Stream.of(arr);

String[]arr2={"a","bb","ccc"};

Stream<String>stream8=Stream.of(arr2);

Méthodes courantes de flux de flux

stream's Couramment utilisé les méthodes sont divisées en deux catégories :

Méthode retardée :

Le type de valeur de retour est toujours une méthode du type propre à l'interface Stream, les appels en chaîne sont donc pris en charge . (À l'exception de la méthode finale, toutes les autres méthodes sont des méthodes retardées.)

Méthode Terminator : Le type de valeur de retour n'est plus une méthode du type propre à l'interface Stream, il n'est donc plus pris en charge. Appels chaînés similaires à StringBuilder.

Voyons ci-dessus quelques méthodes courantes de flux de flux. Apprenons à utiliser ces méthodes tour à tour.

forEach méthode de traversée

Cette méthode accepte une fonction d'interface consommateur et remettra chaque élément de flux à la fonction pour traitement. L'interface Consumer est une interface fonctionnelle consommateur qui peut transmettre des expressions lambda et consommer des données. La méthode

foeeach est utilisée pour parcourir les données dans le flux. Il s'agit d'une méthode de terminaison après le parcours, les autres méthodes du flux ne peuvent pas être utilisées.

Utilisation de base

public class Demo03Stream_forEach {

public static void main(String[] args) {

Stream<String>stream=Stream.of("张三","李四","王五","赵六","小明","小胖");

/*stream.forEach((String name)->{

System.out.println(name);

});*/

stream.forEach(name->System.out.println(name));

}

}

filter filter method

est utilisé pour Stream Filtrez les numéros dans le flux. Le paramètre Predicate de la méthode de filtrage est une interface fonctionnelle, donc des expressions lambda peuvent être transmises pour filtrer les données. Vous pouvez filtrer une conversion vers le flux suivant via la méthode de filtrage, comme indiqué ci-dessous :

L'image ci-dessus utilise la méthode de filtrage pour filtrer certains éléments différents. Filtrez puis devenez un nouveau flux.

Utilisation de base

public class Demo04Stream_filter {

public static void main(String[] args) {

//创建一个Stream流

Stream<String>stream=Stream .of("张三丰","赵敏","张无忌","周芷若","张三","狮王","张大牛");

//对Stream流中的元素进行过滤。只要张的人

Stream<String>stream2=stream.filter((String name)->{return name.startsWith("张");});

//遍历Stream流

stream2.forEach(name->System.out.println(name));

}

}

méthode de cartographie cartographique (conversion)# 🎜🎜#Si vous devez convertir des éléments d'un flux vers un autre flux, vous pouvez utiliser la méthode map. Cette interface nécessite un paramètre d'interface fonctionnelle Function, qui peut convertir le type de données de type T dans le flux actuel en un autre flux de données de type R, comme indiqué ci-dessous :

#🎜 🎜#Le diagramme ci-dessus convertit les données de différents éléments en éléments d'un même type.

Utilisation de base

public class Demo05Stream_map {

public static void main(String[] args) {

//获取一个String类型的Stream流

Stream<String>stream=Stream.of("1","2","3","4","5");

//使用map方法，把字符串类型的整数，转换（映射）为integer类型的整数

Stream<Integer>stream2=stream.map((String s)->{

return Integer.parseInt(s);

});

//遍历Stream流

stream2.forEach(i->System.out.println(i));

}

}

count méthode pour compter le nombre de elements# 🎜🎜#

est utilisé pour compter le nombre d'éléments dans le Stream. La méthode count est une méthode terminale et la valeur de retour est un entier de type Long. Vous ne pouvez donc plus appeler d'autres méthodes dans le Stream

Utilisation de base

.

public class Demo06Stream_count {

public static void main(String[] args) {

//获取一个Stream流

ArrayList<Integer>list=new ArrayList<Integer>();

//添加元素

list.add(1);

list.add(2);

list.add(3);

list.add(4);

list.add(5);

list.add(6);

list.add(7);

Stream<Integer>stream=list.stream();

//统计stream流中的元素个数

long count=stream.count();

//打印输出

System.out.println(count);//7

}

}

limit截取流元素方法

Limit方法可以对流进行截取，只取用前n个。参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作。limit方法是一个延迟方法，只是对流中的元素进行截取，返回一个新的流，使用可以继续调用stream流中的其他方法。

基本使用

public class Demo07Stream_limit {

public static void main(String[] args) {

show02();

}

private static void show02() {

//创建一个String类型的数组

String[]arr={"喜羊羊","美羊羊","沸羊羊","懒羊羊","灰太狼","红太狼"};

//集合获取一个Stream流

Stream<String>stream=Stream.of(arr);

//用limit方法截取前6个元素

Stream<String>stream2=stream.limit(3);

//遍历Stream2流

stream2.forEach(i->System.out.println(i));

}

}

skip跳过元素方法

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流，如果流的当前长度大于n,则跳过前n个；否则将会得到一个长度为0的流。

基本使用

public class Demo08Stream_skip {

public static void main(String[] args) {

//创建一个String类型的数组

String[]arr={"喜羊羊","美羊羊","懒羊羊","慢羊羊","红太狼","灰太狼","小灰灰","沸羊羊","软绵绵","武大狼"};

//获取Stream流

Stream<String>stream=Stream.of(arr);

//使用skip方法截取后面的元素

Stream<String>stream2=stream.skip(5);

//遍历stream2流

stream2.forEach(i->System.out.println(i));

}

}

concat:合并方法

用于把流组合到一块。如果有两个流，希望合并成为一个流，就可以使用concat方法

基本使用

public class Demo09Stream_concat {

public static void main(String[] args) {

//创建一个Stream流

Stream<String>stream=Stream.of("张三丰","张翠山","赵敏","周芷若","张无忌");

//创建一个String类型的数组

String[]arr={"喜羊羊","美羊羊","懒羊羊","慢羊羊","红太狼","灰太狼","小灰灰","沸羊羊","软绵绵","武大狼"};

//获取Stream流

Stream<String>stream2=Stream.of(arr);

//使用常用方法concat方法合并流

Stream<String>stream3=Stream.concat(stream, stream2);

//遍历Stream3流

stream3.forEach(i->System.out.println(i));

}

}

Stream流的练习

最后，我们通过下面的练习来巩固一下上面所学的内容。

现在有两个ArrayList集合存储队伍当中的多个成员姓名，

要求使用传统的for循环(或增强for循环)依次进行以下若干操作步骤:

1.第一个队伍只要名字为3个字的成员姓名:存储到一个新集合中。

2.第一个队伍筛选之后只要前3个人;存储到一个新集合中。

3.第二个队伍只要姓张的成员姓名;存储到一个新集合中。

4.第二个队伍筛选之后不要前2个人;存储到一个新集合中。

5.将两个队伍合并为一个队伍;存储到一个新集台中。

6.根据姓名创建Person对象:存储到一个新集合中，

7.打印整个队伍的Person对象信息。

示例：

第一支队伍：迪丽热巴、宋远桥、苏星河、石破天、石中玉、老子、庄子、洪七公

第二支队伍：古娜力扎、张无忌、赵丽颖、张三丰、尼古拉斯赵四、张天爱、张二狗

首先创建Person对象类

public class Person {

private String name;

public Person() {

super();

}

public Person(String name) {

super();

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "Person [name=" + name + "]";

}

}

然后再根据习题要求用Stream流进行过滤

1.第一个队伍只要名字为3个字的成员姓名:存储到一个新集合中。

2.第一个队伍筛选之后只要前3个人;存储到一个新集合中。

// 第一支队伍

// 创建集合

ArrayList<String> one = new ArrayList<>();

// 添加元素

one.add("迪丽热巴");

one.add("宋远桥");

one.add("苏星河");

one.add("石破天");

one.add("石中玉");

one.add("老子");

one.add("庄子");

one.add("洪七公");

//1.第一个队伍只要名字为3个字的成员姓名:存储到一个新集合中。

//2.第一个队伍筛选之后只要前3个人;存储到一个新集合中。

Stream<String>oneStream=one.stream().filter(name->name.length()==3).limit(3);

3.第二个队伍只要姓张的成员姓名;存储到一个新集合中。

4.第二个队伍筛选之后不要前2个人;存储到一个新集合中。

// 第二支队伍

// 创建集合

ArrayList<String> tow = new ArrayList<>();

// 添加元素

tow.add("古娜力扎");

tow.add("张无忌");

tow.add("赵丽颖");

tow.add("张三丰");

tow.add("尼古拉斯赵四");

tow.add("张天爱");

tow.add("张二狗");

//3.第二个队伍只要姓张的成员姓名;存储到一个新集合中。

//4.第二个队伍筛选之后不要前2个人;存储到一个新集合中。

Stream<String>towStream=tow.stream().filter(name->name.startsWith("张")).skip(2);

5.将两个队伍合并为一个队伍;存储到一个新集台中。

6.根据姓名创建Person对象:存储到一个新集合中，

7.打印整个队伍的Person对象信息。

//5.将两个队伍合并为一个队伍;存储到一个新集台中。

//6.根据姓名创建Person对象:存储到一个新集合中，

//7.打印整个队伍的Person对象信息。

Stream.concat(oneStream,towStream).map(name->new Person(name)).forEach(p->System.out.println(p));

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!