Java return an empty list

If you are using java 9 or later:

} else {
    return List.of();
}

If you are stuck with some version of java before 9:

} else { 
    return Collections.emptyList();
}

Notes:

1. These constructs are the most efficient, because they reuse an existing instance of an empty list, so each time you ask for an empty list, no new list gets created. However, object allocation in Java is very inexpensive, so this should not really be a concern.
2. The list returned by either List.of() or Collections.emptyList() is secretly immutable. By secretly I mean that it exposes mutation methods, but if you make the mistake of invoking any of those methods, you will be slapped with a runtime exception. In other, better languages than Java, (for example, in Scala,) there exist immutable / unmodifiable collections, but Java does not have such a thing out of the box. So, if you are sticking with Java in 2020, you are accepting the possibility that not all of your collections can be written to, despite the fact that they all look as if they can be written to.
3. In general, functions are meant to return immutable entities, so if you are invoking a function which returns a collection and then you intend to modify that collection, you are doing it wrong. If you really need a collection that you can modify, you should instead write your function so that it populates a mutable list that you pass to it as a parameter, so it is evident that you, as the owner of the mutable list, are free to further modify the list after the function returns.

Collections.emptyList() returns an immutable list, i.e., a list to which you cannot add elements if you want to perform any operation on your list, then create new instance of list and return it.

if (isValidLang(lang)) {
        query.setParameter("lang", lang);
        return query.getResultList();
    } else {
        return new ArrayList<Lookup>();  // return array list instance.
    }

With Java 9, you can now use the static factory method List::of to create an immutable empty list:

} else { 
    return List.of();
}

Try it like this:

public List<Lookup> findAll(String lang) {
    List<Lookup> result = new ArrayList<Lookup>();
    Query query = entityManager.createNamedQuery("Lookup.findAll");
    if (isValidLang(lang)) {
        query.setParameter("lang", lang);
        result = query.getResultList();
    }
    return result;
}

Using ternary operator (boolean_expression ? statement1 : statemetn2 ) in java we can check every return type whether it is null. If we do this once then every calling method using the code will be benefited because they do not have to check against null. Your code can be rewritten like this -

public List<Lookup> findAll(String lang) {
    Query query = entityManager.createNamedQuery("Lookup.findAll");
    ArrayList lookupList = null;

    if (isValidLang(lang)) {
        query.setParameter("lang", lang);
        lookupList = <ArrayList> query.getResultList();
    }

    return (null != lookupList ? lookupList : Collections.EMPTY_LIST);
}