So verwenden Sie das neue Feature Stream in Java8

Das Konzept von Stream Flow

Warum sollten wir Stream Flow verwenden?

Die Idee von Stream Flow ähnelt dem Fließband einer Produktionswerkstatt. Wenn wir mehrere Elemente (insbesondere mehrstufige Vorgänge) bedienen müssen, sollten wir unter Berücksichtigung von Leistung und Komfort zunächst einen schrittweisen „Modell“-Plan erstellen und ihn dann gemäß dem Plan ausführen.

Stream ist eine Warteschlange von Elementen aus einer Datenquelle

Elemente sind Objekte eines bestimmten Typs, die eine Warteschlange bilden. Strom in Lava speichert keine Elemente, sondern berechnet sie bei Bedarf.

DataSource Die Quelle des Streams. Kann eine Sammlung, ein Array usw. sein.

Die beiden Grundfunktionen von Stream:

·Pipelining: Zwischenoperationen führen zum Reflow des Objekts selbst. Auf diese Weise können mehrere Vorgänge wie im fließenden Stil zu einer Pipeline verbunden werden. Dadurch können Vorgänge wie Faulheit und Kurzschlüsse optimiert werden.

Interne Iteration: In der Vergangenheit wurde die Sammlungsdurchquerung explizit außerhalb der Sammlung durch einen Iterator oder erweitert für iteriert. Dies wird als externe Iteration bezeichnet. Stream stellt eine interne Iterationsmethode bereit, und der Stream kann die Traversal-Methode direkt aufrufen.

Die Verwendung eines Streams umfasst normalerweise drei grundlegende Schritte: Beziehen einer Datenquelle (Quelle) → Datenkonvertierung: Führen Sie eine Operation aus, um das gewünschte Ergebnis zu erhalten. Das ursprüngliche Stream-Objekt wird jedoch nicht konvertiert Ändern und ein neues wird zurückgegeben Stream-Objekte (können mehrere Transformationen haben), wodurch Operationen an ihnen wie eine Kette angeordnet und zu einer Pipeline werden können.

Erfassung des Stream-Streams

Es gibt zwei gängige Möglichkeiten, den Stream zu erhalten:

1. Über Sammlung abrufen

2. Die statische Methode der Stream-Schnittstelle erhält

Über Sammlung erhalten

Alle Sammlungen können Erhalten Sie den Stream über die Stream-Standardmethode

//把集合转换为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();

Nach dem Login kopieren

2. Die statische Methode der Stream-Schnittstelle kann den Stream erhalten, der dem Array entspricht. Die statische Methode der Stream-Schnittstelle kann den Stream erhalten, der dem Array entspricht.

Der Parameter ist ein variabler Parameter, dann können wir ein Array übergeben Methoden vom Typ der Schnittstelle, die daher verkettete Aufrufe unterstützen. (Mit Ausnahme der finalen Methode sind alle anderen Methoden verzögerte Methoden.)

Terminator-Methode:

Der Rückgabewerttyp ist keine Methode mehr vom eigenen Typ der Stream-Schnittstelle, daher werden Kettenaufrufe wie StringBuilder nicht mehr unterstützt.

Die oben genannten sind einige gängige Streaming-Methoden. Lassen Sie uns der Reihe nach lernen, wie diese Methoden verwendet werden.

forEach-Traversal-Methode

Diese Methode akzeptiert eine Consumer-Schnittstellenfunktion und übergibt jedes Stream-Element zur Verarbeitung an die Funktion. Die Consumer-Schnittstelle ist eine Consumer-Funktionsschnittstelle, die Lambda-Ausdrücke übergeben und Daten konsumieren kann. foeeach-Methode wird zum Durchlaufen der Daten im Stream verwendet. Es handelt sich um eine Abschlussmethode. Nach dem Durchlaufen können keine anderen Methoden im Stream verwendet werden.

Verwenden Sie grundsätzlich die Filtermethode

//把数组转换成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);

, um die Zahlen im Stream zu filtern. Der Parameter Predicate der Filtermethode ist eine funktionale Schnittstelle, sodass Lambda-Ausdrücke zum Filtern der Daten übergeben werden können. Sie können die Filtermethode verwenden, um eine Transformation in den nächsten Stream zu filtern, wie unten gezeigt:

Das obige Bild filtert mithilfe der Filtermethode einige verschiedene Elemente und wird dann zu einem neuen Stream.

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));

}

}

Nach dem Login kopieren

map-Mapping-Methode (Konvertierung) verwenden.

Wenn Sie Elemente in einem Stream in einen anderen Stream konvertieren müssen, können Sie die Map-Methode verwenden. Diese Schnittstelle erfordert einen Funktionsschnittstellenparameter „Function“, der den T-Typ-Datentyp im aktuellen Stream in einen anderen R-Typ-Datenstream konvertieren kann, wie unten gezeigt:

Die obige Abbildung konvertiert die Daten verschiedener Elemente in A-Typ-Daten Element.

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));

}

}

Nach dem Login kopieren

count-Zählelementmethode

, um die Anzahl der Elemente im Stream-Stream zu zählen. Die Zählmethode ist eine Terminalmethode und der Rückgabewert ist eine Ganzzahl vom Typ Long. Sie können also keine anderen Methoden mehr im Stream aufrufen

Grundlegende Verwendung

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

}

}

Nach dem Login kopieren

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));

}

}

Nach dem Login kopieren

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));

}

}

Nach dem Login kopieren

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));

}

}

Nach dem Login kopieren

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));

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das neue Feature Stream in Java8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!