Arraywerte auslesen und löschen

[ankmanu]

Hi,

ich habe folgendes Problem:
Ich habe ein Array greenarray_x mit 100 Speicherplätzen. Dieses wird jetzt mit verschiedenen Werten gefüllt, die sich allerdings meistens fast gleichen.
Also zB so:

greenarray_x [1] = 240;
greenarray_x [2] = 239;
greenarray_x [3] = 241;
greenarray_x [4] = 243;

Ab einem zufälligen Speicherplatz(z.B. 20) kommen dann andere ähnliche Werte:

greenarray_x [20] = 430;
greenarray_x [21] = 435;
greenarray_x [22] = 428;
greenarray_x [23] = 434;

Wie kann ich nun immer nur EINEN der ähnlichen Werte weiterverwenden?
Also es müsste folgendes passieren:

Das Programm müsste z.B den 1.Arraywert nehmen (240) und dann überprüfen, ob irgendein anderer Arraywert diesem Wert um +-10 gleicht. (in diesem Fall Arraywert 2,3 und 4)
Alle Werte, die diesem Wert gleichen (um +-10) sollten dann aus dem Array gelöscht werden!
(so dass dann nur noch wert 1 übrig bleibt)
Dann sollte das Programm den nächsten anderen Wert nehmen(also 430) und das selbe tun.

Am Ende sollten dann also 2 Werte übrig bleiben (nämlich 240 und 430)!
Diese Werte würde ich dann nämlich gerne weiterverwenden...

Übrigens sollten alle Werte, die null sind(das kann vorkommen, wenn das array nicht voll gefüllt ist, also z.B nur 90 Speicherplätze beschrieben wurden) sofort gelöscht werden!

Aber wie kann ich das realisieren (also Arraywerte nach ähnlichen überprüfen, arraywerte löschen,...)??

Vielen Dank schon mal

manu

 

[Isrok]

Moin, ich hätte mal eine frage dazu , was genau meinst du mit Löschen (=null setzen)? Und willst du als Ergebniss nur die Werte haben die glatt durch 10 teilbar sind?

 

[ankmanu]

naja ich will die werte einfach nicht verwenden, also ich will. am ende mit 2 werten weiterrechnen, und alle anderen(die ähnlich sind) brauch ich eben nicht mehr. (man kann sie also löschen oder einfach nicht verwenden.)
Nur weiß ich eben nicht wie ich das ganze realisieren soll!

Grüße
manu

 

[DaveX]

Ich würde sowas vorschlagen:

public static Integer[] cleanArray(int[] values, int abweichung)
{
	List<Integer> filter = new ArrayList<Integer>();
	filter.add(values[0]);
	int tmp = values[0];
	for( int pos = 1 ; pos < values.length; pos++ )
	{
		if( values[pos] < tmp-abweichung || values[pos] > tmp+abweichung )
		{
			tmp = values[pos];
			filter.add(values[pos]);
		}
	}
		
	return filter.toArray(new Integer[filter.size()]);
}

Testen kannst du es mit:

int[] alleWerte = {231,232,233,234,235,452,451,455,678,679,669}; // array mit initialisierten Werten
Integer[] test = DeinKlassenNamen.cleanArray(alleWerte , 10); // Abweichung +-10
		   
for (Integer gefilterterWert : test) {
	System.out.println(gefilterterWert );
}

 

[swingens]

Zur Überprüfung würde ich folgendes implementieren:
[Java] for ( int i = 0; i < greenarray_x.length; i++ )
{
for ( int j = 0; j < greenarray_x.length; j++ )
{
if (greenarray_x==greenarray_x[j] && j!=i)
{
//Variable aus dem Array löschen
}
}
}
[/code]

 

[DaveX]

if (greenarray_x==greenarray_x[j] && j!=i)
{
//Variable aus dem Array löschen
}

und wenn sowas vorkommt:

greenarray_x [1] = 240;
greenarray_x [2] = 239;
greenarray_x [3] = 240;
greenarray_x [4] = 243;

greenarray_x [1] == greenarray_x [3] && 1!=3 und umgelehrt

Es ist nicht gesagt dass sich die werte nicht wiederholen !

 

[swingens]

Zum rausfiltern würde ich doppelte Einträge einfach auf 0 setzen und 0-Werte später einfach ignorieren, ist meiner Meinung nach die einfachste, wenn auch nicht eleganteste Variante.

 

[DaveX]

Du nennst etwas mit der Komplexität n² elegant wenn es n sein kann ?
und dann noch unnötiges auf null setzen?

 

[swingens]

Du nennst etwas mit der Komplexität n² elegant wenn es n sein kann ?
und dann noch unnötiges auf null setzen?

Du scheinst nicht richtig zu lesen, ich schrieb NICHT die eleganteste Methode.

und wenn sowas vorkommt:

greenarray_x [1] = 240;
greenarray_x [2] = 239;
greenarray_x [3] = 240;
greenarray_x [4] = 243;

greenarray_x [1] == greenarray_x [3] && 1!=3 und umgelehrt

Es ist nicht gesagt dass sich die werte nicht wiederholen !

Versteh Dein Progblem nicht ganz;
nur wenn die beiden Arrays die gleichen Werte haben (greenarray_x [1] == greenarray_x [3]) aber nicht gleich sind (greenarray_x [1] == greenarray_x [3]) sollen sie rausgelöscht werden.

Es werden ja in jedem Durchgang die gleichen Werte miteinander verglichen, also z.B. greenarray_x [1] mit greenarray_x [1]; diese Werte sollen natürlich nicht rausgelöscht werden, dafür greift dann j!=i

Kannst Du gerne mal ausprobieren, funktioniert auf jeden Fall

 

[ankmanu]

Hi,

also danke erstmal an alle.

Nur um klarzustellen: Ein Wert kann NICHT zweimal vorkommen!

@DaveX
danke, aber das in Zeile 4 mit List funktioniert nicht. Muss ich da noch irgendwas dran ändern?

Gruß
manu

 

[DaveX]

Ups da hast du recht, hab die prüfung falsch interpretiert,
dennoch sagte er dass die Abweichung auch eine Rolle spielt.

ich habe dein Beispiel getestet:

List<Integer> muelleimer = new ArrayList<Integer>();
int[] abc = {231,232,233,234,235,452,451,455,678,679,669}; 
for ( int i = 0; i < abc.length; i++ )
{
     for ( int j = 0; j < abc.length; j++ )
    {
	 if (abc[i]==abc[j] && j!=i)
	{
	    muelleimer.add(abc[i]); //Variable aus dem Array löschen

	}
    }     
 }
		 
for (Integer integer : muelleimer) {
	System.out.println("soll gelöscht werden "+integer);
}

Ist das richtig ?

 

[DaveX]

@ankmanu was funktioniert nicht ? Wie lautet die meldung ?

vielleicht fehlt oben der import?
import java.util.List;
import java.util.ArrayList;

Welches IDE benutzt du ?
das kann sonst automatisch generiert werden. wenn es fehlt

 

[ankmanu]

@DaveX

jo danke, ich hatte das import von java.util.List; vergessen...
Der Code geht jetzt, aber dein Testbeispiel nicht, da kommt als fehler:
method cleanArray nicht gefunden!

Das Beispiel geht jetzt ... SUPER...
Aber wie würde das ganze jetzt insgesamt aussehen?
Also wie kann ich jetzt nur die 3 richtigen Werte speichern(z.B in einem anderen Array)?
Das also nicht nur zwei identische Werte gelöscht werden, sondern auch welche mit einer Abweichung von +-10??


Grüße
manu

 

[swingens]

Dave, Dein Beitrag ist um einiges eleganter als meiner, besonders, da ich ja die Abweichung nicht berücksichtigt hatte.
Deine Interpretation meines Codes ist richtig, es wurden aber keine doppelten Werte initialisiert.
Für den Falle, dass doch welche initialisiert würden, würde der Code diese nur markieren, aber nicht rauslöschen.
Hier ist mir noch nicht ganz klar, wie Du diese tatsächlich rauslöschen willst... da hab ich ja nur die unelegante Methode mit dem ignorieren der 0-Werte ???:L

 

[ankmanu]

So, jetzt stimmt der Code mit der Abweichung, bis auf das, das jetzt alle werte gelöscht werden, und nicht 3 beibehalten werden!

import java.util.List;
import java.util.ArrayList;

public class test3
{
    public test3()
    {
    }
    public static void main (String[] args){
        
        List<Integer> muelleimer = new ArrayList<Integer>();
int[] abc = {231,232,233,234,235,452,451,455,678,679,669,232}; 
for ( int i = 0; i < abc.length; i++ )
{
     for ( int j = 0; j < abc.length; j++ )
    {
     if (abc[i]==abc[j] && j!=i)
    {
        muelleimer.add(abc[i]); //Variable aus dem Array löschen
 
    }
     if (abc[i]>abc[j]-10 && j!=i)
    {
        muelleimer.add(abc[i]); //Variable aus dem Array löschen
 
    }
    if (abc[i]<abc[j]+10 && j!=i)
    {
        muelleimer.add(abc[i]); //Variable aus dem Array löschen
 
    }
    }     
 }
         
for (Integer integer : muelleimer) {
    System.out.println("soll gelöscht werden "+integer);
}
    }
}

Wie kann ich das noch hinkriegen, das also in dem Fall hier 231, 452 und 678 in einem extra Array gespeichert werden?

Grüße
manu

 

[DaveX]

Du hast nicht alle Beiträge gelesen,
ich habe in meinem ersten Beitrag die funktion dafür gepostet , du hättest sie einfach wie unten benutzen sollen ;D

import java.util.List;
import java.util.ArrayList;

public class test3
{
    public test3()
    {
    }

public static Integer[] cleanArray(int[] values, int abweichung)
{
    List<Integer> filter = new ArrayList<Integer>();
    filter.add(values[0]);
    int tmp = values[0];
    for( int pos = 1 ; pos < values.length; pos++ )
    {
        if( values[pos] < tmp-abweichung || values[pos] > tmp+abweichung )
        {
            tmp = values[pos];
            filter.add(values[pos]);
        }
    }
        
    return filter.toArray(new Integer[filter.size()]);
}

public static void main (String[] args){
        
int[] abc = {231,232,233,234,235,452,451,455,678,679,669,232}; 
Integer[] gefiltertesErgebnis = test3.cleanArray(abc,10) // 10 ist die Abweichung
         
for (Integer integer : gefiltertesErgebnis ) {
    System.out.println("ist uebrig geblieben "+integer);
}
    }
}

 

[DaveX]

@swingens

rauslöschen ist sehr ungünstig da auf du evtl 80% der Array plätze zugreiffen musst.
und dazu laufst du n*n über das Array das dauert undkostet Zeit.

meine Idee war die einwert nehmen in den filter reinschmeissen und mit den nächsten vergleichen ob er der Abweichung genügt
wenn ja dann wird er nciht in den filter geworfen wenn ja dan wird er in den filter geworfen und gilt als neuer marker zum vergleichen.

So laufe ich nur einmal durch das Array muss es nicht modifizieren und am Ende convertiere ich die Liste zum Integer array mit den gefilterten Werten.