Java8 nouvelles fonctionnalités lambda, interface fonctionnelle, StreamingAPI

Expression Lambda

1 Il s'agit d'une simplification du format des objets de classe interne anonymes

2 Une nouvelle est introduite dans Java8. L'opérateur "->" est appelé l'opérateur flèche, ou l'opérateur lambda

3. Sa fonction est de diviser les parties avant et arrière en deux parties

4. l'expression Lambda. Liste des paramètres (paramètres de la méthode abstraite définis dans l'interface)

5. Le côté droit : représente le corps de la méthode, corps Lambda

écrit au format syntaxe

1 .Il n'y a aucun paramètre ni aucune valeur de retour

Le support gauche ne peut pas être omis, et le support droit peut être omis ou non.

2 .Il y a un paramètre et aucune valeur de retour

Il y a plusieurs paramètres et aucune valeur de retour

Le crochet gauche peut ou non être omis, et l'accolade droite peut ou non être omis

3 De nombreux contenus de méthodes doivent être réécrits dans l'interface. Vous devez ajouter des accolades pour plusieurs phrases

<.>

Remarque : s'il n'y a qu'une seule instruction dans le corps Lambda, alors les accolades peuvent être omises ; s'il n'y a qu'une seule instruction dans l'accolade et qu'il s'agit d'une instruction return, alors ; le mot-clé return peut être omis

Interface fonctionnelle

Le principe de l'utilisation de l'expression Lambda est que l'interface doit être une interface fonctionnelle s'il n'y a qu'une seule méthode abstraite dans. l'interface, alors l'interface est une interface fonctionnelle. Une annotation courante est Pour vérifier si l'interface actuelle est une interface fonctionnelle @FunctionalInterface Si ce n'est pas une interface fonctionnelle, une erreur de compilation sera signalée

Fonction :

Ce que vous voulez exprimer est le contenu d'une méthode, puisque la méthode n'est dans aucune classe, tout s'appelle une fonction. Ce que l'interface veut réellement exprimer, c'est la déclaration de. une fonction. Ensuite, utilisez l'objet de classe d'implémentation de cette interface pour exprimer l'incarnation d'une fonction

Interface de consommation :

Méthode abstraite : void accept(T t)

Lorsqu'une fonction peut accepter et traiter les données, une fois le traitement terminé, il n'est pas nécessaire de renvoyer des données, cette fonction doit être transmise en tant que données, utilisez donc l'interface consommateur

package cn.ujiuye.function;
import java.util.function.Consumer;
import cn.ujiuye.domin.Mobile;
/**
 * @author liugang
 * 消费型接口方式
 */
public class CustmoerTest {
     public static void main(String[] args) {
	    Mobile m = new Mobile("华为",3000);
	     //lambad表达式实现赋值  内部显然是对消费者接口的使用，故是对函数式接口编程的新东西
	     updateMobile(m, x -> x.setPrice(x.getPrice() + 1000 ));
	     System.out.println(m);
	 }
    //调用其使用的方法
	private static void updateMobile(Mobile m, Consumer<Mobile> con) {
	     for (int i = 0; i < 3; i++) {
		     con.accept(m);	
		 }
	}
}

référence de la méthode

1. Lors de l'écriture d'une interface fonctionnelle, la méthode L'implémentation a été implémentée par un autre objet, il n'est donc pas nécessaire d'appeler à nouveau l'implémentation, mais la méthode directement définie peut être utilisée

2. Format

Fonction Interface fonctionnelle : Nom = Nom de l'objet :: Nom de la méthode

Interface fonctionnelle : Nom = Nom de la classe :: Statique nom de la méthode

3. Fonction

Traiter ce qui a été implémenté comme Une donnée, en guise de référence, est affectée à une référence à une interface fonctionnelle. Cette référence peut être utilisée comme retour. valeur d'une méthode, ou en tant qu'objet de classe d'implémentation

StreamingAPI

Dans jdk1.8, un type de flux est fourni, qui peut facilement exploiter les données dans le conteneur. Le filtrage des données, la sortie et d'autres opérations peuvent être effectués sans définir manuellement une boucle

Acquisition du type Stream et méthodes courantes

Acquisition de la collection :

Appelez le stream() et rappelez l'objet Stream

Méthode de terminaison : foreach count

Méthode Delay : saut de limite de filtre, etc.

package cn.ujiuye.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
/**
 * @author liugang
 *
 */
public class StreamApiDemo03Demo03 {
    public static void main(String[] args) {
    	//定义一个集合,并获取stream类型的数据
		List<Integer> list = new ArrayList<Integer>();
		Collections.addAll(list, 12,32,-13,50,100);
		Stream<Integer> stream = list.stream();
		stream.forEach(x ->System.out.println(x - 100));
		System.out.println(list.stream().count());
    }
}

package cn.ujiuye.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
/**
 * @author liugang
 * Stream中一些方法的使用
 */
public class StreamApiDemo04 {
   public static void main(String[] args) {
	   ArrayList<Integer> list = new ArrayList<>();
	   Collections.addAll(list, -4,-12,-199,0,15,25,36,100);
	   Stream<Integer> stream = list.stream();
	   stream.filter(x -> x > 0)    //过滤
	         .skip(1)               //跳过
	         .limit(2)              //限制
	         .sorted((x,y) -> -1)   //排序
	         .forEach(System.out::println);
   }
}

Exercice

Il existe deux collections Arraylist qui stockent les noms de plusieurs membres de l'équipe. Utilisez la méthode Stream pour effectuer les étapes suivantes

1 La première équipe n'a besoin que de membres dont les noms comportent 3 caractères

. 2. La première équipe n'a besoin que des trois premières personnes après la sélection

3. Les deuxièmes équipes n'ont besoin que de personnes portant le nom de famille Zhang

4. Une fois la deuxième équipe sélectionnée, les deux premières personnes. ne sont pas obligatoires

5. Fusionner les deux équipes en une seule équipe

6. Après la fusion, les objets Person (type personnalisé) de tous les membres de l'équipe sont stockés dans une collection ArrayList

Équipe 1 : Miyamoto Musashi, Song Gongming, Su Youpeng, Stone Man, Shi Chuanxiang, Li Er, Zhuang Zi, Hong Qigong

Équipe 2 : Pavarotti, Zhang Sanfeng, Zhao Weiwei, Zhang Zizhong, Borzhijin Temujin , Zhang Tianai, Zhang Cuihua

public class StreamApiTest {
    @SuppressWarnings("unused")
	public static void main(String[] args) {
	    //创建集合
    	List<String> list1 = new ArrayList<String>();
	    List<String> list2 = new ArrayList<String>();
	    //把元素添加到集合中
	    Collections.addAll(list1, "宫本武藏","宋公明","苏有朋","石头人","时传祥","李耳","庄子","洪七公");
	    Collections.addAll(list2, "帕瓦罗蒂","张三疯","赵薇薇","张自忠","孛儿只斤铁木真","张天爱","张翠花");
	    //创建Stream对象
	    Stream<String> stream1 = list1.stream();
	    Stream<String> stream2 = list2.stream();
	    //创建筛选后的元素
	    Stream<String> limit1 = stream1.filter(x -> x.length() == 3).limit(3);
	    Stream<String> limit2 = stream2.filter(x -> x.startsWith("张")).skip(2);
	    //将两对的人合到同一个对里
	    Stream<String> concat = Stream.concat(limit1, limit2);
	    //定义一个集合用来存对象
	    List<Person> list = new ArrayList<Person>();
	    //想要的是一个Person对象的流
	    //Stream<Person> map = concat.map(x -> new Person(x);
	    Stream<Person> map = concat.map(Person::new);
	    //将流对象添加到集合中
	    map.forEach(list::add);
	    System.out.println(list);
	}
}

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!