如何找到不在数组列表中的数字？

Question

So I have a Arraylist. It is currently holding integers. I would like to get list of integers that are not in the arraylist from a certain range. For example if the range of numbers was from 1 to 5, if the arraylist contains 1,3,4 then the output should 2 and 5. The numbers stored in the ArrayList should also be unique hence I am thinking of using Hashset. This is my code so far:

HashSet<Integer> abc = new HashSet<>();
            while(myrs.next()){
                try {
                    //RoomIdsThatAreCurrentlyReserved.add(Integer.parseInt(myrs.getObject(1).toString()));
                    abc.add(Integer.parseInt(myrs.getObject(1).toString()));
                } catch (SQLException e) {
                    e.printStackTrace();

My code is basically reading from a result set.

Answer 1

With Eclipse Collections , the following will work using MutableSet . Using MutableSet here since you seem to be open for using Set .

MutableSet<Integer> set = Sets.mutable.with(1, 2, 3, 4, 5);
MutableSet<Integer> anotherSet = Sets.mutable.with(2, 3, 4);

MutableSet<Integer> result = set.difference(anotherSet);
System.out.println(result); //[1, 5]

Note: I am a committer for Eclipse Collections.

Answer 2

Here is simple example :

Arraylist a={1,2,3,4,5};
Arraylist b={2,3,4};

if you won't an output like 1 and 5 . then

simply used this:

List<Integer> c = new ArrayList<>(a);
c.removeAll(b);

Answer 3

Why don't you do like this,

 Iterator iterator = hashSet.iterator();

    while (iterator.hasNext()){
        int currentIteratorValue = (int) iterator.next();

        if(currentIteratorValue != 1 && currentIteratorValue != 3 && currentIteratorValue != 4){
            System.out.println(currentIteratorValue); //Prints 5 and 2
        }
    }

Answer 4

Using https://github.com/google/guava (java 1.6)

        List<Integer> fullList = Lists.newArrayList(1, 2, 3, 4 , 5);
        List<Integer> partOfList = Lists.newArrayList(1, 3, 4 );
        FluentIterable<Integer> missing = FluentIterable.from(fullList).filter(Predicates.not(Predicates.in(partOfList)));

Answer 5

It's a 1-liner.

Given:

List<Integer> list; // populated elsewhere
// copy to a set if the list is large so it will perform better
Set<Integer> set = new HashSet<>(list); 

Then:

List<Integer> missing = IntStream.range(a, b)
    .filter(i -> !set.contains(i))
    .collect(Collectors.toList());

If the list is small you can skip the set and just use

.filter(i -> !list.contains(i))

but that is O(n) whereas the set contains is O(1) .