Return same hashCode value for CaseInsensitive strings

[Vijay Kumar koganti]

Hi,

I have got two strings for ex: vijay & VIjay and when the hashcode of both the strings would be different. I would like to know how to make their hashcode values equal ie the case-sensitivity shouldn't have any affect on the hashcode value.

The requirement was driven by the fact that adding elements in the HashSet is allowing the duplicate values as it is treating the two strings for ex: vijay & VIjay are different and i need to override this behaviour.

Any idea how can i achieve this ?

regards,
vijay

[Jesper de Jong]

Note that only changing the hashCode() method would not be sufficient; you would also need to change the equals() method. HashSet uses both hashCode() and equals() to check if two objects contain the same value.

You can't change the hashCode() and equals() methods of class String. Instead of putting strings in your HashSet, create your own class that contains the names, and put that in your HashSet:

class Name {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int hashCode() {
        return name.toLowerCase().hashCode();
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof Name) return false;
        return name.toLowerCase().equals(((Name) obj).name.toLowerCase());
    }
}

[Vijay Kumar koganti]

Hi Jesper,

Thanks for your response. I am aware of overriding equals together with hashcode and i was using equalsIgnoreCase(Obj.getEmpname()) for that purpose instead of the one you mentioned
return name.toLowerCase().equals(((Name) obj).name.toLowerCase()).

But now i was surprised to see that incase of TreeSet it works just fine if you are overriding the CompareTo and then just comparing the two strings with name.CompareToIgnorecase(obj.getName) .To my understanding CompareTo is used only for the sorting of the set and the hashcode is not overridden it should have added the both strings into the set . Please find the code below.

 ublic class Book implements Comparable<Book>{
	
	public Book(int bookid, String bookname) {
		
		this.bookid = bookid;
		this.bookname = bookname;
	}
	private int bookid;
	private String bookname;
	
	public int getBookid() {
		return bookid;
	}
	public void setBookid(int bookid) {
		this.bookid = bookid;
	}
	public String getBookname() {
		return bookname;
	}
	public void setBookname(String bookname) {
		this.bookname = bookname;
	}
	public int compareTo(Book b) {
		// TODO Auto-generated method stub
		return bookname.compareToIgnoreCase(b.getBookname());
		
	}
	
 public String toString()
 {
	 return bookname;
 }
}   

public class TreesetCollection {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TreeSet<Book> booktree = new TreeSet<Book>();
		booktree.add(new Book(1,"geeta"));
		booktree.add(new Book(2,"sita"));
		booktree.add(new Book(3,"Geeta"));
		
		System.out.println("TreeSet Collection : "+ booktree);
		

	}

}

Expected End result is : TreeSet Collection : [Geeta,geeta, sita]

Actual Result is : TreeSet Collection : [geeta, sita]

can some one explain ?

vijay

[Henry Wong]

Actual Result is : TreeSet Collection : [geeta, sita]

can some one explain ?

What is there to explain? TreeSet uses the comparable (and comparator) to sort -- and to determine equality. You override the comparable interface, hence, it works. Did you expect it not to behave as overridden?

Henry

[Campbell Ritchie]

Have you read the HashSet and TreeSet documentation? It gives a brief hint how the two Set implementations work, and, once you understand that, it should explain about compareTo and equals/hashCode.

By the way: declare your TreeSet as Set<Book> booktree = new TreeSet<Book>();

[Vijay Kumar koganti]

Hi campbell/Henry,

Thanks for your reply. I was in a wrong impression that CompareTo/Compare are basically for the sorting and hashcode&equals for object equality irrespective of the type of collection.After reading the TreeSet documentation i realized that in case of Tree set the CompareTo/Compare does both sorting as well as Object equality.

regards,
vijay

[Vijay Kumar koganti]

Hi campbell/Henry,

One last question, so as discussed in the above posts TreeSet decides the equality and sorting using the Comparable/Comparator.In that case if i want to order books with names say (geeta,sita,Sita) and i want them to be ordered like [geeta,sita,Sita] how would i achieve this using TreeSet because making the compareTo to ignore the case would end up my Set having only two elements ??

 	Set<Book> booktree = new TreeSet<Book>();
		booktree.add(new Book(1,"geeta"));
		booktree.add(new Book(2,"sita"));
		booktree.add(new Book(3,"Sita"));
		
		//booktree.addAll(bookarray);
		
		System.out.println("TreeSet Collection : "+ booktree);  


public int compareTo(Book b) {
		// TODO Auto-generated method stub
		return bookname.compareTo(b.getBookname());
		
	}
 

[Campbell Ritchie]

You would have to design a Comparator which gives true alphabetical ordering. Do a search for "asciibetical" and you will find some useful information. Two threads which I just found doing such a search: No 1 No 2.

[Rob Spoor]

Jesper Young wrote:Note that only changing the hashCode() method would not be sufficient; you would also need to change the equals() method. HashSet uses both hashCode() and equals() to check if two objects contain the same value.

You can't change the hashCode() and equals() methods of class String. Instead of putting strings in your HashSet, create your own class that contains the names, and put that in your HashSet:

class Name {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int hashCode() {
        return name.toLowerCase().hashCode();
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof Name) return false;
        return name.toLowerCase().equals(((Name) obj).name.toLowerCase());
    }
}

I don't really like toLowerCase() or toUpperCase() as it potentially creates a new String. Instead, I use String.equalsIgnoreCase and my custom hashCodeIgnoreCase:

public static int hashCodeIgnoreCase(String s)
{
    return hashCodeIgnoreCase(s, 0);
}

public static int hashCodeIgnoreCase(String s, int def)
{
    if (s == null)
    {
        return def;
    }
    int hash = 0;
    int len = s.length();
    for (int i = 0; i < len; i++)
    {
        char c = Character.toUpperCase(s.charAt(i));
        hash = 31 * hash + c;
    }
    return hash;
}

This is exactly how String.hashCode works, with the exception of the Character.toUpperCase (which does not create a new object like s.toUpperCase).

[Vijay Kumar koganti]

Hi Campbell,

That's really a great knowledgeable post and thanks for the links.Good to learn some thing new before i go to sleep.

Good night guys.
vijay

[Campbell Ritchie]

Thank you and you're welcome But I learned lots from Rob's last post.

[Jesper de Jong]

Rob Prime wrote:I don't really like toLowerCase() or toUpperCase() as it potentially creates a new String.

Ok, but Java's garbage collector is very efficient at cleaning up short-lived objects such as those String objects that is only used to compare the strings or calculate the hashcode. I've been to a presentation where the presenter explained that, for example, people sometimes make their programs overcomplicated because they are afraid that creating a new object costs too much while it really isn't a problem. Java's garbage collector deals with short-lived and long-lived objects differently, and short-lived objects are cleaned up very quickly.

If your container object is immutable (as my class Name above is), then you could cache the hash code, so that you'd only have to calculate it once. Here's another version of class Name:

class Name {
    private String name;
    private Integer hash;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int hashCode() {
        if (hash == null) hash = name.toLowerCase().hashCode();
        return hash;
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof Name) return false;
        return name.equalsIgnoreCase(((Name) obj).name);
    }
}