Detect if ArrayList contains multiple instance of the same object

Question

I tried to detect if an ArrayList contains the same coppies of an object with no success. Here is my code;

public class Foo{
    int id;
    int name;

    @Override
    public boolean equals(Object o){
        Foo f = (Foo)o;
        return f.id==this.id;
    }

}

//in another class
ArrayList<Foo> foos;
...
boolean ifFoosListContainsMultipleFoo(Foo f){
    return foos.indexOf(f)!=foos.lastIndexOf(f);
}
//but this method always returns `false` even the `foos` list
//contains multiple object with the same `id`;

So, what am I doing wrong and is there a more optimal way of doing this?

Thanks in advance.

EDIT: I saw that I need to override hash method of the Foo class, then why equals function is not enough;

EDIT 2: Sorry for wasting your time but it was my mistake. There is no problem with my code, I used ifFoosListContainsMultipleFoo as !ifFoosListContainsMultipleFoo so this was result of false response.

Apologize me.

I'm not sure but don't you have to override hashCode method as well? — wawek
– wawek, Commented Sep 2, 2015 at 6:55
@wawek He is using an ArrayList and the implementation of the indexOf method does never use hashCode, only equals. — kai
– kai, Commented Sep 2, 2015 at 6:59
@ismail whether you really need to override hashcode or not depends on what kind of collection you are working with. But it's best practice to always implement equals if you implement hashCode, and the other way around too. — Simon
– Simon, Commented Sep 2, 2015 at 7:07

Codebender · Accepted Answer · 2015-09-02 07:01:42Z

4

Your code should work as it is, except in the case where f is not present in the list at all..

So you can do something like,

boolean ifFoosListContainsMultipleFoo(Foo f){
    return (foos.indexOf(f) != -1) && (foos.indexOf(f)!=foos.lastIndexOf(f));
}

answered Sep 2, 2015 at 7:01

Codebender

14.5k7 gold badges51 silver badges87 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Flown Over a year ago

Maybe store the first indexOf in a variable to spare one iteration through the list.

WilQu Over a year ago

Both methods will return -1 if the element is not present, so I think this is unnecessary.

Flown Over a year ago

In this state if the element is present the first index is computed twice.

Ismail Sahin Over a year ago

ohh @WilQu I didn't look it carefully but you are right in this query there is no need to check if list contains the element.

Codebender Over a year ago

@WilQu, yes... you are right... I am wondering why it's not working for the OP in that case...

Reut Sharabani · Accepted Answer · 2015-09-02 07:04:21Z

2

You can use a HashSet<Foo> to do this. You should override hashCode as well because HashSet uses hashes internally.

Set<Foo> set = new HashSet<Foo>(foos);
// check for duplicates
set.size() == foos.size();

You can also use the set manually which should let you retain the duplicates and can let you end the check sooner (instead of adding everything):

Set<Foo> set = new HashSet<Foo>();
// check for duplicates
for (Foo foo : foos){
    if (!set.contains(foo)){
        set.add(foo);
    } else {
        // do something with foo, which is a duplicate.
        // possibly end check for duplicates or store in a list
    }
}

answered Sep 2, 2015 at 7:04

Reut Sharabani

31.5k7 gold badges76 silver badges95 bronze badges

Collectives™ on Stack Overflow

Detect if ArrayList contains multiple instance of the same object

2 Answers 2

5 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related