Zeile aus Stringlist löschen, wie optimieren?

[himitsu]

Zitat von p80286:

{leerzeilen löschen}

Delphi-Quellcode:

Stringliste.loadfromfile('Testdatei');
..
for i:=Stringliste.count-1 downto 0 do
  if length(Stringliste[i])=0 then Stringliste.delete(i);

Hat man mehr als 1 Mio Zeilen, kann das schon dauern. Darum meine Frage, wie kann ich das optimieren?

Ein etwas besseres Laufzeitverhalten habe ich mit

Delphi-Quellcode:

for i:=Stringliste.count-1 downto 0 do begin
  if length(Stringliste[i])>0 then stringlist2.insert(0,stringlist[i]);
  Stringlist.delete(i);
end;

(das Verhältnis ist etwa 6:5)


Als untauglich hat sich erwiesen:

Delphi-Quellcode:

p:=pos(#13#10#13#10,string);
while p>0 do begin
  delete(string,p,2);
  p:=posex(#13#10#13#10,string,p-1);
end

Da beim TStringlist.Delete letztlich nur 3 Pointer verschoben werden erhoffe ich mir von einer Pointerliste auch keine große Verbesserung.

All zuviel kann man da eh nicht optimieren.

1. es wird ein Pointer aus der Liste entfernt UND die Pointer der nachfolgenden Strings werden verschoben
2. die Referenzen der zukopierenden Strings werden kopiert, und die Referenzzählung wird angesprochen (Stringinhalte werden nicht kopiert)
3. erst wird aus allen Strings/Zeilen EIN großer String gebastelt, dann wird via StringReplace "jeder" doppelte Zeilenumbruch einzeln entfernt (Achtung, bei 3 und mehr aufeinanderfolgenden Zeilenumbrüchen wird nur jeder Zweite entfernt), dabei werden alle nachfolgenden Zeichen jedesmal umkopiert, und dann wird der ganze String wieder in viele Einzelstrings zerlegt

Auslesen als TEXT geht nur bei einem Memo (TMemoStrings) schneller, da dort der Text zusammenhängend im RAM liegt. (aber das Löschen der Leerzeilen sollte auch da temporärn einer TStringList erfolgen, da das TMemo arschlangsam ist).




Wie kommen die Daten denn in die TStringList?
Was am Schnellsten ginge, wäre die Leerstrings garnicht erst aufzunehmen.
Also die Add-Methode überschreiben und bei dem ungewollten Leerstring abbrechen.

[p80286]

So chefe stört nicht mehr...
erst einmal vielen Dank für die vielen Rückmeldungen.

Zunächst, alle Zeilen müssen vorliegen und erst dann entscheidet sich welche Zeilen gelöscht werden. Sehr oft sind Leerzeilen betroffen und dafür hab ich dann eine Spezialbehandlung.
Die Lösung "nicht einlesen" entfällt daher.

Die Prüfung auf Stringlist[i]='' hab ich ausprobiert und gefühlt sind da ein paar Sekunden herum gekommen.

Die "Kopierlösung" ist auch auf andere Zeileninhalte anwendbar, zusammen mit dem "Auftrennen" scheint das interessant zu werden. Muß ich mal testen. Das wichtigste Problem was ich sehe ist hirbei der Speicherplatzbedarf.
Mal ausprobieren.

noch mal vielen Dank
K-H

P.S. z.Zt. arbeite ich mit ca 2,5 Mio Zeilen das fluppt so oder so

[Mokus]

Zitat:

Das wichtigste Problem was ich sehe ist hirbei der Speicherplatzbedarf.

WTF ?

wenn das dein Grö´tes Problem solltest du dir alg. Gedanken machen, ob man da nicht was anders Lösen könnte ...

[Furtbichler]

folgendes geht auch (ohne extra Liste)

Delphi-Quellcode:

Procedure RemoveEmptyLines (aList : TStringList);
Var
  i,j : Integer;

Begin
  j:=0;
  for i:=0 to aList.Length-1 do
    if aList[i]<>'' then begin
      aList[j] := aList[i];
      j := j + 1;
    end;
  
  SetLength(aList,j);
End;

(Ungetestet) Im Prinzip rennt man die Liste einmal durch und kopiert nur die nichtleeren Zeilen. Nach jedem Kopiervorgang erhöht man die Zielposition j um 1.

Braucht kaum/keinen extra Speicher

[OlafSt]

Und warum das ganze nicht Ultra-Oldschool ?

Delphi-Quellcode:

procedure bla;
var
  f: TEXTFILE;
  s: string;
  TSL: TStringList;
begin
  TSL:=TStringList.Create;
  AssignFile(f, 'BLA.TXT');
  Reset(f);
  while not eof(f) do
  begin
    ReadLn(f,s);
    if s <> '' then
      TSL.Add(s);
  end;
  CloseFile(f);
end;

Datei wird nur einmal komplett gelesen und der Speicherbedarf ist fürs Einlesen nahezu Null.

[Blup]

Ah, da war jemand schneller, habs getestet, ist wirklich schnell.

Delphi-Quellcode:

    sl.BeginUpdate;
    try
      i2 := 0;
      for i := 0 to sl.Count - 1 do
      begin
        if sl[i] <> '' then
        begin
          sl[i2] := sl[i];
          Inc(i2);
        end;
      end;
      for i := sl.Count - 1 downto i2 do
        sl.Delete(i);
    finally
      sl.EndUpdate;
    end;

[Uwe Raabe]

Zitat von p80286:

Das wichtigste Problem was ich sehe ist hirbei der Speicherplatzbedarf.

Das Problem ist kleiner als du vielleicht denkst. Wenn du den Inhalt einer Stringlist kopierts, werden nur die Pointer auf die Strings kopiert und nicht die Stringinhalte. Somit verbraucht die kopierte StringList kaum mehr als <Anzahl Zeilen>*<Sizeof(Pointer)> an zusätzlichem Speicher.

[p80286]

Zitat von Uwe Raabe:

Das Problem ist kleiner als du vielleicht denkst. Wenn du den Inhalt einer Stringlist kopierts, werden nur die Pointer auf die Strings kopiert und nicht die Stringinhalte. Somit verbraucht die kopierte StringList kaum mehr als <Anzahl Zeilen>*<Sizeof(Pointer)> an zusätzlichem Speicher.

Das ist ein Wort!
ich war mir nicht sicher ob nicht vielleicht doch die Inhalte kopiert werden!

Gruß
K-H

[Neutral General]

Wie siehts mit StringReplace aus? Schonmal probiert wie das abschneidet?

StringReplace(Stringlist.Text,#13#10,'',[rfReplaceAll])

[jaenicke]

Zitat von Neutral General:

Wie siehts mit StringReplace aus? Schonmal probiert wie das abschneidet?

StringReplace(Stringlist.Text,#13#10,'',[rfReplaceAll])

Sehr schlecht, denn dabei werden erst alle Strings aus der Liste zu einem einzelnen verkettet (sprich mindestens doppelter Speicherverbrauch, vom Zusatzaufwand ganz abgesehen) und dann darin die Zeilenumbrüche gesucht, die vorher schon so schön bekannt waren, und dann ein weiterer String mit dem Ergebnis angelegt (sprich noch einmal Speicher verballert).

Insgesamt verstehe ich das ganze so:
Eine Datei wird geladen, nach mehreren Kriterien sollen dann Zeilen gelöscht werden und am Ende soll das Ergebnis wieder gespeichert werden. Richtig?
Wenn ja, befürworte ich immer noch die Variante, die ich schon früher genannt hatte:
Einfach alles unverändert lassen und nur die zu löschenden Zeilen beim Speichern auslassen. Dafür kann man sich einfach ein Array of Boolean anlegen und darin markieren welche Zeilen gelöscht sind. Solange die Kriterien zur Löschung nicht indexabhängig sind und die Anzahl der Zeilen prozentual nicht sehr hoch ist, sollte das die schnellste Variante sein.