String splitten und nacheinander löschen

[23paul23]

Hallo,

ich habe eine Liste mit Namen vom Typ String. Diese werden durch eine Komma getrennt in eine Tabellen-Zelle geschrieben mit folgendem code

StringBuilder sb = new StringBuilder();
list.add(name)
for(Iterator<String> iter = list.iterator(); iter.hasNext();)
{
	sb.append(iter.next());
}
column.setValue(column.getValue() + sb.toString() + ", "); //z.B. wie folgt: Hans, Peter, Dieter,

Nun möchte ich einzelne Namen aus der Zelle wieder löschen.
Dazu habe ich mir gedacht, dass ich den gesamten Inhalt der Zelle an ein String übergebe und diese durch das Trennzeichen "," splitte und in eine neue Liste hinzufüge. Somit könnte ich nur die Namen löschen aber die Kommas würden in der Zelle weiterhin existieren. Also wie folgt:

String splitName;
String[] afterSplit;
List<String> list = new ArrayList<String>();
String delimiter = ",";
splitName = column.getValue(); // splitName = Hans, Peter, Dieter,
afterSplit = splitName.split(delimiter); // afterSplit = [Hans, Peter, Dieter] natürlich ohne Komma im Array
for(int i=0; i<splitName.length; i++)
{
       list.add(afterSplit[i]); 
}

Wie kann ich jetzt z.B. die Abfrage definieren, wenn Hans gefunden wird, das Hans inklusive das nächste Komma gelöscht werden können?

if(name == "Hans")
{
      .... // es soll dann in der Zelle nur noch "Peter, Dieter," stehen. 
}

Vielen Dank

 

[Marco13]

Klingt schräg. Strings vergleicht man mit
if (name.equals("Hans")) { ... }

Spricht etwas dagegen, den Namen mit list.remove(name) aus der Liste zu entfernen, und den String neu zu bauen? Da mit string.split und Kommasuche usw. rumzuwurschteln wirkt... zerbrechlich (nicht nur wenn jemand in seinen Namen fieserweise ein Komma einbaut )

 

[23paul23]

sorry wegen dem tippfehler

list.remove(name) war auch mein erster versuch, daber dann war die frage wie ich die kommas löschen kann.
anscheinend bleibt mir nichts übrig, als den zellen-wert immer wieder neu zu bauen.

 

[Marco13]

Doch, es bleibt dir was anderes übrig. Du KANNST auch den String auseinanderpflücken und die Kommas per Hand entfernen. Es ging nur um die Frage, was einfacher ist...

 

[23paul23]

hallo

noch mal kurz meine ausgangslage:

Zelleninhalt: Hans, Peter, Dieter, Paul

Zelleninhalt soll nach und nach gelöscht werden, z.B. (dir Reihenfolge spielt keine Rolle):
1. Hans, Dieter, Paul //Peter wird mit Komma entfernt
2. Hans, Dieter // Paul wird mit Komma entfernt
3. Dieter //Hans wird mit Komma entfenrt
4 // Dieter wird entfernt und die Zelle bleibt leer

Mein bisheriges Programm:

public void addNamesInCell()
{
        List<String> nameList = new ArrayList<String>();
	StringBuilder sb = new StringBuilder();
        nameList.add(names); // Annahme: Hans, Peter, Dieter, Paul wurden hinzugefügt

	for(Iterator<String> iter = nameList.iterator(); iter.hasNext();)
	{
		sb.append(iter.next()); 
	}
				
	if(!column.getValue().contains(names) && column.getValue().length()<1)
	{
		column.setValue(sb.toString()); // falls noch kein Name vorhanden ist, dann soll der Name ohne ein Komma eingetragen werden
	}
	if(!column.getValue().contains(names) && column.getValue().length()>0)
	{
		column.setValue(column.getValue() + ", " + sb.toString()); //falls schon ein Name vorhanden ist, dann soll der neue Name nach einem Komma eingetragen werden
	}
}

Die Namen sollen jetzt einzeln aus der Zelle entfernt werden aber weiterhin durch Kommas getrennt werden.

public deleteNamesInCell()
{
        String temp;
	String delimiter = ",";
	String[] splitedNames;
	List<String> splitedList = new ArrayList<String>();
	StringBuilder sb = new StringBuilder();

        temp = column.getValue(); // z.B. temp = Hans, Peter, Dieter, Paul
        splitedNames = temp.split(delimiter);
        for(int i=0; i<splitedNames.length; i++)
        {
                splitedList.add(splitedNames[i]); // in der Liste sind jetzt die Namen ohne Kommas enthalten
        }

        if(splitedList.contains(name)) //z.B. ist name = Peter
        {
                splitedList.remove(name); //Peter wird aus der Liste enfernt
                for(Iterator<String> iter ) splitedList.iterator(); iter.hasNext();)
                {
                        sb.append(iter.next()); // bzgl. den übrig gebliebenen Namen werden iteriert
                }
                if(column.getValue().length()>0) //?
                {
                        column.setValue(...); //? In der Zelle sollen die Namen Hans, Dieter, Paul stehen. Jeweils immer durch ein Komma getrennt, damit beim nächsten Durchlauf wieder bzgl. dem Komma gesplittet werden kann. 
                }
                if(column.getValue()==0)
                {
                        System.out.println("Alle Namen wurden entfernt");
                }
        }
}

Mein Problem ist die if-Bedingung in der Zeile 23 von der Methode deleteNameInCell() zu definieren. Wie kann dich der Zelle die übrig gebliebenen Namen, die wiederrum durch ein Komma getrennt sind, übergeben?
Für jede Hilfestellung bin ich dankbar.

 

[Marco13]

So ein Krampf. Poste ein KSKB, und beschreibe, wann da was wie aufgerufen werden soll.

 

[23paul23]

Ein KSKB ist schwierig, weil das ganze Programm sehr komplex ist und als Plug-in erweitert wird.

Ich kann höchstens abstrakt die Reihenfolge darstellen, wann was aufgerufen wird:

public class MainClass
{
AddDeleteClass adClass = new AddDeleteClass();

public static void main(String [ ] args)
{
       ...

       if(name=soll hinzugefügt werden) //die namen werden von einer anderen Tabelle gelesen
       {
              addNameInCell(name); // hatte vorhin vergessen, dass diese Methode als Parameter ein String übergeben bekommt
       }

       if(name=soll entfernt werden)
       {
              deleteNameInCell(name); //ebenfalls Parameter vom Typ String
       }
       ...
}
}

public class AddDeleteClass
{
       public void addNamesInCell(String names)
       {
              // siehe unten
       }

       public void deleteNamesInCell(String names)
       {
              // siehe unten
       }
}

Einen kompletten Auszug kann ich leider nicht posten, weil das sehr komplex ist und ich nur einen teilbereich mir angucke.
Mir fehlt die Idee wie ich die if-Bedingung realisieren kann.

 

[23paul23]

Wo ich gerade mir noch mal den Code anschaue, fällt mir auf, dass die letzen beiden if-abfragen aus der Methode delteNamesInCell(String names) wie folgt sein müssen

if(splitedList.size()>0)
{
      //solange die Liste noch Namen enthält, sollen diese in die Celle geschrieben werden
}

if(splitedList.size()==0)
{
      System.out.println("Alle Namen wurden entfernt");
}

 

[23paul23]

wenn ich

if(splitedList.size()>0)
{
       column.setValue(sb.toString);        
}

verwendet, dann steht in der Zelle, z.B. folgendes: Hans Dieter Paul. Also jeweil ohne Komma.

Ich überlege gerade diese Wert (colum.getValue()) bezgl. den Leerzeichen zu trennen, in eine Liste zu speichern und analog der Methode addNamesInCell(String names) als neuen Wert durch Kommas getrennt in die Zelle zu schreiben.

Mir fällt nichts anderes ein.

 

[Mizar]

Nur so eine Idee, aber wäre etwas in dieser Richtung nichts für dich?

public class Main
{
	public static void main(String[] args)
	{
		AddDeleteClass adClass = new AddDeleteClass();
		
		adClass.addNameToCell("Jochen");
		adClass.addNameToCell("Hans");
		adClass.addNameToCell("Beate");
		adClass.deleteNameFromCell("Hans");
		adClass.addNamesToCell(new String[]{"Jochen", "Beate"});
		adClass.addNameToCell("Beate");
		adClass.addNameToCell("Matthias");
		adClass.deleteNamesFromCell(new String[]{"Karl", "Susi", "Heinz"});
	}
}

class AddDeleteClass
{
	private LinkedList<String> data;
	
	public AddDeleteClass()
	{
		this.data = new LinkedList<String>();
	}
	
	public void addNameToCell(String name)
	{
		if(!data.contains(name)) {
			data.add(name);
			setColumnContent();
		}
	}
	
	public void addNamesToCell(String[] names)
	{
		int oldSize = data.size();
		for(String name: names) {
			if(!data.contains(name)) {
				data.add(name);
			}
		}
		if(oldSize != data.size()) {
			setColumnContent();
		}
	}
	
	public void deleteNameFromCell(String name)
	{
		if(data.contains(name)) {
			data.remove(name);
			setColumnContent();
		}
	}
	
	public void deleteNamesFromCell(String[] names)
	{
		if(data.removeAll(Arrays.asList(names))) {
			setColumnContent();
		}
	}
	
	private void setColumnContent()
	{
		StringBuilder str = new StringBuilder();
		if(!data.isEmpty()) {
			str.append(data.getFirst());
			for(int i = 1; i < data.size(); ++i) {
				str.append(", " + data.get(i));
			}
		}
		// Hier entsprechend Zelleninhalt neu setzen, je nachdem
		// wie genau du Zugriff auf die Zelle hast.
		// Als Test nur eine Konsolenausgabe:
		System.out.println(str);
	}
}

 

[23paul23]

Hallo,

habe das Problem meiner Meinung nach einfacher gelöst. habe die methode replaceAll verwendet um die enthaltenen namen (mit oder ohne komma) einfach durch ein leerzeichen zu ersetzen. anschließend werden alle doppelten leerzeichen entfernt.

String value, temp, newValue;
value = column.getValue();
if(value.contains(names))
{
       if(value.contains(names + ",")      
       {
       temp = value.replaceAll(names + ",", ""); //ersetze name mit nachfolgendem komam durch ""
       newValue = temp.replaceAll("  ", " "); //ersetzte alle doppelten leerzeichen durch ein leerzeichen
       column.setValue(newValue);
       value = column.getValue(); //überprüfe für den nächsten durchlauf den aktuellen zelleninhalt
       }

       if(value.contains(", " + names)      
       {
       temp = value.replaceAll(", " + names, ""); //ersetze name mit vorstehendem komam durch ""
       newValue = temp.replaceAll("  ", " "); //ersetzte alle doppelten leerzeichen durch ein leerzeichen
       column.setValue(newValue);
       value = column.getValue();
       }

       if(value.contains(names)      
       {
       temp = value.replaceAll(names, ""); //ersetze name mit vorstehendem komam durch ""
       newValue = temp.replaceAll("  ", " "); //ersetzte alle doppelten leerzeichen durch ein leerzeichen
       column.setValue(newValue);
       value = column.getValue();
       }
}

 

[Marco13]

Bei

Hans , Wurst
    ^ Leerzeichen-Komma-Leerzeichen

haut's ihn da wohl raus, aber ist vielleicht nur ein Datei. Die "modellorientierteste" (und IMHO mit "robusteste") Lösung hatte ich ja schon in der ersten Antwort angedeutet, und Mizar hat dann ein Beispiel dafür ausgearbeitet.