Einzelne Werte von Array-Feld löschen

[SugarRay]

Hallo

Ich habe noch eine Frage:

Ich übergebe ein Int-Feld mit positiven und negativen Werten.

In der Funktion werden die negativen Werte gelöscht.

Das heisst, danach werden nur noch die poitiven Werte angezeigt.

Wenn zum Beispiel feld[2] negativ ist, was schreibe ich dann nach dem = in der Funktion hin? Wenn ich 0 schreiben würde, würde ja dann dafür in der Ausgabe eine 0 stehen. Oder muss ich = null ; schreiben ?

Danke

 

[Fab1]

du kannst dir mal ArrayList anschauen, diese ist dynamisch und man kann mithilfe von remove() einfach Werte löschen. ArrayList (Java Platform SE 6)

Hat Ähnlichkeiten mit einem normalen Array.

 

[SugarRay]

also

z.b.

remove(feld[2]); ?

 

[Fab1]

Nein, es reicht wenn du NUR den Index angibst.

import java.util.ArrayList;

public class Test {

	public static void main(String[] args) {

		ArrayList<Integer> a = new ArrayList<Integer>();  // Innerhalb der <> wird der Typ gesetzt, der erwartet wird, in diesem Fall Integer, kann auch eine Objekt oder ähnliches sein.
		
		for(int i = 0; i<10; i++){
			a.add(i);
		}
		a.remove(5); // Index 5 wird gelöscht
	}
}

 

[SugarRay]

Bitte nicht so kompliziert.


Ich habe das jetzt so geschrieben:

public static void main (String [] args)
{

int [] feld = new int [10];

feld[0] = 12;
feld[1] = -12;
feld[2] = -23;
feld[3] = 231;
feld[4] = -2;
feld[5] = 7;
feld[6] = 4;
feld[7] = 8;
feld[8] = -56;
feld[9] = 6;

for (int i = 0; i < 10; i++)
{
if (feld < 0) feld = null;
}

for (int i = 0; i < 10; i++)
{
System.out.print(" " + feld);
}



}

}

 

[Fab1]

Hi,


im Forum gibt es die Java Tags, somit wäre dein Code leichter zu lesen für spätere Posts.

schau mal http://www.java-forum.org/java-basics-anfaenger-themen/111919-null-primitive-datentypen.html man kann einem Primitiven Datentyp kein null zuweisen.

public class Test {

	public static void main(String[] args) {

		int[] feld = new int[10];

		feld[0] = 12;
		feld[1] = -12;
		feld[2] = -23;
		feld[3] = 231;
		feld[4] = -2;
		feld[5] = 7;
		feld[6] = 4;
		feld[7] = 8;
		feld[8] = -56;
		feld[9] = 6;

	/*	for (int i = 0; i < 10; i++) {
			if (feld[i] < 0)
				feld[i] = null; // man kann primitiven Datentypen kein null zuweisen.
		}*/

		for (int i = 0; i < 10; i++) {
			if(feld[i]>0){
				System.out.print(" " + feld[i]);
			}
			        
		}

	}

}

hoffe das hilft dir weiter. Hab ja nicht viel geändert. Ich gebe allerdings nur die positiven Werte aus und lösche sie nicht. Weiß aber auch nicht genau was du damit anstellen willst, hört sich ja an wie eine Hausaufgabe.

 

[SugarRay]

Klausurvorbereitung.

In der Angabe steht nur, dass die negativen Werte entfernt werden sollen. Vielleicht ist mit entfernt nur gemeint, dass sie dann nicht mehr ausgegeben werden.

Trotzdem danke.

 

[Final_Striker]

Löschen kannst du die Werte nicht aber z.B. in ein neues kleineres Array umkopieren.

 

[Fab1]

Klausurvorbereitung.

In der Angabe steht nur, dass die negativen Werte entfernt werden sollen. Vielleicht ist mit entfernt nur gemeint, dass sie dann nicht mehr ausgegeben werden.

Trotzdem danke.

Würde ich dann so nicht auffassen, sondern das die Werte rausmüssen

 

[SugarRay]

Hier ist die Aufgabenstellung:

Es ist die static-Methode (Funktion) "entferne" zu entwerfen.
An diese Methode wird ein int-Feld übergeben.
Im Feld stehen beliebige positive und negative Werte.
Der Wert 0 markiert den letzten Wert im Feld.
Die Funktion entfernt aus dem Feld alle negativen Werte, zählt
die entfernten Werte und gibt diese Anzahl als Rückgabewert
zurück. Um die negativen Werte zu entfernen, werden die Zahlen
hinter den negativen Werten innerhalb des Feldes "nach vorne"
umgespeichert.
Beispiel: Aus 2, -5, 22, -1, 234, 0
wird 2, 22, 234, 0

 

[SugarRay]

Ich habe es jetzt so. Ist vielleicht ein bisschen umständlich, aber ich kann es halt nicht besser. 😀

public class Vorbereitung2
{
	public static void main (String [] args)
	{

	int [] feld = new int [10];

	feld[0] = 12;
	feld[1] = -12;
	feld[2] = -23;
	feld[3] = 231;
	feld[4] = -2;
	feld[5] = -4;
	feld[6] = 4;
	feld[7] = 8;
	feld[8] = 0;
	feld[9] = 6;

	int entferntewerte = entferne(feld);
	
	System.out.println();
	System.out.print("Entfernte Werte: " + entferntewerte);
	}

	
	public static int entferne (int [] b)
	{
	int negativewerte = 0;
	int bisnull = 0;
	
	for (int i = 0; i < b.length ; i++)
		{
		bisnull++;
		if (b[i] == 0) break;
		
		}
	
	
	
	for (int i = 0; i < bisnull; i++)
		{
		if (b[i] < 0) negativewerte++;
		}
	
	int zaehler = 0;
	
	do
	{
	zaehler = 0;
	
	for (int i = 0; i < (bisnull-1); i++)
		{
			if(b[i] < 0)
			{
				if(b[i+1] >= 0)
				{
				int a = b[i+1];
				b[i+1] = b[i];
				b[i] = a;
				zaehler++;
				}
			}
		}
		
	}while(zaehler != 0);
	
	for (int i = 0; i < bisnull; i++)
		{
		if(b[i] >= 0) System.out.print(b[i] + " ");
		}
	
	return negativewerte;
	
	}

}

 

[Final_Striker]

In der Angabe steht nur, dass die negativen Werte entfernt werden sollen. Vielleicht ist mit entfernt nur gemeint, dass sie dann nicht mehr ausgegeben werden.

Ich finde schon, dass in der Aufgabe sehr deutlich beschrieben ist wie die Werte "entfernt" werden sollen.

 

[SugarRay]

Ich finde schon, dass in der Aufgabe sehr deutlich beschrieben ist wie die Werte "entfernt" werden sollen.

und wie sollen sie entfernt werden?

 

[Final_Striker]

Um die negativen Werte zu entfernen, werden die Zahlen
hinter den negativen Werten innerhalb des Feldes "nach vorne"
umgespeichert.
Beispiel: Aus 2, -5, 22, -1, 234, 0
wird 2, 22, 234, 0

steht doch da, sogar mit einem Beispiel.

Um die negativen Werte zu entfernen, werden die Zahlen
hinter den negativen Werten innerhalb des Feldes "nach vorne"
umgespeichert.
Beispiel: Aus 2, -5, 22, -1, 234, 0
wird 2, 22, 234, 0

 

[faetzminator]

Das geht doch auch einfacher:

public static int[] getPositiveNumbers(int[] input) {
    int[] temp = new int[input.length]; // temporäres Array erzeugen
    int tempSize = 0;
    for (int i = 0; i < input.length; i++) {
        if (input[i] >= 0) { // oder auch > 0
            temp[tempSize++] = input[i]; // schreib die Zahl in das leere Feld und erhöhe den Count
        }
    }
    // noch in ein neues Array kopieren
    int[] result = new int[tempSize];
    System.arraycopy(temp, 0, result, 0, tempSize);
    return result;
}

[c]System.arraycopy()[/c] kopiert hier von [c]temp[/c] ab Index 0 [c]tempSize[/c] Werte nach [c]result[/c] ab Index 0.
Wenn du also [c]{ -3, 1, 5, -7, 2 }[/c] übergibst, sieht [c]temp[/c] nach der Schleife so aus: [c]{ 1, 5, 2, 0, 0 }[/c] und [c]tempSize[/c] ist 3.
Danach wird noch das Array [c]result[/c] mit der Grösse 3 erstellt und die ersten drei Werte von [c]temp[/c] nach [c]result[/c] kopiert.
Aber wie von den Vorrednern schon gesagt, in der Praxis nutzt man normalerweise keine Arrays, sondern Collections, z.B. Lists.

 

[njans]

Nach 2maligem Lesen ist es mir nun auch klar.
Du verschiebst die positiven Zahlen über die negativen. Hmm ob das so viel Sinn macht, naja. In nem Array würden dann immer noch Zahlen in den anderen Einträgen sein, wirklich gelöscht ist das dann nicht. Und von Kopieren in ein neues Array mit passender Kardinalität steht auch nichts.