[JAVA] Ogawa spielen

~~ Es sieht aus wie ein geheimes Wort ~~

Lass uns spielen

stream.java

package stream;

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

/**
 *Lass uns mit Stream spielen
 * 
 * @Autor Ogawa
 *
 */
public class Stream {

	/**Liste der Zeichenketten, die in Zahlen umgewandelt werden können*/
	private static final List<String> STRING_LIST = Arrays.asList("0", "2", "2", null, "4", null, "1");

	/**Liste der Nummern*/
	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>}Aufführen{@code <String>}Umstellung auf
	 * 
	 * @param numList Eingabewert
	 * @Konvertierungsergebnis zurückgeben
	 */
	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>}Aufführen{@code <Integer>}Umstellung auf
	 * 
	 * @param strList Eingabewert
	 * @Konvertierungsergebnis zurückgeben
	 * @löst NumberFormatException aus Wenn das Argument ein Element enthält, das nicht in einen numerischen Wert konvertiert werden kann.
	 */
	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>}Fügen Sie interne Nummern hinzu
	 * 
	 * @param numList Eingabewert
	 * @Aggregationsergebnis zurückgeben
	 */
	private static int sum(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).mapToInt(v -> v).sum();
	}

	/**
	 * List{@code <Integer>}Nur auf positive ganze Zahlen eingrenzen
	 * 
	 * @param numList Eingabewert
	 * @Ergebnis der Verarbeitung zurückgeben
	 */
	private static List<Integer> findPuls(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v >= 0).collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Nur auf negative ganze Zahlen eingrenzen
	 * 
	 * @param numList Eingabewert
	 * @Ergebnis der Verarbeitung zurückgeben
	 */
	private static List<Integer> findMinus(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v <= 0).collect(Collectors.toList());
	}

	/**
	 * List{@code <Integer>}Drücken Sie zu gleichmäßig
	 * 
	 * @param numList Eingabewert
	 * @Ergebnis der Verarbeitung zurückgeben
	 */
	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>}Nur ungerade Zahlen
	 * 
	 * @param numList Eingabewert
	 * @Ergebnis der Verarbeitung zurückgeben
	 */
	private static List<Integer> findOdd(List<Integer> numList) {
		return numList.stream().filter(Objects::nonNull).filter(v -> v % 2 != 0).collect(Collectors.toList());
	}
}

Schauen wir uns jeden an

Konvertieren Sie die Elemente von "List " in "List ", während Sie Nullen entfernen

convertToStr.java

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

Konvertieren Sie Elemente von List <String> in List <Integer>, während Sie Nullen entfernen

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> Aggregieren Sie die internen Zahlen, während Sie Nullen entfernen

sum.java

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

Begrenzen Sie List <Integer> auf nur positive ganze Zahlen

findPuls.java

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

Beschränken Sie "List " auf nur negative Ganzzahlen

findMinus.java

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

Grenzen Sie die Liste auf nur gerade ein

findEven.java

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

Grenzen Sie List <Integer> auf nur ungerade Zahlen ein

findOdd.java

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

Ich möchte ListUtils machen

Willst du es nicht schaffen?

Nun, es scheint unwahrscheinlich, dass es verwendet wird, wenn es nur eine einfache Operation ist ...?

Ist es überhaupt nur ein Originalmodell?

Ich möchte die Grundoperation so im Voraus vorbereiten

~~ Ich möchte, dass du so viel auf der Java-Seite vorbereitest ...? ~~