[JAVA] Jeu d'Ogawa

~~ Cela ressemble à un mot secret ~~

Jouons

stream.java

package stream;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 *Jouons avec stream
 * 
 * @auteur Ogawa
 *
 */
public class Stream {

	/**Liste des chaînes de caractères pouvant être converties en nombres*/
	private static final List<String> STRING_LIST = Arrays.asList("0", "2", "2", null, "4", null, "1");

	/**Liste des numéros*/
	private static final List<Integer> NUMBER_LIST = Arrays.asList(1, -1, null, 2, null, 2, -4);

	/**
	 * main
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(convertToStr(NUMBER_LIST));
		System.out.println(convertToInt(STRING_LIST));
		System.out.println(sum(NUMBER_LIST));
		System.out.println(findPuls(NUMBER_LIST));
		System.out.println(findMinus(NUMBER_LIST));
		System.out.println(findEven(NUMBER_LIST));
		System.out.println(findOdd(NUMBER_LIST));
	}

	/**
	 * List{@code <Integer>}liste{@code <String>}Conversion en
	 * 
	 * @param numList Valeur d'entrée
	 * @retourner le résultat de la conversion
	 */
	private static List<String> convertToStr(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).map(v -> String.valueOf(v))
				.collect(Collectors.toList());
	}

	/**
	 * List{@code <String>}liste{@code <Integer>}Conversion en
	 * 
	 * @param strList Valeur d'entrée
	 * @retourner le résultat de la conversion
	 * @throws NumberFormatException Lorsque l'argument contient un élément qui ne peut pas être converti en valeur numérique.
	 */
	private static List<Integer> convertToInt(List<String> strList) throws NumberFormatException {
		return strList.stream().filter(Objects::nonNull).map(v -> Integer.parseInt(v))
				.collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Ajouter des numéros internes
	 * 
	 * @param numList Valeur d'entrée
	 * @return Résultat d'agrégation
	 */
	private static int sum(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).mapToInt(v -> v).sum();
	}

	/**
	 * List{@code <Integer>}Pour réduire aux entiers positifs uniquement
	 * 
	 * @param numList Valeur d'entrée
	 * @retour du résultat du traitement
	 */
	private static List<Integer> findPuls(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v >= 0).collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Pour réduire uniquement aux entiers négatifs
	 * 
	 * @param numList Valeur d'entrée
	 * @retour du résultat du traitement
	 */
	private static List<Integer> findMinus(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v <= 0).collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Serrez pour égaliser
	 * 
	 * @param numList Valeur d'entrée
	 * @retour du résultat du traitement
	 */
	private static List<Integer> findEven(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v % 2 == 0).collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Aux seuls nombres impairs
	 * 
	 * @param numList Valeur d'entrée
	 * @retour du résultat du traitement
	 */
	private static List<Integer> findOdd(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v % 2 != 0).collect(Collectors.toList());
	}
}

Regardons chacun d'eux

Convertissez les éléments de List <Integer> en List <String> tout en éliminant les valeurs nulles

convertToStr.java

	private static List<String> convertToStr(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).map(v -> String.valueOf(v))
				.collect(Collectors.toList());
	}

Convertir les éléments de List <String> en List <Integer> tout en éliminant les valeurs nulles

convertToInt.java

	private static List<Integer> convertToInt(List<String> strList) throws NumberFormatException {
		return strList.stream().filter(Objects::nonNull).map(v -> Integer.parseInt(v))
				.collect(Collectors.toList());
	}

List <Integer> Agrège les nombres internes tout en éliminant les valeurs nulles

sum.java

	private static int sum(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).mapToInt(v -> v).sum();
	}

Réduisez List <Integer> aux entiers positifs

findPuls.java

	private static List<Integer> findPuls(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v >= 0).collect(Collectors.toList());
	}

Limiter List <Integer> aux seuls entiers négatifs

findMinus.java

	private static List<Integer> findMinus(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v <= 0).collect(Collectors.toList());
	}

Réduisez List <Integer> à seulement

findEven.java

	private static List<Integer> findEven(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v % 2 == 0).collect(Collectors.toList());
	}

Réduisez List <Integer> aux seuls nombres impairs

findOdd.java

	private static List<Integer> findOdd(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v % 2 != 0).collect(Collectors.toList());
	}

Je veux créer ListUtils

Tu ne veux pas y arriver?

Eh bien, il semble peu probable qu'il soit utilisé s'il ne s'agit que d'une simple opération ...?

Est-ce juste un modèle original en premier lieu?

Je veux préparer l'opération de base à l'avance comme ceci

~~ Je veux que vous prépariez cela du côté java ...? ~~