CODEWITHSUNDEEP
javaarraysarraylist
user10274438
user10274438

Reputation: 123

How can I tell if the elements in an Array List are same or different?

I'm trying to verify if all the elements in an array list are same or not. This is my code: 

ArrayList<Integer> arr = new ArrayList<>(Arrays.asList(2,2,4,2));
for (int z = 0; z < arr.size(); z++) {          
    if(!arr.get(z++).equals(arr.get(z--))) {
        System.out.println("same"); 
    }else {
        System.out.println("differnt");         
    }
}

Upvotes: 5

Views: 1580

Answers (10)

GhostCat
GhostCat

Reputation: 140427

If you want to ensure that the list contains at least two different elements, you have to "walk" the array once: you compare the first element against all others, and stop on the first mismatch. On mismatch: not all elements are the same, otherwise they are all the same!

But the initial question was a bit unclear. If you want to determine if there are no two equal elements in the array, you have to compare all entries against all others! Then you need two loops: you pick all elemenst in order, to compare them to all others (respectively to all following ones: you already compared slot 1 to all other slots, so you would only have to compare slot 2 to slot3 ... til end).

Another approach would be to use a Set implementation, for example HashSet! Sets have unique members. So when you turn your list into a set, and the set has less entries than the list, you know that the list contains duplicates.

Upvotes: 2

Dumidu Udayanga
Dumidu Udayanga

Reputation: 914

. . . and does your code work? What sort of output do you get? Are you suffering any exceptions? Don't declare your List as ArrayList; declare it as List. Don't call a List arr; it isn't an array. Call it numbers or something like that. Why have you got the bang sign/not operator in line 3? I think that shouldn't be there. If you think about the different kinds of collection/data structure available, which you can read about here, you will find a collection type whose size() method will tell you how many distinct elements you have.

Upvotes: 4

Marco13
Marco13

Reputation: 54639

Put the elements into a Set. If the resulting set has a size of 1, then all elements have been the same. One line of code, no loops, no indices, works with every collection:

boolean allTheSame = new HashSet<Integer>(list).size() == 1;
System.out.println(allTheSame ? "same" : "different");

(Edited:)

It might be worth noting that if the list is large, and likely contains many different elements, then constructing a Set will impose some memory overhead that can be avoided, if desired. In this case, you'd iterate over the list and compare all elements to the first one. But you should not check the elements for identity with ==. Instead, you should compare them using their equals method, or, if you graciously want to handle null entries, using Objects#equals.

An example of how to solve this efficiently and generically is given in the answer by Zabuza

Upvotes: 12

abdulwasey20
abdulwasey20

Reputation: 837

You will have to check for each element, if all the elements on later indexes are same as that one or different than it. You can do it using a nested loop like this:

public static void main(String[] args) {
    // write your code here
        ArrayList<Integer> arr = new ArrayList<Integer>(Arrays.asList(2,2,4,2));
        boolean result=true;
        for (int i = 0; i < arr.size(); i++) {
            for (int j=i; j<arr.size(); j++){
                if (!arr.get(i).equals(arr.get(j))){
                    result=false;
                }
            }
        }
        System.out.println(result);
    }

the 2nd loop starts from j=i and goes till the right end of the array because you don't need to check the left side of that index as it is already checked in the previous iterations and the result would already have been updated to false.

Upvotes: 3

Aayush Sahu
Aayush Sahu

Reputation: 136

same is a flag that stores the result we intend.
uv is the uniformality variable.
Object is the type of object you stored in list (the arraylist)

import java.util.*; 
class Main{
    public static void main(String args[]){
        ArrayList<Integer> arr = new ArrayList<>(Arrays.asList(2,2,2,2));
        boolean same=true;
        Object uv=arr.get(0);
        for (Object i: arr){
            if(!i.equals(uv)){
                same=false;
                break;
            }   
        }
        System.out.print("Result:"+same);
    } 
}

Upvotes: 3

TongChen
TongChen

Reputation: 1430

A method use BitSet to judge are all elements in list is same or not,it need less memory and run faster.

public static boolean areAllElementsSame(List<Integer> numbers) {
    BitSet set = new BitSet();
    numbers.forEach(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) {
            set.set(integer);
        }
    });
    return set.cardinality() == 1;
}

This method can also used to figure out how many different elements.

Upvotes: 3

Zabuzard
Zabuzard

Reputation: 25903

There are various solutions to this.

Compare any with others

You just need to pick any element (the first, for example) and then compare this to all other elements. A single simple loop is enough:

public static <E> areElementsEquals(List<E> list) {
    // Edge cases
    if (list == null || list.size() <= 1) {
        return true;
    }

    // Pick any element
    E any = list.get(0);
    // Compare against others
    for (E other : list) {
        // Use Objects#equals for null-safety
        if (!Objects.equals(any, other)) {
            return false;
        }
    }
    return true;
}

Or a Stream-API version:

return list.stream()
    .allMatch(other -> Objects.equals(any, other));

If you checked that any is not null, you could also use a method reference:

return list.stream()
    .allMatch(any::equals);

Set

Sets do not have duplicates. You can put all your elements into a Set and check if the size is 1, then all other elements were duplicates.

return new HashSet<>(list).size() == 1;

While this code is pretty compact, I would favor the more straightforward solution of iterating. It is a bit more readable and also more efficient, since it does not have the additional overhead of setting up a set.

Upvotes: 6

forpas
forpas

Reputation: 164089

You only have to compare the 1st item against all the others:

int a = arr.get(0);
boolean allSame = true;
for (int z = 1; z < arr.size(); z++) {
    allSame = (a == arr.get(z));
    if (!allSame) break;
}

if (allSame)
    System.out.println("Same");
else
    System.out.println("Different");

Upvotes: 4

Cyril
Cyril

Reputation: 254

Try this :

String first = arr.get(0);
boolean allTheSame = true;
if (arr.size() > 1) {
    for (int z = 1; z < arr.size(); z++) {
        if (!arr.get(z).equals(first)) {
            allTheSame = false;
            break;
        }
    }
}

Upvotes: 3

Schidu Luca
Schidu Luca

Reputation: 3947

You just have to compare the current element with the next, if they are different that means you don't have all elements the same:

for(int i = 0; i < list.size() - 1; i++) {
        if (list.get(i) != list.get(i + 1)) {
            return false; // elements are different
        }
    }

return true; // all element are the same

Upvotes: 3

Related Questions