finding repeated combinations in a list - algorithm

Question

User enters Username, password and system generates unique field. Each username password combination along with an auto generated unique field is stored in a List as an object.
I want to find out if the username-password combination is repeated or not in the list (without considering the unique key).
I wanted to avoid using for loops to figure this out. Using hashmap to find out if there are repeated combinations-
//hm is the hashmap...
//up is the list....
for(int i=0; i<up.length(); i++){
if(hm.contains(up[i])){
System.out.println("Repeated combination");
break;
}
else{
hm.put(up[i],i);
}
}
However the object has a unique auto generated field and the above logic wouldn't work. Any suggestions to achieve this in the fastest possible way.

Answer 1

I assume that up[i] is some class(User) which has username, password and unique_id as three fields.
If that's true you can create wrapper around this class(UserWrapper) and override equals/hashCode methods to rely only on username/password attributes of User class.
That should be really quick to code/test
EDIT: Sample classes are below. You could you LinkedHashMap (so you'll have map functionality and still have users ordered in the same way as you put them in)
class User {
private final String id = UUID.randomUUID().toString();
private final String username;
private final String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
#Override
public boolean equals(Object obj) {
if (obj instanceof User) {
User user = (User) obj;
return id.equals(user.getId()) &&
username.equals(user.getUsername()) &&
password.equals(user.getPassword());
}
return false;
}
public int hashCode() {
return id.hashCode() + username.hashCode() * 31 + password.hashCode() * 31 * 31;
}
public String getId() {
return id;
}
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
}
Wrapper:
class UserWrapper {
private final User user;
public UserWrapper(User user) {
this.user = user;
}
#Override
public boolean equals(Object obj) {
if (obj instanceof UserWrapper) {
UserWrapper userWrapper = (UserWrapper) obj;
return user.getUsername().equals(userWrapper.getUser().getUsername()) &&
user.getPassword().equals(userWrapper.getUser().getPassword());
}
return false;
}
public int hashCode() {
return user.getUsername().hashCode() + user.getPassword().hashCode() * 31;
}
public User getUser() {
return user;
}
}
Finder:
class DuplicateUserFinder {
public List<UserWrapper> findDuplicates(List<UserWrapper> allUsers) {
final List<UserWrapper> duplicateList = new ArrayList<UserWrapper>();
final Set<UserWrapper> duplicateSet = new HashSet<UserWrapper>();
for (UserWrapper wrapper : allUsers) {
if (duplicateSet.contains(wrapper)) {
duplicateList.add(wrapper);
} else {
duplicateSet.add(wrapper);
}
}
return duplicateList;
}
}
Unit Test:
public class DuplicateUserFinderTest {
private final DuplicateUserFinder finder = new DuplicateUserFinder();
#Test
public void shouldReturnEmptyIfNoDuplicates() {
User user1 = new User("user1", "pass1");
User user2 = new User("user2", "pass2");
UserWrapper userWrapper1 = new UserWrapper(user1);
UserWrapper userWrapper2 = new UserWrapper(user2);
Assert.assertTrue(finder.findDuplicates(Arrays.asList(userWrapper1, userWrapper2)).isEmpty());
}
#Test
public void shouldReturnDuplicates() {
User user1 = new User("user", "pass");
User user2 = new User("user", "pass");
UserWrapper userWrapper1 = new UserWrapper(user1);
UserWrapper userWrapper2 = new UserWrapper(user2);
Assert.assertTrue(finder.findDuplicates(Arrays.asList(userWrapper1, userWrapper2)).contains(userWrapper2));
Assert.assertThat(finder.findDuplicates(Arrays.asList(userWrapper1, userWrapper2)).size(), CoreMatchers.equalTo(1));
}
}