delphi的StringList类真好用啊 试着用java写了一个

package com.zhao_yi.sysutils.classes;

import java.util.List;
import java.util.ArrayList;
import java.util.StringTokenizer;
import com.zhao_yi.sysutils.SysUtil;
import com.zhao_yi.sysutils.*;
import java.util.Arrays;
import java.util.*;

public class StringList {
  private List strings = new ArrayList();
  private List objects = new ArrayList();
  private boolean sorted = false;

  public StringList() {
  }

  public String[] getStrings() {
    return (String[])strings.toArray(new String[strings.size()]);
  }

  public void setStrings(String[] array){
    strings = null; objects=null;
    strings = new ArrayList(Arrays.asList(array));
    objects = new ArrayList(array.length);
  }

  private void rangeCheck(int Index) throws IndexOutOfBoundsException {
    if ((Index < 0) || (Index >= getCount()))
      throw new IndexOutOfBoundsException();
  }

  public int getCount() {
    return strings.size();
  }

  public String Get(int Index){
    return (String) strings.get(Index);
  }

  public int Find(String S) {
    int I, L, H, C;
    L = 0;
    H = getCount() - 1;
    while (L <= H) {
      I = (L + H) / 2;
      C = SysUtil.CompareStrings(Get(I), S);
      if (C < 0)
        L = I + 1;
      else {
        H = I - 1;
        if (C == 0)
          L = I;
      }
    }
    return L;
  }

  public int AddObject(String S, Object AObject) {
    int Result = -1;
    if (!sorted)
      Result = getCount();
    else
      Result = Find(S);
    InsertItem(Result, S, AObject);
    return Result;
  }

  public int Add(String S) {
    return AddObject(S, null);
  }

  public void AddStrings(StringList Strings) {
    for (int i = 0; i < Strings.getCount(); i++)
      Add(Strings.Get(i));
  }

  public void AddStrings(String[] Strings) {
    for (int i = 0; i < Strings.length; i++)
      Add(Strings[i]);
  }

  public void Clear() {
    strings.clear();
    objects.clear();
  }

  public void Delete(int Index){
    strings.remove(Index);
    objects.remove(Index);
  }

  public void InsertItem(int Index, String S, Object AObject) {
    strings.add(Index, S);
    objects.add(Index, AObject);
  }

  public void Put(int Index, String S) throws IllegalStateException{
    if (this.sorted)
      throw new IllegalStateException("list sorted!");
    else
      strings.set(Index, S);
  }

  public void PutObject(int Index, Object AObject) {
    objects.set(Index, AObject);
  }

  public void Exchange(int Index1, int Index2) {
    Object temp = null;
    temp = strings.get(Index1);
    strings.set(Index1, strings.get(Index2));
    strings.set(Index2, temp);
    temp = objects.get(Index1);
    objects.set(Index1, objects.get(Index2));
    objects.set(Index2, temp);
  }

  public void QuickSort(int L, int R) {
    if (L < R) {
      int i = L;
      int j = R;
      String S = Get(L);
      while (i < j) {
        while (SysUtil.CompareStrings(Get(i), S) <= 0)
          i++;
        while (SysUtil.CompareStrings(Get(j), S) > 0)
          j--;
        if (i < j)
          Exchange(i, j);
      }
      Exchange(i, L);
      if (L < j)
        QuickSort(L, j);
      if (i < R)
        QuickSort(i, R);
    }
  }

  public void SetSorted(boolean value) {
    if (value != sorted) {
      if (value)
        QuickSort(0, getCount() - 1);
      sorted = value;
    }
  }

  public int IndexOf(String S) {
    return strings.indexOf(S);
  }

  public String getTextStr() {
    StringBuffer Result = new StringBuffer();
    for (int i = 0; i < strings.size(); i++) {
      Result.append(Get(i));
      Result.append(Systems.lineseparator);
    }
    return Result.toString();
  }

  public void setTextStr(String value) {
    Clear();
    StringTokenizer tokenizer = new StringTokenizer(value, Systems.lineseparator);
    while (tokenizer.hasMoreTokens())
      Add(tokenizer.nextToken());
  }

}