Removing duplicate strings from an array?

1) I think you need to use the equals operator. Try

if (!wordList[i].equals(wordList[j])){

instead of !=.

2) Also Kevin is right. You need to set t back to false.

3) Side note as pointed out by others already: To be more efficient you should start the inner loop with

for (j = i+1; j < wordList.length; j++) {

4) Another side note: Your result array is still too long. If you don't want to use a List<String> and it is ok to loose the original array you could go with a solution as suggested by Zim-Zam O'Pootertoot and set the original duplicates to null, add a counter to count how many null values you assigned, initialize the new array with the correct size and loop a final time over the first array and copy only the non-null values into your new array.

If you are allowed to use Lists, you can define a generic method that does this fairly easily:

public <T> T[] removeDuplicates(final T[] array) {
    List<T> noDuplicates = new ArrayList<T>();
    for (T arrayElem : array) {
        if (!noDuplicates.contains(arrayElem)) {
            noDuplicates.add(arrayElem);
        }
    }
    return (T[]) noDuplicates.toArray();
}

You probably want to set t back to false after pulling the value you want:

if(t)
{
     wordList1[i]=wordList[i];
     t = false;
}

Also this:

if((wordList[i]!=wordList[j])&&(j>i))

Will always return true since strings are immutable (unless you compared a string to an exact reference of itself which you disallow with j>i). You need to change it to say this:

if (!(wordList[i].equals(wordList[j]))&&(j>i))

Using .equals will compared that they contain the same string, not that they point to the exact reference of a string.

Not sure if that's the only problems or not, a bit unclear from what's given.

In your inner loop, initialize j = i + 1

if(wordlist[i] != null && wordlist[i].equals(worldlist[j])) { wordlist[j] = null; }

...and then compact the array when you're finished to remove all null values

How about using a List:

wordList = outString.toString().split(", ");
List<String> finalList = new ArrayList<String>();
for(String val : wordList) {
  if(!finalList.contains(val)) {
    finalList.add(val);
  }
}

A Set would be more efficient, however. If you can't use a List or a Set, and you are forced to remove the duplicates, then you will have to loop through the array each time, which will perform horribly.

Iterate through the array, and store in an auxiliary int[] or List<Integer> the indexes of duplicates that you find with your two for's.

Create a new Array, with size equal to the original one minus the size of the repeated Strings.

Iterate through your original array, if the index isn't on your auxiliary list, set it to your new Array.

The best and most effective method is to suppose arr is the array that contains strings and can have duplicate values:

Arrays.sort(arr);
int l = 0;
for (int a = 0; a < arr.length; a++) {
    if (a == arr.length - 1)
        l++;// its a unique value
    else if (!(a[a + 1].equals(arr[a])))
        l++;// its also a unique
}
String newArray[] = new String[l];
l = 0;
for (int a = 0; a < arr.length; a++) {
    if (a == arr.length - 1)
        newArray[l] = arr[a];
    else if (!(a[a + 1].equals(arr[a]))) {
        newArray[l] = arr[a];
        l++;
    }
}

Try this...

public class RemoveDupsStringArray {

public static void main(String[] args) {
    String[] withDuplicates = new String[] {"one","one","two","three","one","three","three"};
    String[] withoutDuplicates = new String[] {"one","two","three"};

    removeDuplicates(withDuplicates);
    removeDuplicates(withoutDuplicates);
}

private static void removeDuplicates(String[] array) {
    int[] occurence = new int[array.length];
    for (int i = 0; i < array.length; i++) {
        for(int j=i+1;j<array.length;j++){
            if(array[i]==array[j]){
                occurence[j]=j;
            }
        }
    }
    int resultLength=0;
    for(int i=0;i<occurence.length;i++){
        if(occurence[i]==0){
            resultLength++;
        }
    }
    String[] result=new String[resultLength];
    int index=0;int j=0;
    for(int i=0;i<occurence.length;i++){
        index = occurence[i];
        if(index==0){
            result[j]= array[i];
            j++;
        }
    }

    for(String eachString : result){
        System.out.println(eachString);
    }
}
}