[Arrays] Kombinationsmöglichkeiten

[derfreak]

Hallo,

ich bin gerade auf ein Problem gestoßen und weiß leider nicht weiter.
Im Internet bin ich auf das gestoßen: KLICK,

Ich habe zwei Fragen:

1. Wie kombiniere ich zwei Arrays, in einem Array?
Wenn es geht bitte keine zwei For-Schleifen, ich suche eine Methode wie diese unten von der Webseite.
Beispiel:

int[] a = {4,6,8};
int[] b = {5,7};
int[] c = erstes array(also a), zweites array (also b)

Ich habe es schon versucht mit .clone(), leider hat es nicht zusammen funktioniert. (Einzeln schon)
Ebenfalls habe ich es bereits versucht mit System.arraycopy ebenfalls ein fehl griff.

int [] combined = ArrayUtils.addAll(first, second);

Auf der Webseite ist dieser Code zufinden, leider ist es bestimmt ein selbst implementierte Bibliothek...
Gibt es sowas auch auf der Standard Bibliothek?



2. Wie kombiniere ich ein Array und ein Int in einem Array?

int[] a = {4,6,8};
int b = 7;
c müsste jetzt 4 6 8 und 7 ausgeben

Vielen Dank!

 

[Tobse]

Zunächst einmal muss man hier sagen, dass die Größe eines Arrays nicht geändert werden kann. Die Größe wird bei der Initilisierung angegeben und ist damit fix.

zu 1: da bleibt einem nur das bloße kopieren:

public static int[] combine(int[] a, int[] b)
{
    int[] c = new int[a.length + b.length];
    System.arraycopy(a, 0, c, 0, a.length);
    System.arraycopy(b, 0, c, a.length, b.length);
    return c;
}

gleiches gilt für 2.:

public static int[] append(int[] a, int... b)
{
    return combine(a, b);
}

 

[Joose]

Tobse hat dir hier schon die Lösung verraten, außerdem steht auf der von dir geposteten Seite ebenfalls die Lösung! Hättest es nur von dort übernehmen und etwas anpassen müssen.

 

[derfreak]

Tobse hat dir hier schon die Lösung verraten, außerdem steht auf der von dir geposteten Seite ebenfalls die Lösung! Hättest es nur von dort übernehmen und etwas anpassen müssen.

Ich weiß, habe einiges versucht leider hat es nicht funktioniert.
Und wenn man dann einfach nicht weiter weiß, ist es schön wenn jemand anders den Fehler sieht bzw. einem Hilft.

Danke das hat geklappt.

Leider habe ich wieder ein Problem und weiß nicht weiter.
Und zwar ist es so, dass zum Array data eine zahlen Folge gibt z.b.{85,19,866,74,13,56,75}
threshold hat ebenfalls eine zahl z.b. 50
Alle Werte die größer als 50 sind im Array data, sollen nun in ein neues Array übergeben werden.

Um heraus zu finden wie viele zahlen davon betroffen sind habe ich eine einfache for schleife mit verwendung von Math.min und einem zaehler.

Nun weiß wie groß das Array sein muss, welches ich unten nun fast fertig geschrieben habe.
Jedoch weiß ich einfach nicht wie ich jetzt jedes einzelne element in das neue array einfügen kann.

	public int[] getValuesAboveThreshold(int threshold) {
	int zaehler = 0;
	int d = data[0];

	for(int i = 0; i < data.length; i++){
		if(Math.min(data[i], d) > threshold){
			zaehler++;
		}
	}
	int[] array4 = new int[zaehler];
	for(int j = 0; j < data.length; j++){
		if(data[j] > threshold){
			// Hier muss data[j] ins array4 kopiert werden
		}
		
	}
	return array4;
	}

 

[nvidia]

	public int[] getValuesAboveThreshold(int threshold) {
 return Arrays.stream(data).filter(i -> i > threshold).toArray();
}

 

[derfreak]

	public int[] getValuesAboveThreshold(int threshold) {
 return Arrays.stream(data).filter(i -> i > threshold).toArray();
}

Ist das was ich geschrieben habe so falsch?

 

[Joose]

Ist das was ich geschrieben habe so falsch?

Nein aber etwas zuviel
Das Math.min ist unnötig, du musst nur prüfen ob der Wert an Index i > threshold ist.

public int[] getValuesAboveThreshold(int threshold) {
	int zaehler = 0;
	for(int i = 0; i < data.length; i++){
		if(data[i] > threshold){ >
			zaehler++;
		}
	}
	int[] array4 = new int[zaehler];
        zaehler = 0
	for(int j = 0; j < data.length; j++){
		if(data[zaehler] > threshold){
			data[zaehler] = data[j];
		}		
	}
	return array4;
}

 

[derfreak]

Nein aber etwas zuviel
Das Math.min ist unnötig, du musst nur prüfen ob der Wert an Index i > threshold ist.

public int[] getValuesAboveThreshold(int threshold) {
	int zaehler = 0;
	for(int i = 0; i < data.length; i++){
		if(data[i] > threshold){ >
			zaehler++;
		}
	}
	int[] array4 = new int[zaehler];
        zaehler = 0
	for(int j = 0; j < data.length; j++){
		if(data[zaehler] > threshold){
			data[zaehler] = data[j];
		}		
	}
	return array4;
}

Das funktioniert leider nicht so.
Denn die in data[j] enthaltenen Zahlen müssen nun aufs array4 übertragen werden.

Wenn ich über Sysout nun data[j] prüfe um zu gucken welche Zahlen sich dort verbergen, bekomme ich:

85
93
81
79
81
93

Sonst kommt ja diese Aussage, da ja nichts übgeben wurde und wir nur ein leeres bzw. array mit 6 0 haben

Messwerte Über 78:
[0, 0, 0, 0, 0, 0]

Demnach muss ich data[j] irgendwie auf das Array übertragen.

 

[Joose]

Demnach muss ich data[j] irgendwie auf das Array übertragen.

Ja mein Fehler ;-)
In der 2.for-Schleife musst du die if-Bedingung anpassen
Statte data[zaehler] müsste dort data[j] stehen.

Gleich den Hinweis dazu: Nie(!) einfach Code aus dem Internet 1:1 kopieren ohne zu überlegen und testen was dieser macht.

 

[derfreak]

Ja mein Fehler ;-)
In der 2.for-Schleife musst du die if-Bedingung anpassen
Statte data[zaehler] müsste dort data[j] stehen.

Gleich den Hinweis dazu: Nie(!) einfach Code aus dem Internet 1:1 kopieren ohne zu überlegen und testen was dieser macht.

Danke für den Hinweis^^
Aber das funktioniert immer noch nicht. Ich glaube du missverstehst mich^^

Wir legen ja für array4 nichts fest außer dass es die genannte Länge besitzt. (Die durch die IF-Anweisung erstellt wurde.)

Bei Zeile 45 Steht was ich eig. meine

Hier mal der komplette Code:

import java.util.Arrays;

public class Measurement {

	private int[] data;

	public Measurement() {
		data = new int[0];
	}

	public void addValue(int value) {

		int[] data2 = new int[data.length + 1];
		System.arraycopy(data, 0, data2, 0, data.length);
		data2[data.length] = value;
		data = data2.clone();
	}

	public void addValues(int[] values) {
		int[] hilfsArray2 = new int[data.length + values.length];
		System.arraycopy(data, 0, hilfsArray2, 0, data.length);
		System.arraycopy(values, 0, hilfsArray2, data.length, values.length);
		data = hilfsArray2.clone();
	}

	public int getMinimumValue() {
		int c = data[0];
		for(int i = 0; i < data.length; i++){
		c = Math.min(data[i],c);
		}
		return c;
	}

	public int[] getValuesAboveThreshold(int threshold) {
	int zaehler = 0;
	for(int i = 0; i < data.length; i++){
		if(data[i] > threshold){
			zaehler++;
		}
	}
	int[] array4 = new int[zaehler];
	for(int j = 0; j < data.length; j++){
		if(data[j] > threshold){
			data[zaehler] = data[j];
// MEINE VERMUTUNG: Man muss es nun so schreiben, dass für jedes data[zaehler] (BTW: das 
// könnten wir sogar komplett weg lassen (glaube ich, da man direkt auf data[j] zugreifen könnte))
// element nun auf array4 übertragen wird.
		}
		
		
	}
	return array4;
	}

	// --------------------------------------------------------------
	
	public void printData() {
		System.out.println(Arrays.toString(data));
	}

	public static void main(String[] args) {
		Measurement m = new Measurement();
		System.out.println("Neues Measurement-Objekt m erzeugt. m:");
		// ErwarteteAusgabe:
		// []
		m.printData();

		System.out.println("------------------------------------------------------------------");
		
		m.addValue(85);
		System.out.println("Hinzufügen eines neuen Wertes. m:");
		// Erwartete Ausgabe:
		// [85]
		m.printData();
		
		System.out.println("------------------------------------------------------------------");
		
		m.addValues(new int[] { 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93 });
		System.out.println("Hinzuzfügen einer Menge von Werten. m:");
		// Erwartete Ausgabe:
		// [85, 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93]
		m.printData();
		
		System.out.println("------------------------------------------------------------------");
		
		int minimumValue = m.getMinimumValue();
		System.out.println("Minimaler Wert der Messreihe m:");
		// Erwartete Ausgabe: 58
		System.out.println(minimumValue);
		
		System.out.println("------------------------------------------------------------------");
		
		int[] valuesAbove78 = m.getValuesAboveThreshold(78);
		System.out.println("Messwerte über 78:");
		// Erwartete Ausgabe:
		// [85, 93, 81, 79, 81, 93]
		System.out.println(Arrays.toString(valuesAbove78));
		
		System.out.println("------------------------------------------------------------------");
		
		int[] valuesAbove93 = m.getValuesAboveThreshold(93);
		System.out.println("Messwerte über 93:");
		// Erwartete Ausgabe:
		// []
		System.out.println(Arrays.toString(valuesAbove93));
	}

}

 

[Chloroplast]

//Schritt 1
int zaehler = 0;
    for(int i = 0; i < data.length; i++){
        if(data[i] > threshold){
            zaehler++;
        }
    }
//Schritt 2
    int[] array4 = new int[zaehler];
    for(int j = 0; j < data.length; j++){
        if(data[j] > threshold){
            data[zaehler] = data[j];

Du machst im Prinzip zwei Schritte. im ersten zählt dein Programm die variable zaeler hoch, um herauszufinden wieviele Elemente überhaupt infrage kommen.

Im zweiten Schritt
legst du ein neues Array mit der größe des zählers an. Dann läufst du mit einer anderen Schleife über das ausgangsarray. wenn die Werte in dem Array an der jeweiligen Stelle größer sind als threshold speicherst du sie in das neue Array an der Stelle zaeler. zaeler war allerdings die anzahl der elemente, und wird im nachhinein nicht mehr verändert, dh. du speicherst alles an einer stelle ab. Eigentlich müsste hier auch eine ArrayIndexOutOfBoundsException fliegen, denn wenn du ein Array mit beispielsweise int[] a = new int[50]; anlegst, gibts es die Stellen 0 - 49.

Am besten verwendest du eine weitere variable die du hochzählst wenn etwas eingefügt wurde, etwa so:

//Schritt 1
int zaehler = 0;
    for(int i = 0; i < data.length; i++){
        if(data[i] > threshold){
            zaehler++;
        }
    }
//Schritt 2
    int counter = 0;
    int[] array4 = new int[zaehler];
    for(int j = 0; j < data.length; j++){
        if(data[j] > threshold){
            data[counter++] = data[j];

 

[derfreak]

Nein. Ihr habt mich einfach noch nicht verstanden.
Aber ich konnte das ganze Problem nun Lösen.
Dazu habe ich ein weiteres Array genommen & die letzte IF - Anweisung entfernt!
Jetzt stimmt es, jedenfalls nach der Ausgabe.

Ich bedanke mich DENNOCH für die STARKE UNTERSTÜRZUNG!
Echt nett von euch!

	public int[] getValuesAboveThreshold(int threshold) {
		int zaehler = 0;
		int[] temp = new int[data.length];
		for (int i = 0; i < data.length; i++) {
			if (data[i] > threshold) {
				temp[zaehler] = data[i];
				zaehler++;
			}
		}
		int[] array4 = new int[zaehler];
		for (int j = 0; j < array4.length; j++) {

			array4[j] = temp[j];

		}
		return array4;
	}

 

[nvidia]

Nein. Ihr habt mich einfach noch nicht verstanden.

Eine entsprechende Lösung die genau das gleiche Ergebnis wie deine bringt und dabei effizienter ist gab es schon weit vorher siehe http://www.java-forum.org/java-basi...s-kombinationsmoeglichkeiten.html#post1018044.

 

[derfreak]

Eine entsprechende Lösung die genau das gleiche Ergebnis wie deine bringt und dabei effizienter ist gab es schon weit vorher siehe http://www.java-forum.org/java-basi...s-kombinationsmoeglichkeiten.html#post1018044.

Ich habe es versucht, hat leider nicht funktioniert.
Gerne kannst du es ja testen.
Den Vollständigen Code findest du hier:

http://www.java-forum.org/java-basi...s-kombinationsmoeglichkeiten.html#post1018057

 

[nvidia]

Ich habe es versucht, hat leider nicht funktioniert [...]

Da du immer nur behauptest das es nicht funktioniert gehe ich davon aus das nicht die korrekte Ausgabe erzeugt wurde. Falls du kein Java 8 verwendest ist das ein anderes Thema.

Ich jedenfalls erhalte folgende Ausgabe die für mich verdächtig gleich aussieht.

Spoiler

Neues Measurement-Objekt m erzeugt. m:
[]
------------------------------------------------------------------
Hinzufügen eines neuen Wertes. m:
[85]
------------------------------------------------------------------
Hinzuzfügen einer Menge von Werten. m:
[85, 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93]
------------------------------------------------------------------
Minimaler Wert der Messreihe m:
58
------------------------------------------------------------------
Messwerte über 78:
original [85, 93, 81, 79, 81, 93]
java-8-Stil [85, 93, 81, 79, 81, 93]
------------------------------------------------------------------
Messwerte über 93:
original []
java-8-Stil []

Mit dem Code

Spoiler

public class Measurement {

    private int[] data;

    public Measurement() {
        data = new int[0];
    }

    public void addValue(int value) {

        int[] data2 = new int[data.length + 1];
        System.arraycopy(data, 0, data2, 0, data.length);
        data2[data.length] = value;
        data = data2.clone();
    }

    public void addValues(int[] values) {
        int[] hilfsArray2 = new int[data.length + values.length];
        System.arraycopy(data, 0, hilfsArray2, 0, data.length);
        System.arraycopy(values, 0, hilfsArray2, data.length, values.length);
        data = hilfsArray2.clone();
    }

    public int getMinimumValue() {
        int c = data[0];
        for (int i = 0; i < data.length; i++) {
            c = Math.min(data[i], c);
        }
        return c;
    }

    public int[] getValuesAboveThreshold(int threshold) {
        int zaehler = 0;
        int[] temp = new int[data.length];
        for (int i = 0; i < data.length; i++) {
            if (data[i] > threshold) {
                temp[zaehler] = data[i];
                zaehler++;
            }
        }
        int[] array4 = new int[zaehler];
        for (int j = 0; j < array4.length; j++) {

            array4[j] = temp[j];

        }
        return array4;
    }

    public int[] getValuesAboveThreshold2(int threshold) {
        return Arrays.stream(data).filter(i -> i > threshold).toArray();
    }

    // --------------------------------------------------------------

    public void printData() {
        System.out.println(Arrays.toString(data));
    }

    public static void main(String[] args) {
        Measurement m = new Measurement();
        System.out.println("Neues Measurement-Objekt m erzeugt. m:");
        // ErwarteteAusgabe:
        // []
        m.printData();

        System.out.println("------------------------------------------------------------------");

        m.addValue(85);
        System.out.println("Hinzufügen eines neuen Wertes. m:");
        // Erwartete Ausgabe:
        // [85]
        m.printData();

        System.out.println("------------------------------------------------------------------");

        m.addValues(new int[]{58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93});
        System.out.println("Hinzuzfügen einer Menge von Werten. m:");
        // Erwartete Ausgabe:
        // [85, 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93]
        m.printData();

        System.out.println("------------------------------------------------------------------");

        int minimumValue = m.getMinimumValue();
        System.out.println("Minimaler Wert der Messreihe m:");
        // Erwartete Ausgabe: 58
        System.out.println(minimumValue);

        System.out.println("------------------------------------------------------------------");

        int[] valuesAbove78 = m.getValuesAboveThreshold(78);
        System.out.println("Messwerte über 78:");
        // Erwartete Ausgabe:
        // [85, 93, 81, 79, 81, 93]
        System.out.println("original " + Arrays.toString(valuesAbove78));
        System.out.println("java-8-Stil " +Arrays.toString(m.getValuesAboveThreshold2(78)));


        System.out.println("------------------------------------------------------------------");

        int[] valuesAbove93 = m.getValuesAboveThreshold(93);
        System.out.println("Messwerte über 93:");
        // Erwartete Ausgabe:
        // []
        System.out.println("original " + Arrays.toString(valuesAbove93));
        System.out.println("java-8-Stil " + Arrays.toString(m.getValuesAboveThreshold2(93)));
    }
}

 

[derfreak]

Da du immer nur behauptest das es nicht funktioniert gehe ich davon aus das nicht die korrekte Ausgabe erzeugt wurde. Falls du kein Java 8 verwendest ist das ein anderes Thema.

Ich jedenfalls erhalte folgende Ausgabe die für mich verdächtig gleich aussieht.

Spoiler

Neues Measurement-Objekt m erzeugt. m:
[]
------------------------------------------------------------------
Hinzufügen eines neuen Wertes. m:
[85]
------------------------------------------------------------------
Hinzuzfügen einer Menge von Werten. m:
[85, 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93]
------------------------------------------------------------------
Minimaler Wert der Messreihe m:
58
------------------------------------------------------------------
Messwerte über 78:
original [85, 93, 81, 79, 81, 93]
java-8-Stil [85, 93, 81, 79, 81, 93]
------------------------------------------------------------------
Messwerte über 93:
original []
java-8-Stil []

Mit dem Code

Spoiler

public class Measurement {

    private int[] data;

    public Measurement() {
        data = new int[0];
    }

    public void addValue(int value) {

        int[] data2 = new int[data.length + 1];
        System.arraycopy(data, 0, data2, 0, data.length);
        data2[data.length] = value;
        data = data2.clone();
    }

    public void addValues(int[] values) {
        int[] hilfsArray2 = new int[data.length + values.length];
        System.arraycopy(data, 0, hilfsArray2, 0, data.length);
        System.arraycopy(values, 0, hilfsArray2, data.length, values.length);
        data = hilfsArray2.clone();
    }

    public int getMinimumValue() {
        int c = data[0];
        for (int i = 0; i < data.length; i++) {
            c = Math.min(data[i], c);
        }
        return c;
    }

    public int[] getValuesAboveThreshold(int threshold) {
        int zaehler = 0;
        int[] temp = new int[data.length];
        for (int i = 0; i < data.length; i++) {
            if (data[i] > threshold) {
                temp[zaehler] = data[i];
                zaehler++;
            }
        }
        int[] array4 = new int[zaehler];
        for (int j = 0; j < array4.length; j++) {

            array4[j] = temp[j];

        }
        return array4;
    }

    public int[] getValuesAboveThreshold2(int threshold) {
        return Arrays.stream(data).filter(i -> i > threshold).toArray();
    }

    // --------------------------------------------------------------

    public void printData() {
        System.out.println(Arrays.toString(data));
    }

    public static void main(String[] args) {
        Measurement m = new Measurement();
        System.out.println("Neues Measurement-Objekt m erzeugt. m:");
        // ErwarteteAusgabe:
        // []
        m.printData();

        System.out.println("------------------------------------------------------------------");

        m.addValue(85);
        System.out.println("Hinzufügen eines neuen Wertes. m:");
        // Erwartete Ausgabe:
        // [85]
        m.printData();

        System.out.println("------------------------------------------------------------------");

        m.addValues(new int[]{58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93});
        System.out.println("Hinzuzfügen einer Menge von Werten. m:");
        // Erwartete Ausgabe:
        // [85, 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93]
        m.printData();

        System.out.println("------------------------------------------------------------------");

        int minimumValue = m.getMinimumValue();
        System.out.println("Minimaler Wert der Messreihe m:");
        // Erwartete Ausgabe: 58
        System.out.println(minimumValue);

        System.out.println("------------------------------------------------------------------");

        int[] valuesAbove78 = m.getValuesAboveThreshold(78);
        System.out.println("Messwerte über 78:");
        // Erwartete Ausgabe:
        // [85, 93, 81, 79, 81, 93]
        System.out.println("original " + Arrays.toString(valuesAbove78));
        System.out.println("java-8-Stil " +Arrays.toString(m.getValuesAboveThreshold2(78)));


        System.out.println("------------------------------------------------------------------");

        int[] valuesAbove93 = m.getValuesAboveThreshold(93);
        System.out.println("Messwerte über 93:");
        // Erwartete Ausgabe:
        // []
        System.out.println("original " + Arrays.toString(valuesAbove93));
        System.out.println("java-8-Stil " + Arrays.toString(m.getValuesAboveThreshold2(93)));
    }
}

Wow...
Java 7 Ich update mal danke!!

PS: Leider kann ich mir unter dem Code z.z. eh nichts vorstellen. Bin noch relativ neu dabei.
Aber allein, dass ich sehe wie viel Code man doch sparen kann, zeigt mir, dass ich noch viel zu lernen habe!

 

[nvidia]

[...]Bin noch relativ neu dabei.[...]

Die neuen syntaktischen Möglichkeiten sind zwar kein Allheilmittel aber dort wo man sie anwenden kann gibt es ein wenig Erleichterung. Und gerade als Anfänger, denke ich versteht man das relativ schnell wenn man es vernünftig erklärt bekommt.

Falls du Eclipse verwendest, für das "Update" siehe den Post von kaoz http://www.java-forum.org/allgemein...tring-methoden-algorithmik-2.html#post1017459. Netbeans oder IntelliJ sind bereits aktualisiert.