Home / Questions / 316439
Accepted
x3k
Asked: 2020-12-17 04:05:51 +0800 CST 2020-12-17 04:05:51 +0800 CST

Why does List <Long> contains return false?

  • 772

When checking if my list that is returned from a DB query contains a number with .contains()it returns false.

Return false:

System.out.println(listaBd);      // Output:[1, 2]
listaBd.contains(Long.valueOf(1)) // False

The problem does not seem from the code but from the list, since if I create the list by hand it returns true.

List <Long> listaLong = new ArrayList();
listaLong.add(1L);
listaLong.add(2L);
System.out.println(listaLong);      // Output:[1, 2]
listaLong.contains(Long.valueOf(1)) // True

I get the list as follows:

List<Long> results = new ArrayList<Long>();
results = (List<Long>)QueryUtil.list(query, getDialect(), -1, -1); //Liferay

And from what I understand, if it does not give any exceptionwhen casting it, it is because they are Longsvalid

The queryis something like this very simplified (with lots of joins and wheres that I'm going to exclude):

select idIdioma
from mitable;

idIdiomais one fkof a kindNUMBER(10,0)

java

2 Answers

  1. Best Answer

    EDIT: After this back and forth of comments, the answer to the main question of why the contains method returns false is definitely, because the list appears to be of Longs but it doesn't contain Longs, but another numeric type which turned out to be BigDecimal .

    listWe have seen that the class method returns in its specification a QueryUtil, and in its implementation it returns aLifeRayList<?>ArrayList<Object>

    What is happening here is that by doing this:

    List<Long> results = (List<Long>) QueryUtil.list(query, getDialect(), -1, -1);

    The list of Objectsis cast to a list of Longs, but it doesn't really contain Longs, but BigDecimals. Here the OP asks in the comment why the compiler allows this, we see it below.

    The thing is that we have a list that contains objects that are not Longs, but BigDecimal. When doing:

    System.out.println(results);

    Effectively, it prints [1, 2]what would be the result of executing toString()each element of the list. It will paint the same for us if the list were of Integers, of Longs, even Stringsif they contain a number with a string. This is where the delusion is where we have stung, that we have assumed that 1 and 2 were Longswhen it could be something else.

    Finally, when doing

    results.contains(Long.valueOf(1));

    When comparing an object of type BigDecimal, with an object of type Long, it returns falseeven if they have the same numeric value.

    Now, to the question of why the compiler allows that cast, it's because a list of Objectis compatible with a list of Longswhen casting . In this case the compiler knows that there is a list of objects and we "tell" it in this case we "lie" saying that it is a list of Longs. This itself is not illegal in Java, we are casting from one class Listto another List. Now, when we do a cast, we lose the right to have the compiler give us a compile-time error if the types don't match, and if this happens, we end up with a runtime error.

    In this case, you didn't even get an error at runtime, because the method containsaccepts a Object. If the interface Listwere defined like this:

    public interface List<T> {
   // public boolean contains(Object input); --> Así está definido realmente
   public boolean contains(T input);
}

    Yes, it would fail at runtime, because containsyour list method Longswould expect an object of type Longas a parameter, and would be receiving a BigDecimal.

    Also note that casting of List<Object>a List<Long>is supported, but this code does not compile:

        List<BigDecimal> listaBig = new ArrayList<BigDecimal>();
    List<Long> listaLong = (List<Long>) listaBig;

    Finally, the solution to the initial problem is the following as indicated by @David DPG:

    The solution was to go through the raw list of Objects, cast them one by one to Long with ((BigDecimal) results.get(i)).longValue()and add them to a new list, already clean and well parameterized.

    This is the first thing I had written for reference:

    I have looked at the doc for QueryUtil.list: https://github.com/liferay/liferay-portal/blob/master/portal-kernel/src/com/liferay/portal/kernel/dao/orm/QueryUtil.java (line 87) and the list it returns is an ArrayList of Objects.

    It occurs to me that the list is really a list Integerthat has 1 and 2 as integers, and then containsreturns false, since the 1integer does not match the 1L.

    I paste a code where this happens:

    public static void main(String[] args) throws Exception {
    Object x = new ArrayList<Object>();
    ((List<Integer>) x).add(1);
    ((List<Integer>) x).add(2);
    List<Long> y = (List<Long>) x;
    System.out.println(y); // Escribe [1, 2]
    System.out.println(y.contains(Long.valueOf(1))); // Escribe false!
}
    • 16

  2. Although you have already found the cause, I think it is convenient to clarify that: At compile time, the compiler allows to cast the List of Object to a List of Long because they are compatible. However, after compiling, due to type erasure Java will work with untyped List ; so when adding the values ​​to the list you are not "forced" to use the Long type. That is why it does not give an execution error when it decides to add the information retrieved from the DB as BigDecimal.

    • 2