Strings zusammenführen und Bereinigen

[DeddyH]

Oder eine TList<integer> nehmen und vor dem Einfügen prüfen, ob IndexOf(AktuelleZahl) < 0 ist.

[arcticwolf]

Delphi-Quellcode:

Uses
  Generics.Collections,
  System.SysUtils;

Type TIntegerList = TList<Integer>;

Type TIntegerListHelper = Class Helper for TIntegerList
     public
       Function  ToString : String;
     end;

Function  TIntegerListHelper.ToString : String;
Var
  i : Integer;
begin
  Result := '[';
  for i := 0 to Count-1 do
  begin
    Result := Result + Items[i].ToString;
    if (i<Count-1) then Result := Result + ', ';
  end;
  Result := Result + ']';
end;

Procedure AddToIntegerList(Var IntegerList:TIntegerList; aString:String);
Var
  StringArray : TArray<string>;
  i : integer;
  Value : Integer;
begin
  StringArray := aString.Split([',']);
  for I := 0 to High(StringArray) do
  begin
    Value := StrToInt(StringArray[i]);
    if (IntegerList.IndexOf(Value)=-1)
       then IntegerList.Add(Value);
  end;
end;

Procedure CreateIntegerList;
Var IntegerList : TIntegerList;
begin
  IntegerList := TIntegerList.Create;
  AddToIntegerList(IntegerList,'1,2,4,6,9');
  AddToIntegerList(IntegerList,'1,3,6,9,10,11');
  AddToIntegerList(IntegerList,'2,3,4,9,10');
  IntegerList.Sort;
  Writeln(IntegerList.ToString);
  IntegerList.Free;
end;

Die Ausgabe sieht dann wie folgt aus:

Code:

[1, 2, 3, 4, 6, 9, 10, 11]

Eventuell noch eine try .. except um StrToInt, wenn Du dir nicht sicher bist, dass nur Zahlen im String sind.

[Uwe Raabe]

Ich hätte auch noch eine Alternative basierend auf einer gepimpten TStringList, die im Wesentlichen auf dem bisher gesagten aufbaut:

Delphi-Quellcode:

type
  TNumberStringList = class(TStringList)
  protected
    function CompareStrings(const S1: string; const S2: string): Integer; override;
  public
    constructor Create;
    procedure AddNumbers(const ACommaText: string);
  end;

constructor TNumberStringList.Create;
begin
  inherited Create(dupIgnore, True, True);
end;

procedure TNumberStringList.AddNumbers(const ACommaText: string);
begin
  AddStrings(ACommaText.Split([',']));
end;

function TNumberStringList.CompareStrings(const S1, S2: string): Integer;
begin
  Result := string.Compare(S1, S2, [TCompareOption.coDigitAsNumbers]);
end;

procedure TestNumberStringList;
var
  String1: string;
  String2: string;
  String3: string;
begin
  String1 := '1,2,4,6,9';
  String2 := '1,3,6,9,10,11';
  String3 := '2,3,4,9,10';
  var lst := TNumberStringList.Create;
  try
    lst.AddNumbers(String1);
    lst.AddNumbers(String2);
    lst.AddNumbers(String3);
    var S := lst.CommaText;
    Assert(S = '1,2,3,4,6,9,10,11');
  finally
    lst.Free;
  end;
end;

Zur Erklärung:

• Mit dem dupIgnore, True im Create werden erst gar eine Doubletten hinzugefügt (das zweite True für CaseSensitive ist hier redundant)
• Das coDigitAsNumbers im CompareStrings sorgt für eine korrekte Sortierung der Zahlen
• Das AddNumbers vereinfacht das Hinzufügen der einzelnen Listen

Der obige Ansatz funktioniert auch wenn nicht nur Zahlen vorkommen. In dem Fall wäre der CaseSensitive Parameter im Create aber vielleicht doch relevant.

[generic]

Uwe super elegante Lösung! Meine Lösung hätte ähnlich ausgesehen, nur nicht so geschickt mit den Sortieren.
Super mit dem unittest.

[Blup]

Eine Lösung die die Reihenfolge der Elemente nicht tauscht und auch mit einzelnen Wörtern klar kommt:

Delphi-Quellcode:

function ContainsElement(const AContainer, AElement: string): Boolean;
begin
  for var lItem in AContainer.Split([',']) do
  begin
    if lItem = AElement then
      Exit(True);
  end;
  Result := False;
end;

procedure AddElement(var AContainer: string; const AElement: string);
begin
  if not ContainsElement(AContainer, AElement) then
    AContainer := AContainer + ',' + AElement;
end;

procedure AddElementList(var AContainer: string; const AList: string);
begin
  for var lItem in AList.Split([',']) do
    AddElement(AContainer, lItem);
end;

var s1 := '1,2,4';
const s2 = 'Test,3,2,4,5';

AddElementList(s1, s2);
Assert(s1 = '1,2,4,Test,3,5');

[himitsu]

Delphi-Quellcode:

ContainsElement(Container, Element)
ContainsStr(',' + Element + ',', ',' + Container + ',')
MatchStr(Element, Container.Split([',']))
...

bzw.

Delphi-Quellcode:

// Contains
if MatchStr(Element, ContainerArray) then

// Add
if not MatchStr(Element, ContainerArray) then
  ContainerArray := ContainerArray + [Element];  // oder Insert()

// Remove
var i := IndexStr(Element, ContainerArray);
if i >= 0 then
  Delete(ContainerArray, i);

// AsString
S := string.Join(',', ContainerArray);