Fehlende Int Werte aus Array mit streams finden

[Kirby.exe]

Gibt es einen Weg die folgende Methode mit einem Stream zu lösen?

private static void ergaenze(int[] input) {
        int [] index = new int[2];
        int counter1 = 0;
        int counter2 = 0;
        for(int i = 0; i < input.length; i++) {
            if(input[i] == -1) {
                index[counter1] = i;
                counter1++;
            }
        }
        int tmp = 0;
        for(int i = 1; i <= 9; i++) {
            if(findIndex(i, input) == -1) {
                tmp = index[counter2];
                input[tmp] = i;
                counter2++;
            }
        }
    }

    private static int findIndex(int element, int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] == element) {
                return i;
            }
        }
        return -1;
    }

 

[krgewb]

Angenommen, du hast ein ArrayList (Integer) namens nums mit irgendwelchen ganzzahligen Werten.

Aller Integer-Werte in der ArrayList werden mit zwei multipliziert. (Der Name kann frei gewählt werden. Bei mir heißt er halt n. Die Hauptsache ist, dass links und rechts vom Pfeil derselbe Name steht).

nums.replaceAll(n -> n * 2);

Anderes Beispiel (hier werden alle Integer-Werte entfernt, die negativ sind. Hierzu wird geschaut, ob die Bedingung wahr ist. Die Bedingung steht rechts vom Pfeil):

nums.removeIf(n -> n < 0);

Als nächstes zeige ich dir, wie das mit streams gegangen wäre.

 

[krgewb]

Alle Werte mit zwei multiplizieren:

nums = nums.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

Alle Werte entfernen, die negativ sind (hier muss man anders herum denken. Ich sage dem Program: ,,Hole nur die, die gleich Null sind oder positiv sind):

 nums = nums.stream()
    .filter(n -> n >= 0)
    .collect(Collectors.toList());

Alles in einer Zeile:

 nums = nums.stream()
    .map(n -> n * 2)
    .filter(n -> n >= 0)
    .collect(Collectors.toList());

bzw.

nums = nums.stream().map(n -> n * 2).filter(n -> n >= 0).collect(Collectors.toList());

 

[Kirby.exe]

Alle Werte mit zwei multiplizieren:

nums = nums.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

Alle Werte entfernen, die negativ sind (hier muss man anders herum denken. Ich sage dem Program: ,,Hole nur die, die gleich Null sind oder positiv sind):

nums = nums.stream()
    .filter(n -> n >= 0)
    .collect(Collectors.toList());

Alles in einer Zeile:

nums = nums.stream()
    .map(n -> n * 2)
    .filter(n -> n >= 0)
    .collect(Collectors.toList());

bzw.

nums = nums.stream().map(n -> n * 2).filter(n -> n >= 0).collect(Collectors.toList());

Danke

 

[krgewb]

Beispiel für findFirst und ifPresent:

Optional<Person> first = result.stream().filter(t -> t.getName().equals("Mayer")).findFirst();

first.ifPresent(System.out.println("Huhu!"));

 

[krgewb]

Es tut mir Leid. Ich weiß jetzt nicht, wie ich jetzt das aus Beitrag #1 umsetzen würde.

 

[Kirby.exe]

Es tut mir Leid. Ich weiß jetzt nicht, wie ich jetzt das aus Beitrag #1 umsetzen würde.

Naja man könnte es ja etwas aufsplitten, gibt es eine Möglichkeit mit einem Stream ein Array nach den Fehlenden Zahlen zu Matchen? also folgendes Beispiel:

Gegeben ist ein Array welches Zahlen von 0-5 enthält, jedoch hat es zwei -1 Einträge.
Der Stream soll jetzt nach den fehlenden Zahlen suchen und diese in ein Array speichern.

Beispiel Array:

int[] numbers = {0,-1,5,3,-1};

Die Sortierung der Zahlen ist egal.

 

[krgewb]

0 bis 5? Das wären also sechs Elemente: 0, 1, 2, 3, 4, 5.
Dein Array namens numbers hat aber nur 5 Elemente.

 

[Kirby.exe]

0 bis 5? Das wären also sechs Elemente: 0, 1, 2, 3, 4, 5.
Dein Array namens numbers hat aber nur 5 Elemente.

Oh sorry mein Fehler xD ich meinte 1-4 also fünf Elemente xD geht das mit streams?

 

[krgewb]

Weiß ich nicht. Ich hätte es mit ArrayList gelöst.

import java.util.ArrayList;

public class Hauptprogramm {

	public static void main(String[] args) {

		int[] numbers = { 0, -1, 4, 3, -1 };

		ArrayList<Integer> nums = new ArrayList<>();
		for (int i = 0; i < numbers.length; i++) {
			nums.add(numbers[i]);
		}

		System.out.println("Fehlende Zahlen:");
		for (int i = 0; i < numbers.length; i++) {
			if (!nums.contains(i)) {
				System.out.println(i);
			}
		}

	}
}

Ausgabe:

Fehlende Zahlen:
1
2

 

[Kirby.exe]

Weiß ich nicht. Ich hätte das es mit ArrayList gelöst.

import java.util.ArrayList;

public class Hauptprogramm {

    public static void main(String[] args) {

        int[] numbers = { 0, -1, 4, 3, -1 };

        ArrayList<Integer> nums = new ArrayList<>();
        for (int i = 0; i < numbers.length; i++) {
            nums.add(numbers[i]);
        }

        System.out.println("Fehlende Zahlen:");
        for (int i = 0; i < numbers.length; i++) {
            if (!nums.contains(i)) {
                System.out.println(i);
            }
        }

    }
}

Ausgabe:

Fehlende Zahlen:
1
2

Das ist mit einer ArrayList geht war mir klar xD Ich hatte mir nur die Frage gestellt wozu streams den dienen, da man alles was ein stream macht auch iterativ lösen kann xD

 

[krgewb]

Oh sorry mein Fehler xD ich meinte 1-4 also fünf Elemente xD geht das mit streams?

Das sind aber vier Elemente: 1, 2, 3, 4

 

[Kirby.exe]

Das sind aber vier Elemente: 1, 2, 3, 4

Sorry ich bin etwas müde, ist ja auch relativ egal wie viele Elemente es sind, ich hatte mich nur gefragt ob es alternativ zu schleifen und ArrayLists gibt xD Naja scheint nicht so

 

[lennero]

        int[] nums = {0, -1, 2, -1, 4, 5};
        boolean[] isNotMissing = new boolean[nums.length];
        
        java.util.Arrays.stream(nums).forEach(n ->
        {
            if(n >= 0)
            {
                isNotMissing[n] = true;
            }
        });
        int[] neueNums = IntStream.range(0, nums.length).map(n -> isNotMissing[n] ? nums[n] : n).toArray();

 

[Kirby.exe]

        int[] nums = {0, -1, 2, -1, 4, 5};
        boolean[] isNotMissing = new boolean[nums.length];
       
        java.util.Arrays.stream(nums).forEach(n ->
        {
            if(n >= 0)
            {
                isNotMissing[n] = true;
            }
        });
        int[] neueNums = IntStream.range(0, nums.length).map(n -> isNotMissing[n] ? nums[n] : n).toArray();

thx

 

[mihe7]

int[] missing = IntStream.rangeClosed(0,5).filter(i -> IntStream.of(numbers).noneMatch(v -> v == i)).toArray();

 

[krgewb]

@lennero In deinem Beispiel ist das Array nums aber schon sortiert! 0, 2, 4 und 5 sind schon an der richtigen Stelle!!

 

[Kirby.exe]

@lennero In deinem Beispiel ist das Array nums aber schon sortiert! 0, 2, 4 und 5 sind schon an der richtigen Stelle!!

Am ende soll das Array ja nicht sortiert sein, somit macht es meines Erachtens keinen Unterschied

 

[thecain]

Das beispiel von @lennero ist mMn sowieso ein How-Not-To Streams. Hier wäre ein Loop sicher einfacher. Aber das Stand ja hier nicht zur Frage von dem her keine harte Kritik

 

[lennero]

Das beispiel von @lennero ist mMn sowieso ein How-Not-To Streams. Hier wäre ein Loop sicher einfacher. Aber das Stand ja hier nicht zur Frage von dem her keine harte Kritik

Das stimmt. War zu voreilig, bitte nicht nachmachen

Das Beispiel funktioniert sowieso nur wenn alle Elemente bereits an ihrer richtigen Stelle stehen (und nur durch eine -1 ersetzt wurden).