StringBuffer and HashSet

Question

I've been using a HashSet to clear a String[] from duplicates. In the name of optimization I decided to use StringBuffer instead. This, however, made the removing of dublicates not possible. My question is obviously why, but also, is there a significant performance increase in using StringBuffer instead of string in the code below?
String[] getID() {
      StringBuffer idNr[]; //was string before...
      idNr = getDirectory(); //returns  a StringBuffer[] with values
      int underScoreStart;
      int underScoreEnd;
      for (int i = 0; i < idNr.length; i++) {
         underScoreStart = idNr.indexOf(dataSeparetor) + 1;
underScoreEnd = idNr[i].lastIndexOf(dataSeparetor);
idNr[i] = new StringBuffer(idNr[i].substring( underScoreStart, underScoreEnd));
java.util.HashSet sortSet = new java.util.HashSet();
for (int i=0; i <idNr.length; i++) {
sortSet.add(idNr[i]);
StringBuffer[] array; // was string before
int arrayIndex = 0;
array = new StringBuffer[sortSet.size()];
Iterator i = sortSet.iterator();
while(i.hasNext()) {
array[arrayIndex++] = (StringBuffer)i.next();
System.out.println(array[arrayIndex-1]);
StringBuffer tmp; //was string before
for(int j = 0; j < array.length; j++){                           
for (int l =0; l < (int)array.length -1; l++) {
if(Integer.valueOf(array[l].toString()).intValue()>Integer.valueOf(array[j].toString()).intValue()) {
tmp = array[l];
array[l] = array[l+1];
array[l+1] = tmp;
String returnString[] = new String[array.length];
for (int l=0; l < returnString.length; l++)
returnString[l] = array[l].toString();
return returnString;

Answer 1

Thanx for you reply. I have gone back to using String
when copying to the hashset and I have also replaced
my own sorting function with Arrays.sort... The code
looks as below now.
Why is there a performance loss when using string
buffer in the places I've indicated?Mainly because in a number of places String objects are created anyway and then you create StringBuffers copying the content of the String. If these StringBuffers are not used for editing their content then they are wasted space (in addition if you then need to use their String representation you've created yet another String object of the same content again). You also create many array objects which are abandoned - you can reduce this somewhat.
Here's what I think is a tidier solution returning a List of String objects rather than an array though the array is still trivial.
List getId() {
  String[] directory = getDirectory();
  Map workingMap = new HashMap();
  // Populate the map with the integer representations and String representations
  for(int count = 0; count < directory.length; count++) {
    int start = directory[count].indexOf(DATA_SEPARATOR) + 1;
    int end = directory[count].lastIndexOf(DATA_SEPARATOR);
    String s = directory[count].substring(start,end);
    Integer i = new Integer(s);
    workingMap.put(i,s);
  // Now we'll sort the keys and extract the values from the Map in order
  List list = new ArrayList(workingMap.keySet());
  Collections.sort(list);
  List results = new ArrayList(list.size());
  for(Iterator iterator = list.iterator(); iterator.hasNext(); ) {
    results.add(workingMap.get(iterator.next()));
  return results;
}Personally I'd simply return a list of Integer objects and convert back to String only if necessary. In which case the code is very simple.
List getId() {
  String[] directory = getDirectory();
  Set workingSet = new HashSet();
  for(int count = 0; count < directory.length; count++) {
    int start = directory[count].indexOf(DATA_SEPARATOR) + 1;
    int end = directory[count].lastIndexOf(DATA_SEPARATOR);
    Integer i = new Integer(directory[count].substring(start,end));
    workingSet.add(i);
  List results = new ArrayList(workingSet);
  Collections.sort(results);
  return results;
}NB: Yes I know SortedMap is available... yet another way to skin a cat.
Hope this helps
PS: Don't forget those Dukes...
Talden