Cara menggunakan ciri baharu Stream dalam Java8

Konsep aliran Strim

Mengapa menggunakan aliran Strim?

Idea Aliran Strim adalah serupa dengan barisan pemasangan bengkel pengeluaran. Apabila kita perlu mengendalikan berbilang elemen (terutamanya operasi berbilang langkah), mengambil kira prestasi dan kemudahan, kita harus terlebih dahulu menyusun pelan dipacu langkah "model", dan kemudian melaksanakannya mengikut pelan.

Strim (strim) ialah baris gilir elemen daripada sumber data

Elemennya ialah Objek jenis tertentu, membentuk baris gilir. Aliran dalam lava tidak menyimpan unsur, tetapi mengiranya atas permintaan.

Sumber Data Sumber strim. Boleh menjadi koleksi, tatasusunan, dll.

Dua ciri asas Strim:

·Pelipisan paip: Operasi perantaraan akan mengalir semula objek itu sendiri. Dengan cara ini, berbilang operasi boleh disambungkan ke saluran paip, sama seperti gaya fasih. Melakukannya boleh mengoptimumkan operasi seperti kemalasan dan litar pintas.

Lelaran dalaman: Pada masa lalu, lintasan koleksi diulang secara eksplisit di luar koleksi melalui lelaran atau dipertingkatkan untuk Ini dipanggil lelaran luaran. Strim menyediakan kaedah lelaran dalaman, dan strim boleh terus memanggil kaedah traversal.

Apabila menggunakan strim, ia biasanya merangkumi tiga langkah asas: Dapatkan sumber data (sumber)→ Penukaran data: Lakukan operasi untuk mendapatkan hasil yang diingini Setiap kali objek Strim asal ditukar, the Change, mengembalikan objek Stream baharu (yang boleh mempunyai berbilang penukaran), yang membolehkan operasi padanya diatur seperti rantai dan menjadi saluran paip.

Perolehan strim Strim

Terdapat dua cara biasa untuk mendapatkan strim:

1 Dapatkan melalui Koleksi

2 Kaedah statik Get

Get through Collection

Semua koleksi Collection boleh mendapatkan strim melalui kaedah lalai strim

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

Salin selepas log masuk

2 The kaedah statik antara muka .Strim memperoleh

Kaedah statik antara muka Strim boleh mendapatkan strim yang sepadan dengan tatasusunan. Parameter

ialah parameter pembolehubah, maka kita boleh menghantar tatasusunan

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

Salin selepas log masuk

Kaedah aliran biasa

Kaedah aliran biasa dibahagikan kepada dua kategori:

Kaedah tertunda: Jenis nilai pulangan masih merupakan kaedah antara muka Strim itu sendiri, jadi panggilan berantai disokong. (Kecuali kaedah akhir, semua kaedah lain adalah kaedah tertunda.)

Kaedah Penamat: Jenis nilai pulangan bukan lagi kaedah jenis antara muka Strim sendiri, jadi ia tidak lagi menyokong kaedah seperti panggilan StringBuilder Chain.

Di atas ialah beberapa kaedah aliran aliran yang biasa. Mari kita pelajari cara menggunakan kaedah ini secara bergilir.

untukSetiap kaedah traversal

Kaedah ini menerima fungsi antara muka Pengguna dan akan menyerahkan setiap elemen strim kepada fungsi untuk diproses. Antara muka Pengguna ialah antara muka berfungsi pengguna yang boleh menghantar ungkapan lambda dan menggunakan data.

Kaedah foeeach digunakan untuk melintasi data dalam strim Ia adalah kaedah penamatan Selepas melintasi, kaedah lain dalam strim tidak boleh digunakan.

Penggunaan asas

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

}

}

Salin selepas log masuk

kaedah penapisan penapis

digunakan untuk menapis nombor dalam Strim. Parameter Predikat kaedah penapis ialah antara muka berfungsi, jadi ungkapan lambda boleh dihantar untuk menapis data. Anda boleh menapis penukaran ke strim seterusnya melalui kaedah penapis, seperti yang ditunjukkan di bawah:

Gambar di atas menapis beberapa elemen berbeza menggunakan kaedah penapis, dan kemudian menjadi Strim Baharu .

Penggunaan asas

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

}

}

Salin selepas log masuk

kaedah pemetaan peta (penukaran)

jika diperlukan Untuk menukar elemen dalam aliran kepada aliran lain, anda boleh menggunakan kaedah peta. Antara muka ini memerlukan parameter antara muka fungsi Fungsi, yang boleh menukar jenis data jenis T dalam aliran semasa kepada aliran data jenis R yang lain, seperti ditunjukkan di bawah:

di atas graf A menukar data daripada elemen yang berbeza kepada elemen satu jenis.

Penggunaan asas

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

}

}

Salin selepas log masuk

kaedah unsur statistik kira

digunakan Kira bilangan elemen dalam Strim Kaedah kiraan ialah kaedah terakhir, dan nilai pulangan ialah integer jenis Panjang. Jadi anda tidak lagi boleh memanggil kaedah lain dalam Strim

Penggunaan asas

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

}

}

Salin selepas log masuk

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

}

}

Salin selepas log masuk

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

}

}

Salin selepas log masuk

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

}

}

Salin selepas log masuk

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

Atas ialah kandungan terperinci Cara menggunakan ciri baharu Stream dalam Java8. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!