CareerCup

Using hash is not allowed whether your write your own hash function or you use the one available in the java collections.
Sorting seems fine but it gives you O(n* log n) complexity.
A better means would be to declare a 256-bit BitSet. The index of each of the slots of this bit array would represent the Ascii code.
Now we just traverse through the given string and change the bit value in the BitSet(givenString.charAt(i)) from 0 to 1.
If we confront a 1 instead of a 0 for a character then we return false.
If we successfully traverse the whole string it implies the string has all unique characters.
O(n) would be the time complexity for this.

Is sort permitted? If so, you can sort the string a first, and use this code to check duplicate chars:

public boolean hasUniqueChars(String a){
  for(int i=0; i< a.lenghth(); i++){
    if (a.charAt(i) == a.charAt(i+1)
       return false;
  }
  return true;
}

yes I did it by sorting as well !!

Sorting uses minimal of O(nlogn) Time Complexity.

Better use the hash to validate the uniqueness. its O(n) algo

Use an array of size 256 (assuming char is 1 byte). Use that as the hash table...

Sorting the string is the best option.
If changing the string not allowed, then u will have to store the sorted array using extra memory.

public static boolean isUniqueChars2(String str) {
 boolean[] char_set = new boolean[256];
 for (int i = 0; i < str.length(); i++) {
 int val = str.charAt(i);
 if (char_set[val]) return false;
 char_set[val] = true;
}
}

public static boolean hasUniqueChars(String s) {
		int[] char_set = new int[256];
		for(int i=0; i<s.length(); i++) {
			int index = s.charAt(i);
			char_set[index]++;
		}
		for(int i=0; i<char_set.length; i++) {
			if(char_set[i]>1) return false;
		}
		return true;

}

consider the unicode, I fix it:

public static boolean hasUniqueChars(String s) {
		int[] char_set = new int[65535];
		for(int i=0; i<s.length(); i++) {
			int index = s.charAt(i);
			char_set[index]++;
		}
		for(int i=0; i<char_set.length; i++) {
			if(char_set[i]>1) {
				return false;
			}
		}
		return true;

}