java unchecked assignment collections.empty_list

Java – use Collections.EMPTY_LIST wihout an UncheckedException

generics java

Is there a Generics Friendly way of using Collection.EMPTY_LIST in my Java Program.

I know I could just declare one myself, but I'm just curious to know if there's a way in the JDK to do this.

Something like users = Collections<User>.EMPTY_LIST;

Best Answer

By doing the following:

The type of the returned list from Collections.emptyList(); will be inferred as a String due to the left-hand-side of the assignment. However, if you prefer to not have this inference, you can define it explicitly by doing the following:

In this particular instance, this may appear as redundant to most people (in fact, I've seen very little code out in the wild that makes use of explicit type arguments), however for a method with the signature: void doStuff(List<String> users) it would be perfectly clean for one to invoke doStuff() with an explicit type argument as follows:

Related Solutions

Java – how to round a number to n decimal places in java.

Use setRoundingMode , set the RoundingMode explicitly to handle your issue with the half-even round, then use the format pattern for your required output.

gives the output:

EDIT : The original answer does not address the accuracy of the double values. That is fine if you don't care much whether it rounds up or down. But if you want accurate rounding, then you need to take the expected accuracy of the values into account. Floating point values have a binary representation internally. That means that a value like 2.7735 does not actually have that exact value internally. It can be slightly larger or slightly smaller. If the internal value is slightly smaller, then it will not round up to 2.7740. To remedy that situation, you need to be aware of the accuracy of the values that you are working with, and add or subtract that value before rounding. For example, when you know that your values are accurate up to 6 digits, then to round half-way values up, add that accuracy to the value:

To round down, subtract the accuracy.

Java – Fastest way to determine if an integer’s square root is an integer

I figured out a method that works ~35% faster than your 6bits+Carmack+sqrt code, at least with my CPU (x86) and programming language (C/C++). Your results may vary, especially because I don't know how the Java factor will play out.

My approach is threefold:

• First, filter out obvious answers. This includes negative numbers and looking at the last 4 bits. (I found looking at the last six didn't help.) I also answer yes for 0. (In reading the code below, note that my input is int64 x .) if( x < 0 || (x&2) || ((x & 7) == 5) || ((x & 11) == 8) ) return false; if( x == 0 ) return true;
• Next, check if it's a square modulo 255 = 3 * 5 * 17. Because that's a product of three distinct primes, only about 1/8 of the residues mod 255 are squares. However, in my experience, calling the modulo operator (%) costs more than the benefit one gets, so I use bit tricks involving 255 = 2^8-1 to compute the residue. (For better or worse, I am not using the trick of reading individual bytes out of a word, only bitwise-and and shifts.) int64 y = x; y = (y & 4294967295LL) + (y >> 32); y = (y & 65535) + (y >> 16); y = (y & 255) + ((y >> 8) & 255) + (y >> 16); // At this point, y is between 0 and 511. More code can reduce it farther. To actually check if the residue is a square, I look up the answer in a precomputed table. if( bad255[y] ) return false; // However, I just use a table of size 512
• Finally, try to compute the square root using a method similar to Hensel's lemma . (I don't think it's applicable directly, but it works with some modifications.) Before doing that, I divide out all powers of 2 with a binary search: if((x & 4294967295LL) == 0) x >>= 32; if((x & 65535) == 0) x >>= 16; if((x & 255) == 0) x >>= 8; if((x & 15) == 0) x >>= 4; if((x & 3) == 0) x >>= 2; At this point, for our number to be a square, it must be 1 mod 8. if((x & 7) != 1) return false; The basic structure of Hensel's lemma is the following. (Note: untested code; if it doesn't work, try t=2 or 8.) int64 t = 4, r = 1; t <<= 1; r += ((x - r * r) & t) >> 1; t <<= 1; r += ((x - r * r) & t) >> 1; t <<= 1; r += ((x - r * r) & t) >> 1; // Repeat until t is 2^33 or so. Use a loop if you want. The idea is that at each iteration, you add one bit onto r, the "current" square root of x; each square root is accurate modulo a larger and larger power of 2, namely t/2. At the end, r and t/2-r will be square roots of x modulo t/2. (Note that if r is a square root of x, then so is -r. This is true even modulo numbers, but beware, modulo some numbers, things can have even more than 2 square roots; notably, this includes powers of 2.) Because our actual square root is less than 2^32, at that point we can actually just check if r or t/2-r are real square roots. In my actual code, I use the following modified loop: int64 r, t, z; r = start[(x >> 3) & 1023]; do { z = x - r * r; if( z == 0 ) return true; if( z < 0 ) return false; t = z & (-z); r += (z & t) >> 1; if( r > (t >> 1) ) r = t - r; } while( t <= (1LL << 33) ); The speedup here is obtained in three ways: precomputed start value (equivalent to ~10 iterations of the loop), earlier exit of the loop, and skipping some t values. For the last part, I look at z = r - x * x , and set t to be the largest power of 2 dividing z with a bit trick. This allows me to skip t values that wouldn't have affected the value of r anyway. The precomputed start value in my case picks out the "smallest positive" square root modulo 8192.

Even if this code doesn't work faster for you, I hope you enjoy some of the ideas it contains. Complete, tested code follows, including the precomputed tables.

Related Topic

• Java – When to use LinkedList over ArrayList in Java
• Java – What’s the simplest way to print a Java array
• Java: convert List to a join()d String
• Java – Is List a subclass of List ? Why are Java generics not implicitly polymorphic
• Java – How to avoid Java code in JSP files, using JSP 2
• Java – How to create a memory leak in Java
• Java – Can’t execute jar- file: “no main manifest attribute”
• Java – Proper use cases for Android UserManager.isUserAGoat()

• United States
• United Kingdom

By Dustin Marx , marxsoftware.blogspot.com |

A software developer's public collection of tips and tricks, real-world solutions, and industry commentary related to Java programming.

Type-safe Empty Collections in Java

I have blogged before on the utility of the Java Collections class and have specifically blogged on Using Collections Methods emptyList(), emptyMap(), and emptySet(). In this post, I look at the sometimes subtle but significant differences between using the relevant fields of the Collections class for accessing an empty collection versus using the relevant methods of the Collections class for accessing an empty collection.

The following code demonstrates accessing Collections 's fields directly to specify empty collections.

Using Collections's Fields for Empty Collections

The code above compiles with javac , but leads to the warning message (generated by NetBeans and Ant in this case):

Specifying -Xlint:unchecked as an argument to javac (in this case via the javac.compilerargs=-Xlint:unchecked in the NetBeans project.properties file) helps get more specific warning messages for the earlier listed code:

NetBeans will also show these warnings if the appropriate hint box is checked in its options. The next three images demonstrate ensuring that the appropriate hint is set to see these warnings in NetBeans and provides an example of how NetBeans presents the code shown above with warnings.

Fortunately, it is easy to take advantage of the utility of the Collections class and access empty collections in a typesafe manner that won't lead to these javac warnings and corresponding NetBeans hints. That approach is to use Collections 's methods rather than its fields . This is demonstrated in the next simple code listing.

Using Collections's Methods for Empty Collections

The above code will compile without warning and no NetBeans hints will be shown either. The Javadoc documentation for each field of the Collections class does not address why these warnings occur for the fields, but the documentation for each of the like-named methods does discuss this. Specifically, the documentation for Collections.emptyList() , Collections.emptySet() , and Collections.emptyMap() each state, "(Unlike this method, the field does not provide type safety.)"

Use of the Collections methods for empty collections shown in the last code listing provided type safety without the need to explicitly specify the types stored within that collection because type was inferred by use of the Collections methods in assignments to known and already declared instance attributes with explicitly specified element types. When type cannot be inferred, compiler errors will result when using the Collections methods without an explicitly specified type. This is shown in the next screen snapshot of attempting to do this in NetBeans.

The specific compiler error message is:

These compiler errors are avoided and type safety is achieved by explicitly specifying the types of the collections' elements in the code. This is shown in the next code listing.

Explicitly Specifying Element Types with Collections's Empty Methods

The Collections class's methods for obtaining empty collections are preferable to use of Collections 's similarly named fields for that same purpose because of the type safety the methods provide. This allows greater leveraging of Java's static type system, a key theme of books such as Effective Java . A nice side effect is the removal of cluttering warnings and marked NetBeans hints, but the more important result is better, safer code.

Original posting available at http://marxsoftware.blogspot.com/ (Inspired by Actual Events)

This story, "Type-safe Empty Collections in Java" was originally published by marxsoftware.blogspot.com .

Next read this:

• Why companies are leaving the cloud
• 5 easy ways to run an LLM locally
• Coding with AI: Tips and best practices from developers
• Meet Zig: The modern alternative to C
• What is generative AI? Artificial intelligence that creates
• The best open source software of 2023
• Development Tools

Dustin Marx is a principal software engineer and architect at Raytheon Company. His previous published work for JavaWorld includes Java and Flex articles and " More JSP best practices " (July 2003) and " JSP Best Practices" (November 2001).

Copyright © 2012 IDG Communications, Inc.

18 Java Collections and Generics Best Practices

1. Choosing the right collections

2. Always using interface type when declaring a collection

3. use generic type and diamond operator, 4. specify initial capacity of a collection if possible.

5. Prefer isEmpty() over size()

6. Do not return null in a method that returns a collection

7. do not use the classic for loop, 8. favor using foreach() with lambda expressions, 9. overriding equals() and hashcode() properly, 10. implementing the comparable interface properly, 11. using arrays and collections utility classes, 12. using the stream api on collections, 13. prefer concurrent collections over synchronized wrappers, 14. using third-party collections libraries, 15. eliminate unchecked warnings, 16. favor generic types, 17. favor generic methods, 18. using bounded wildcards to increase api flexibility, 1. choosing th e right colle ctions.

- Does it allow duplicate elements?

- Does it accept null?

- Does it allow accessing elements by index?

- Does it offer fast adding and fast removing elements?

- Does it support concurrency?

• Java List Tutorial
• Java Map Tutorial
• Java Queue Tutorial
• Java Set Tutorial

5 . Prefer isEmpty() over size()

- HashMap -> ConcurrentHashMap

- ArrayList -> CopyOnWriteArrayList

- TreeMap -> ConcurrentSkipListMap

- PriorityQueue -> PriorityBlockingQueue

- Fastutil : This library is a great choice for collections of primitive types like int or long . It’s also able to handle big collections with more than 2.1 billion elements (2^31) very well.

- Guava : This is Google core libraries for Java 6+. It contains a magnitude of convenient methods for creating collections, like fluent builders, as well as advanced collection types like HashBiMap , ArrayListMultimap , etc.

- Eclipse Collections : this library includes almost any collection you might need: primitive type collections, multimaps, bidirectional maps and so on.

- JCTools : this library provides Java concurrency tools for the JVM. It offers some concurrent data structures currently missing from the JDK such as advanced concurrent queues.

Other Java Collections Tutorial:

• Java Stream API Tutorial
• Understand equals and hashCode in Java
• Understand object ordering in Java
• How to write generic classes and methods in Java

About the Author:

Add comment

Notify me of follow-up comments

Comments  

Ace your Coding Interview

• DSA Problems
• Binary Tree
• Binary Search Tree
• Dynamic Programming
• Divide and Conquer
• Linked List
• Backtracking

Mutable, unmodifiable, and immutable empty Map in Java

This article will discuss different ways to create a mutable, unmodifiable, immutable, and fixed-length empty map in Java.

Mutable maps supports modification operations such as add, remove, and clear on it. Unmodifiable Maps are “read-only” wrappers over other maps. They do not support add, remove, and clear operations, but we can modify their underlying map. Maps that guarantee that no change in the map will ever be visible (even if their underlying map is modified) are referred to as immutable .

Please note that making a map final will not make it unmodifiable or immutable. We can still add key-value pairs or remove key-value pairs from them. Only the reference to the map is final.

1. Mutable Empty Map

⮚ Using Plain Java

We can simply use the HashMap constructor, which constructs an empty resizable-array implementation of the Map interface. The following code takes advantage of the new “diamond” syntax introduced in Java SE 7.

⮚ Using Guava

Guava’s Maps.newHashMap() creates a mutable, empty HashMap instance. This method is deprecated in Java 7 and above.

⮚ Java 8

We can use the Java 8 Stream to construct empty collections by combining stream factory methods and collectors. Collectors.toMap() returns a Collector that accumulates the input key-value pairs into a new Map. To create an empty map, we can pass an empty 2D array.

2. Unmodifiable Empty Map

⮚ Using Collections

Collections unmodifiableMap() returns an unmodifiable view of the specified map.

⮚ Using Apache Collections: MapUtils Class

Apache Commons Collections MapUtils.unmodifiableMap() returns an unmodifiable map backed by the specified map.

  Both the above methods throw a NullPointerException if the specified map is null. If we try to modify the returned map, the map will throw an UnsupportedOperationException . However, any changes in the original mutable map will be visible in the unmodifiable map.

3. Immutable Empty Map

There are several ways to create an immutable empty map in Java. The map will throw an UnsupportedOperationException if any modification operation is performed on it.

We can use Collections.EMPTY_MAP that returns a serializable and immutable empty map.

  The above method might throw an unchecked assignment warning. The following example demonstrates the type-safe way to obtain an empty map:

⮚ In Java 8

We could adapt the Collectors.toMap() collector discussed earlier to always produce an immutable empty map, as shown below:

Guava provides several static utility methods that can be used to obtain an immutable empty map.

1. ImmutableMap.copyOf returns an immutable empty map if specified map is empty.

  The method will throw a NullPointerException if the specified map is null, and any changes in the underlying mutable map will not be visible in the immutable map.

  2. Guava also provides a builder that can create an immutable empty map instance similarly.

  3. ImmutableMap.of() can also be used to return an immutable empty map.

⮚ Using Apache Collections

Apache Commons Collections provides MapUtils.EMPTY_MAP that returns an immutable empty map.

⮚ In Java 9

Java 9 comes with static factory methods on the Map interface that can create compact, unmodifiable instances.

We can use Map.of() to create the structurally immutable empty map. Keys and values cannot be added to it, and calling any mutator method will always cause UnsupportedOperationException to be thrown.

4. Fixed Length Empty Map

There is another type of empty map possible in Java apart from mutable, unmodifiable, and immutable maps called fixed-length map.

Apache Commons Collections MapUtils class has a fixedSizeMap() method that can return a fixed-length empty map backed by the specified empty map. We cannot add elements to the returned map, and the map will throw an UnsupportedOperationException if any resize operation is performed on it.

That’s all about mutable, unmodifiable, and immutable empty Map in Java.

Unmodifiable Map in Java

Mutable, unmodifiable, and immutable empty Set in Java

Mutable, unmodifiable, and immutable empty List in Java

Rate this post

Average rating 4.71 /5. Vote count: 7

No votes so far! Be the first to rate this post.

We are sorry that this post was not useful for you!

Tell us how we can improve this post?

Thanks for reading.

To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.

Like us? Refer us to your friends and support our growth. Happy coding :)

Software Engineer | Content Writer | 12+ years experience

IntelliJ IDEA 2024.1 Help

List of java inspections, abstraction issues, assignment issues, bitwise operation issues, class metrics, class structure.

Inspections labeled with *** are not available in the editor and can be launched via Code | Running Code Cleanup with profile ''{0}'' or Code | Analyze Code | Run Inspection By Name... .

Cloning issues

Code maturity, code style issues, compiler issues, concurrency annotation issues, control flow issues, declaration redundancy, dependency issues, encapsulation, error handling, finalization, inheritance issues, initialization, internationalization, j2me issues, java language level, java language level migration aids, javabeans issues, method metrics, modularization issues, naming conventions, numeric issues, packaging issues, performance, portability, probable bugs, nullability problems, properties files, reflective access, resource management, serialization issues, threading issues, tostring() issues, verbose or redundant code constructs.

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot
• DelayQueue Class in Java with Example
• Finding minimum and maximum element of a Collection in Java
• BlockingQueue Interface in Java
• Differences between wait() and join() methods in Java
• Differences between Dynamic Binding and Message Passing in Java
• Collection vs Collections in Java with Example
• Double Brace Initialization in Java
• Get first and last elements from ArrayList in Java
• Find common elements in two ArrayLists in Java
• Remove all elements from the ArrayList in Java
• Find first and last element of ArrayList in java
• LinkedHashMap and LinkedHashSet in Java
• Difference Between next() and hasNext() Method in Java Collections
• Difference Between ConcurrentHashMap and SynchronizedHashMap
• Difference Between Daemon Threads and User Threads In Java
• Difference Between Collection.stream().forEach() and Collection.forEach() in Java
• Difference between ArrayList and HashSet in Java
• Count number of a class objects created in Java
• LinkedTransferQueue getWaitingConsumerCount() method in Java with Examples

Non-generic Vs Generic Collection in Java

We will be discussing differences later prior let us understand what is generic Collection and non-generic Collection, and most importantly dealing with the implementation part as during implementation one can only really get the real understanding of the concept, henceforth the differences between them.

Generics are basically the errors appearing are compile-time than at run-time. there are certain advantages of generics over non-generic are as follows: 

• Code Reuse: With help of Generics, one needs to write a method/class/interface only once and use it for any type whereas, in non-generics, the code needs to be written again and again whenever needed.
• Type Safety: Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time).

Example: To create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, the compiler allows it. But, when this data is retrieved from ArrayList, it causes problems at runtime for Non-generic ArrayList

Implementation:

Output:  

How generics solve this problem?

If this list was made Generic, then it would take only String objects and threw Compile Time Error in any other case.

Now moving forward, Individual Type Casting is not needed.

If Generics is not needed, then, in the above example every time the data is to be retrieved from ArrayList, it needs to be typecasted. Typecasting at every retrieval operation is a big headache. This can be avoided if somehow it is already known that the list only holds string data.

Geek , now you should be wondering how generics solve this problem?

If this list was made Generic, then it would take only String objects and would return only String objects while retrieval. And hence individual typecasting won’t be required. The above statement is justified 

Note: With the help of generics, while one can implement algorithms Implementing generic algorithms, one can have t hat work on different types of objects and at the same they are type-safe too.

Do remember that there are some points, which will describe the difference between Generics and Non-Generic which are tabulated below in order to get a crisp understanding between them.  

Please Login to comment...

Similar reads.

• Java-Collections
• Technical Scripter 2018
• Difference Between
• Technical Scripter
• Google Releases ‘Prompting Guide’ With Tips For Gemini In Workspace
• Google Cloud Next 24 | Gmail Voice Input, Gemini for Google Chat, Meet ‘Translate for me,’ & More
• 10 Best Viber Alternatives for Better Communication
• 12 Best Database Management Software in 2024
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Unchecked assignment: ‘java.util.List’ to ‘java.util.Collection’

I am having an adapter where i have two lists one list is for InvestorsList where it comes with the list of investors and the other list is called investorListFull which is used to filter results when searching.

Below is how i have declared the lists

Below is how the lists are assigned in my recyclerview adapter constructor

Below is how i am filtering results in investors list

I am getting Unchecked assignment error in publish results investorList.addAll((List) filterResults.values);

Advertisement

I am getting Unchecked cast error in publish results investorList.addAll((List) filterResults.values);

That’s because you’re doing an unchecked cast. Actually, you’re doing both a checked and an unchecked cast there.

(List) filterResults.values is a checked cast. This means that the Java compiler will insert a checkcast instruction into the bytecode to ensure that filterResults.values (an Object ) really is an instance of List .

However, investorList.addAll expects a List<Investor> , not a List . List is a raw type . You can pass a raw-typed List to a method expecting a List<Something> ; but this is flagged as unsafe because the compiler can’t guarantee that it really is a List<Something> – there is nothing about the List that makes it a “list of Something “, because of type erasure. The compiler can insert a checkcast instruction to ensure it’s a List ; but not one to ensure it’s a List<Something> : this fact is unchecked .

What it’s saying with the warning is “there may be something wrong here; I just can’t prove it’s wrong”. If you know for sure – by construction – that filterResults.values really is a List<Investor> , casting it to List<Investor> is safe.

You should write the line as:

Note that this will still give you an unchecked cast warning, because it’s still an unchecked cast – you just avoid the use of raw types as well.

If you feel confident in suppressing the warning, declare a variable, so you can suppress the warning specifically on that variable, rather than having to add the suppression to the method or class; and document why it’s safe to suppress there:

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Unchecked assignment: 'java.util.List' to 'java.util.List<ua.lv.hoy.entity.Customer>' #184

ghost commented Feb 8, 2018

The text was updated successfully, but these errors were encountered:

halyafg commented Feb 10, 2018

Sorry, something went wrong.

ghost commented Feb 26, 2018

Halyafg commented feb 27, 2018.

No branches or pull requests