unchecked assignment 'java.util.hashmap'

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Workaround for unchecked cast of a deserialized Object to ArrayList<Vehicle>

For a class I was assigned to write code to read objects of the class Vehicle using ObjectInputStream ( in ). The objects are stored in an ArrayList called orders .

However, the compiler complains:

I always try to improve my code instead of ignoring or suppressing warnings. In this case, I have come up with a solution, but I'm trying to understand why it works, and if there is a better solution.

This update stops the warning:

Based on what I understand from what I've been reading, it works because (ArrayList<Vehicle>) obj may throw an exception if not all the elements are Vehicle . I am confused -- non-Vehicle objects can be added to the ArrayList even if its type parameter has been specified as Vehicle ? Also, is there a better solution, e.g. using instanceof ?

• serialization

• 2 \$\begingroup\$ You cannot casts a Collection with generics parameter since the at runtime the generics information is not available (due to generics erasure ) and therefore the JVM cannot check that all elements in that Collection to be of that generics type. \$\endgroup\$ –  Timothy Truckle Commented Dec 30, 2017 at 11:56

In general, the Java compiler knows the type of each variable, at every point during the execution. And when you operate on incompatible types, the program won't compile.

When you cast an object to ArrayList<Vehicle> , the Java runtime environment can only ensure that the cast to ArrayList<something> succeeds, but due to backwards compatibility (Java 1.4 from 2002), the cast will succeed, no matter if the arraylist contains Integer or String or Vehicle objects. Therefore, in this situation, the compiler warning tells you: Hey, you are doing something that cannot be checked, make sure you know what you are doing.

Your code that first deserializes the list as a raw type ( ArrayList instead of ArrayList<Vehicle> ) doesn't produce the compiler warning since the raw ArrayList is equivalent to ArrayList<Object> , and you won't get a surprising ClassCastException when working with this list.

If you are sure that the serialized list will only ever contain objects of type Vehicle , you can safely ignore that warning. In my code, I have written a utility function like this:

Another way is to not serialize the list, but to create a wrapper class:

When you serialize this class and deserialize it, you still have to cast the type using (SerializedData) in.readObject() , but the warning goes away.

This still doesn't guarantee that the vehicles list contains only vehicles after deserialization, but that is an entirely different problem.

Your Answer

Sign up or log in, post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged java serialization casting or ask your own question .

• Featured on Meta
• Announcing a change to the data-dump process
• We've made changes to our Terms of Service & Privacy Policy - July 2024

Hot Network Questions

• Is it safe to keep an expired credit card?
• Compact rotatable connection that supports pull forces?
• How can I make a PAL sync generator without a microcontroller?
• Plotting circle by center of circle and the radius in QGIS
• Is it a good practice to share a certificate between two applications
• What is/was float option n? Unknown float option `n'
• How does the grammar in 这不关你的事 work?
• ORCA 6 slower than ORCA 5?
• Is the universe accelerated expansion slowing down?
• Five numbers with median and mean
• Child's teddies "being mean" after dark
• preventing replay attacks if it is done by radio signals
• Is "Non-Trivial amount of work" a correct phrase?
• Jurisdiction: Can police officers open mail addressed to a stranger?
• How would tunneling mold tunnel?
• Efficient way to remove nailed-down plywood flooring in attic without damaging it?
• How to remove the circled numbers from the image and obtain an image without circled numbers?
• Please “weigh in” on my shelf weight question
• Do strawberry seeds have different DNA within the same fruit?
• ESTA renewal advice
• Can I replace this resistor (in USB adapter that plugs to mains) with this other resistor?
• What might be causing ls to ignore LS_COLORS for setgid (sg, g+s) directories?
• Why is the E in 'collega' long?
• Foundations and contradictions of Scholze's work: the category of presentable infinity categories contains itself

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

Converting Object To Map in Java

Last updated: January 8, 2024

• Map Conversions

Get non-trivial analysis (and trivial, too!) suggested right inside your IDE or Git platform so you can code smart, create more value, and stay confident when you push.

Get CodiumAI for free and become part of a community of over 280,000 developers who are already experiencing improved and quicker coding.

Write code that works the way you meant it to:

>> CodiumAI. Meaningful Code Tests for Busy Devs

Java applications have a notoriously slow startup and a long warmup time. The CRaC (Coordinated Restore at Checkpoint) project from OpenJDK can help improve these issues by creating a checkpoint with an application's peak performance and restoring an instance of the JVM to that point.

To take full advantage of this feature, BellSoft provides containers that are highly optimized for Java applications. These package Alpaquita Linux (a full-featured OS optimized for Java and cloud environment) and Liberica JDK (an open-source Java runtime based on OpenJDK).

These ready-to-use images allow us to easily integrate CRaC in a Spring Boot application:

Improve Java application performance with CRaC support

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page .

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page .

Whether you're just starting out or have years of experience, Spring Boot is obviously a great choice for building a web application.

Jmix builds on this highly powerful and mature Boot stack, allowing devs to build and deliver full-stack web applications without having to code the frontend. Quite flexibly as well, from simple web GUI CRUD applications to complex enterprise solutions.

Concretely, The Jmix Platform includes a framework built on top of Spring Boot, JPA, and Vaadin , and comes with Jmix Studio, an IntelliJ IDEA plugin equipped with a suite of developer productivity tools.

The platform comes with interconnected out-of-the-box add-ons for report generation, BPM, maps, instant web app generation from a DB, and quite a bit more:

>> Become an efficient full-stack developer with Jmix

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema .

The way it does all of that is by using a design model , a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

>> Take a look at DBSchema

Do JSON right with Jackson

Download the E-book

Get the most out of the Apache HTTP Client

Get Started with Apache Maven:

Working on getting your persistence layer right with Spring?

Explore the eBook

Building a REST API with Spring?

We’ve opened a new Java/Spring Course Team Lead position. Part-time and entirely remote, of course: Read More

Get started with Spring and Spring Boot, through the Learn Spring course:

Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:

>> The New “REST With Spring Boot”

Get started with Spring and Spring Boot, through the reference Learn Spring course:

>> LEARN SPRING

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI .

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code. And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI :

>> Install Machinet AI in your IntelliJ

Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.

I built the security material as two full courses - Core and OAuth , to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project .

You can explore the course here:

>> Learn Spring Security

Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot .

Get started with Spring Data JPA through the guided reference course:

>> CHECK OUT THE COURSE

1. Introduction

Converting an Object to a Map can be useful in Java when we seek to transform an object’s properties into a key-value representation. This can be very helpful, especially when dealing with data manipulation, serialization, or when we need to pass object data to other parts of our program.

In this tutorial, we’ll explore three different approaches to converting an Object to a Map in Java using reflection, Jackson, and Gson APIs.

2. Using Reflection

Reflection is a powerful feature in Java that allows us to inspect and manipulate classes, interfaces, fields, methods, and other components at runtime. Moreover, it provides the ability to access information about the structure of a class, invoke methods dynamically, and even modify private fields.

Below is a class named Employee , which represents an employee with a private name and salary, providing getters and setters to access and modify these attributes:

The following test method uses reflection to convert a Java object ( employee ) into a Map , using the object’s field names as keys, and their values as values:

In the above test, we handled the conversion process using a private method, convertUsingReflection , which accesses the object’s fields using the .getClass().getDeclaredFields().

What if we consider incorporating an Address object within the Employee  object?

This would allow us to associate each employee with their specific address information. However, it’s important to note that using reflection, a mechanism that dynamically provides access to object properties, might not function seamlessly in this context.

While we won’t delve into the specifics of resolving this issue, it’s worth mentioning the potential challenges of incorporating reflection when dealing with nested objects like ‘ Address’ within ‘ Employee.’

3. Using Jackson

When converting an Object into a Map , Jackson provides multiple approaches. Jackson is a versatile library renowned for its excellent support of various conversion types, such as JSON or XML .

The following example shows how we can convert a Java object ( employee ) into a map using Jackson:

In the above code, we used the ObjectMapper class from Jackson to perform the conversion by invoking the convertValue method. Furthermore, the resulting map has the employee object’s field names as keys and their corresponding values.

Here’s another example showcasing the Jackson library to transform a Java object ( employee ) into a map representation while dealing with nested objects like Address within Employee :

This test aims to serialize the values of the Address object using the JsonSerializer class. In this case, before serializing the Address object, the code performs an extra process. Apart from serializing the Address object, the code verifies whether the street and city values within the Employee object are consistent with the values stored in the nested map.

4. Using Gson

Gson is an alternative way to utilize the fromJson() method to convert an object to JSON, and then convert the JSON into a HashMap in a subsequent step.

The following test uses Gson to convert a Java object ( employee ) into a map:

As shown above, the conversion process involves serializing the employee object to a JSON string using the toJson method, and then de-serializing the JSON string into a map using the fromJson method.

Let’s consider another example where we utilize the Gson library to represent the Java object ( employee ) as a map handle in case of nested objects, such as the Address :

The above test checks if the street and city variables of the Address object match the values stored in a nested map under the key “ address. ”

5. Reflection vs. Jackson vs. Gson 

The following table summarizes the key differences between the three different approaches:

6. Conclusion

In this article, we explored various approaches, such as reflection, Jackson, and Gson, that enable us to convert Objects to Java Maps , facilitating seamless integration and manipulation of object data in diverse scenarios.

As always, the code is available over on GitHub .

Looking for the ideal Linux distro for running modern Spring apps in the cloud?

Meet Alpaquita Linux : lightweight, secure, and powerful enough to handle heavy workloads.

This distro is specifically designed for running Java apps . It builds upon Alpine and features significant enhancements to excel in high-density container environments while meeting enterprise-grade security standards.

Specifically, the container image size is ~30% smaller than standard options, and it consumes up to 30% less RAM:

>> Try Alpaquita Containers now.

Just published a new writeup on how to run a standard Java/Boot application as a Docker container, using the Liberica JDK on top of Alpaquita Linux:

>> Spring Boot Application on Liberica Runtime Container.

Explore the secure, reliable, and high-performance Test Execution Cloud built for scale. Right in your IDE:

Basically, write code that works the way you meant it to.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.

Get started with Spring Boot and with core Spring, through the Learn Spring course:

• 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
• Explore GfG Premium

HashMap in Java

• HashMap clear() Method in Java
• HashMap clone() Method in Java
• HashMap compute() method in Java with Examples
• HashMap containsKey() Method in Java
• HashMap containsValue() Method in Java
• HashMap entrySet() Method in Java
• HashMap get() Method in Java
• HashMap put() Method in Java
• HashMap putAll() Method in Java
• HashMap remove() Method in Java
• AbstractMap equals() Method in Java with Examples
• AbstractMap hashCode() Method in Java with Examples
• AbstractMap.SimpleEntry toString() Method in Java with Examples

Let us start with a simple Java code snippet that demonstrates how to create and use a HashMap in Java.

In Java, HashMap is a part of Java’s collection since Java 1.2. This class is found in java.util package. It provides the basic implementation of the Map interface of Java. HashMap in Java stores the data in (Key, Value) pairs, and you can access them by an index of another type (e.g. an Integer). One object is used as a key (index) to another object (value). If you try to insert the duplicate key in HashMap, it will replace the element of the corresponding key. 

• What is HashMap?

Java HashMap is similar to HashTable , but it is unsynchronized. It allows to store the null keys as well, but there should be only one null key object and there can be any number of null values. This class makes no guarantees as to the order of the map. To use this class and its methods, you need to import java.util.HashMap package or its superclass.

Table of Content

Java HashMap Examples

• HashMap Declaration
• Hierarchy of Java HashMap

Creating HashMap in Java

Java hashmap constructors, performing various operations on hashmap, complexity of hashmap in java, internal structure of hashmap.

• Advantages and Disadvantages of Java HashMap

Below is the implementation of an example of Java HashMap:

 HashMap Declaration:

Parameters:.

It takes two parameters namely as follows:

• The type of keys maintained by this map
• The type of mapped values

Note: K eys and value can’t be primitive datatype. Key in Hashmap is valid if it implements hashCode() and equals() method , it should also be immutable (immutable custom object ) so that hashcode and equality remains constant. Value in hashmap can be any wrapper class, custom objects, arrays, any reference type or even null . For example : Hashmap can have array as value but not as key.

HashMap in Java implements Serializable , Cloneable , Map<K, V> interfaces.Java HashMap extends AbstractMap<K, V> class. The direct subclasses are LinkedHashMap and PrinterStateReasons .

Hierarchy of HashMap in Java

Characteristics of Java HashMap:

A HashMap is a data structure that is used to store and retrieve values based on keys. Some of the key characteristics of a hashmap include:

• Fast access time : HashMaps provide constant time access to elements, which means that retrieval and insertion of elements are very fast, usually O(1) time complexity.
• Uses hashing function : HashMaps uses a hash function to map keys to indices in an array. This allows for a quick lookup of values based on keys.
• Stores key-value pairs: Each element in a HashMap consists of a key-value pair. The key is used to look up the associated value.
• Supports null keys and values : HashMaps allow for null values and keys. This means that a null key can be used to store a value, and a null value can be associated with a key.
• Not ordered: HashMaps are not ordered, which means that the order in which elements are added to the map is not preserved. However, LinkedHashMap is a variation of HashMap that preserves the insertion order.
• Allows duplicates : HashMaps allow for duplicate values, but not duplicate keys. If a duplicate key is added, the previous value associated with the key is overwritten.
• Thread-unsafe : HashMaps are not thread-safe, which means that if multiple threads access the same hashmap simultaneously, it can lead to data inconsistencies. If thread safety is required, ConcurrentHashMap can be used.
• Capacity and load factor : HashMaps have a capacity, which is the number of elements that it can hold, and a load factor, which is the measure of how full the hashmap can be before it is resized.

Let us understand how we can create and do some operations on HashMap in Java with an example mentioned below:

HashMap provides 4 constructors and the access modifier of each is public which are listed as follows:

• HashMap(int initialCapacity)
• HashMap(int initialCapacity, float loadFactor)
• HashMap(Map map)

Now discussing the above constructors one by one alongside implementing the same with help of clean Java programs.

1. HashMap()

It is the default constructor which creates an instance of HashMap with an initial capacity of 16 and a load factor of 0.75.

2. HashMap(int initialCapacity)

It creates a HashMap instance with a specified initial capacity and load factor of 0.75.

3. HashMap(int initialCapacity, float loadFactor)

It creates a HashMap instance with a specified initial capacity and specified load factor.

4. HashMap(Map map)

It creates an instance of HashMap with the same mappings as the specified map.

HashMap<K, V> hm = new HashMap<K, V>(Map map);

1. Adding Elements  in HashMap in Java

In order to add an element to the map, we can use the put() method. However, the insertion order is not retained in the Hashmap. Internally, for every element, a separate hash is generated and the elements are indexed based on this hash to make it more efficient.

2. Changing Elements in HashMap in Java

After adding the elements if we wish to change the element, it can be done by again adding the element with the put() method. Since the elements in the map are indexed using the keys, the value of the key can be changed by simply inserting the updated value for the key for which we wish to change.

3. Removing Element from Java HashMap

In order to remove an element from the Map, we can use the remove() method. This method takes the key value and removes the mapping for a key from this map if it is present in the map.

4. Traversal of Java HashMap

We can use the Iterator interface to traverse over any structure of the Collection Framework. Since Iterators work with one type of data we use Entry< ? , ? > to resolve the two separate types into a compatible format. Then using the next() method we print the entries of HashMap.

HashMap provides constant time complexity for basic operations, get and put if the hash function is properly written and it disperses the elements properly among the buckets. Iteration over HashMap depends on the capacity of HashMap and the number of key-value pairs. Basically, it is directly proportional to the capacity + size. Capacity is the number of buckets in HashMap. So it is not a good idea to keep a high number of buckets in HashMap initially.

Important Features of HashMap

To access a value one must know its key. HashMap is known as HashMap because it uses a technique called Hashing. Hashing is a technique of converting a large String to a small String that represents the same String. A shorter value helps in indexing and faster searches. HashSet also uses HashMap internally. A few important features of HashMap are: 

• HashMap is a part of java.util package.
• HashMap extends an abstract class AbstractMap which also provides an incomplete implementation of the Map interface.
• It also implements a Cloneable and Serializable interfaces. K and V in the above definition represent Key and Value respectively.
• HashMap doesn’t allow duplicate keys but allows duplicate values. That means A single key can’t contain more than 1 value but more than 1 key can contain a single value.
• HashMap allows a null key also but only once and multiple null values.
• This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time. It is roughly similar to HashTable but is unsynchronized.

Internally HashMap contains an array of Node and a node is represented as a class that contains 4 fields: 

It can be seen that the node is containing a reference to its own object. So it’s a linked list. 

Performance of HashMap

The performance of HashMap depends on 2 parameters which are named as follows:

• Initial Capacity
• Load Factor

1. Initial Capacity – It is the capacity of HashMap at the time of its creation (It is the number of buckets a HashMap can hold when the HashMap is instantiated). In java, it is 2^4=16 initially, meaning it can hold 16 key-value pairs. 2. Load Factor – It is the percent value of the capacity after which the capacity of Hashmap is to be increased (It is the percentage fill of buckets after which Rehashing takes place). In java, it is 0.75f by default, meaning the rehashing takes place after filling 75% of the capacity. 3. Threshold – It is the product of Load Factor and Initial Capacity. In java, by default, it is (16 * 0.75 = 12). That is, Rehashing takes place after inserting 12 key-value pairs into the HashMap. 4. Rehashing – It is the process of doubling the capacity of the HashMap after it reaches its Threshold. In java, HashMap continues to rehash(by default) in the following sequence – 2^4, 2^5, 2^6, 2^7, …. so on. 

If the initial capacity is kept higher then rehashing will never be done. But by keeping it higher increases the time complexity of iteration. So it should be chosen very cleverly to increase performance. The expected number of values should be taken into account to set the initial capacity. The most generally preferred load factor value is 0.75 which provides a good deal between time and space costs. The load factor’s value varies between 0 and 1. 

Note: From Java 8 onward, Java has started using Self Balancing BST instead of a linked list for chaining. The advantage of self-balancing bst is, we get the worst case (when every key maps to the same slot) search time is O(Log n). 

Synchronized HashMap

As it is told that HashMap is unsynchronized i.e. multiple threads can access it simultaneously. If multiple threads access this class simultaneously and at least one thread manipulates it structurally then it is necessary to make it synchronized externally. It is done by synchronizing some object which encapsulates the map. If No such object exists then it can be wrapped around Collections.synchronizedMap() to make HashMap synchronized and avoid accidental unsynchronized access. As in the following example: 

Now the Map m is synchronized.  Iterators of this class are fail-fast if any structure modification is done after the creation of the iterator, in any way except through the iterator’s remove method. In a failure of an iterator, it will throw ConcurrentModificationException.   Applications of HashMap: 

HashMap is mainly the implementation of hashing. It is useful when we need efficient implementation of search, insert and delete operations. Please refer to the applications of hashing for details.

Methods in HashMapassociate

• K – The type of the keys in the map.
• V – The type of values mapped in the map.

 Methods inherited from class java.util.AbstractMap

Methods inherited from interface java.util.Map

Advantages of Java HashMap

• Fast retrieval: HashMaps provide constant time access to elements, which means that retrieval and insertion of elements is very fast.
• Efficient storage : HashMaps use a hashing function to map keys to indices in an array. This allows for quick lookup of values based on keys, and efficient storage of data.
• Flexibility : HashMaps allow for null keys and values, and can store key-value pairs of any data type.
• Easy to use : HashMaps have a simple interface and can be easily implemented in Java.
• Suitable for large data sets : HashMaps can handle large data sets without slowing down.

Disadvantages of Java HashMap

• Unordered : HashMaps are not ordered, which means that the order in which elements are added to the map is not preserved.
• Not thread-safe : HashMaps are not thread-safe, which means that if multiple threads access the same hashmap simultaneously, it can lead to data inconsistencies.
• Performance can degrade : In some cases, if the hashing function is not properly implemented or if the load factor is too high, the performance of a HashMap can degrade.
• More complex than arrays or lists : HashMaps can be more complex to understand and use than simple arrays or lists, especially for beginners.
• Higher memory usage : Since HashMaps use an underlying array, they can use more memory than other data structures like arrays or lists. This can be a disadvantage if memory usage is a concern.
• Hashmap vs Treemap
• Hashmap vs HashTable
• Recent Articles on Java HashMap

FAQs on Java HashMap

Q. what is a hashmap in java.

HashMap in Java is the class from the collection framework that can store key-value pairs inside it.

Q. Why use HashMap in Java?

HashMap in Java is used for storing key-value pairs where each key is unique.

Q. What is the benefit of HashMap?

HashMap is used because of it provides features like: Fast retrieval Efficient storage Flexible to use Easy to use Suitable for large data sets

Please Login to comment...

Similar reads.

• Java - util package
• Java-Collections
• Java-HashMap

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Unchecked assignment:‘java.util.HashMap to xxx‘

 IDEA类型强制转换需要声明类型，new HashMap（）改为 new HashMap <> （）即可

或增加 @SuppressWarnings("unchecked") ，也是可以的 

请填写红包祝福语或标题

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

Navigation Menu

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 You must be signed in to change notification settings

Kotlin 2.0.0

Analysis. API

New features.

• KT-65327 Support reading klib contents in Analysis API

Performance Improvements

• KT-65560 K2: Anaysis API: ContextCollector triggers redundant resolution in the case of file elements
• KT-64987 Analysis API: 50GB memory allocation on creating empty kotlinx.collections.immutable.persistentMapOf
• KT-61789 K2: optimize getFirForNonKtFileElement for references inside super type reference
• KT-59498 K2: getOnAirGetTowerContextProvider took too much time due to on air resolve
• KT-61728 Analysis API: optimize AllCandidatesResolver.getAllCandidates
• KT-65561 Analysis API: dummy.kt is not a physical file
• KT-65616 K2: FirDeclarationStatusImpl cannot be cast to FirResolvedDeclarationStatus from STATUS
• KT-65600 Analysis Api: FirFile for KtCodeFragments are created and not updated on changes
• KT-64919 K2 IDE: Implement KMP support for sealed class inheritors
• KT-64241 K2: Unresolved calls to functions in scripts depending on included projects
• KT-65813 Analysis API Standalone: FirDeclarationForCompiledElementSearcher does not find compiled elements
• KT-66052 AA: render expect/actual modifier
• KT-66795 KtCodeFragment.clone() is broken
• KT-66532 K2 CodeGen AA: missing annotation setup for function in source module but not in a compile target file
• KT-64833 Analysis API: Members implemented by delegation have no overridden symbols
• KT-62405 Analysis API: Symbols SUBSTITUTION_OVERRIDE have no overridden symbols
• KT-66749 K2: "Collection contains no element matching the predicate" on an unresolved call
• KT-62832 K2: ClassCastException: FirDeclarationStatusImpl cannot be cast to FirResolvedDeclarationStatus
• KT-66719 AbstractGetKlibSourceFileNameTest: The dependency to ":native:analysis-api-klib-reader" breaks JPS compilation
• KT-66603 Analysis API: support type annotations in KtPsiTypeProviderMixIn#asPsiType
• KT-64505 Analysis API Standalone: Remove test-specific calculation of sealed class inheritors
• KT-66013 Analysis API Standalone: Sealed inheritors aren't correctly calculated for source classes
• KT-62880 K2 IDE: Unresolved java annotation methods in KDoc
• KT-66530 K2: Analysis API: KtPsiTypeProvider#asKtType crashes on PsiClassType for Java type parameter with wrong use site
• KT-65571 Support VirtualFile inputs to Analysis API modules
• KT-66485 Substituted types are not provided for callable references
• KT-66498 Analysis API: 'KtFe10SymbolDeclarationOverridesProvider' considers a class to be a subclass of itself
• KT-64579 K2 IDE: "Expected FirResolvedArgumentList for FirAnnotationCallImpl of FirValueParameterImpl(Source) but FirArgumentListImpl found"
• KT-65978 Analysis API: Use soft references in FileStructureCache
• KT-64051 K2 IDE: Analysis API: Unresolved links to typealias in KDoc
• KT-66189 K2 / IDE: KtFirExpressionTypeProvider bugs
• KT-61422 K2 IDE: "No array element type for vararg value parameter: org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl"
• KT-66276 K2: Analysis API: TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM false positive for script parameter
• KT-66232 K2: Analysis API: cover ScriptWithCustomDefDiagnosticsTestBaseGenerated by LL FIR tests
• KT-60996 K2: Stub Based Deserializer: Set versionRequirements to enable VERSION_REQUIREMENT_DEPRECATION diagnostics
• KT-66306 K2: Analysis API: drop ability to enable global phase resolve lock
• KT-55750 LL FIR: Implement multi-threaded resolve
• KT-65563 Analysis API: Missing session component FirExpectActualMatchingContextFactory in LLFirLibrarySession
• KT-66173 K2: No 'org.jetbrains.kotlin.fir.scopes.impl.FirDelegatedMembersFilter' in array owner: LLFirLibrarySession
• KT-66238 Gradle kotlin build scripts - a lot of unresolved symbols after latest changes in kotlin master
• KT-65099 K2: Recursive local storage cache check for Fir2IrDeclarationStorage::createAndCacheIrPropertySymbols()
• KT-65265 Analysis API: Add library session invalidation tests
• KT-56288 Analysis API: Add tests for session invalidation on the Analysis API side
• KT-64000 K2: make AnnotationArgumentsStateKeepers more accurate
• KT-63606 K2: Analysis API: rewrite FirLazyAnnotationTransformer to avoid redundant transformations
• KT-65191 KtFirMultiplatformInfoProvider#getExpectForActual doesn't return expect function for slightly broken code
• KT-62136 Analysis API: Add concurrent tests for CleanableSoftValueCache
• KT-61222 K2: Add lifecycle management for KtResolveExtension
• KT-65960 Analysis API: Test infrastructure indexes binary libraries from decompiled files instead of stubs during IDE mode tests
• KT-65240 K2: CodeGen API fails to resolve Annotation parameter type when it runs FIR2IR for a class with a parent class from other module if the parent class has an annotation from another module
• KT-65344 K2: make FirScript statements (declarations) independent
• KT-65930 AA: receiver type for Int?::foo misses nullability
• KT-65914 AA: receiver type for this::foo returns return type of the target callable
• KT-62071 Analysis API: KtFirScopeProvider.getScopeContextForPosition throws exception when ImplicitReceiverValue.implicitScope is null
• KT-65780 K2: polish FileStructure implementation for FirFile
• KT-62840 K2 Script: everything around destructuring declaration on top level of scripts are broken
• KT-64528 K2 IDE: MPP: unregistered component 'org.jetbrains.kotlin.fir.scopes.impl.FirDelegatedMembersFilter'
• KT-64921 K2 IDE: references in platform code resolve to expect classifier instead of actual
• KT-61296 K2: do not resolve the entire file on lazyResolve call if FirFile is passed
• KT-65683 Analysis API: Dangling file session creation causes a computeIfAbsent contract violation
• KT-64884 K2 IDE. FP [NAMED_PARAMETER_NOT_FOUND] for copy method of library data class when class has not parameter-properties
• KT-65763 K2: value parameter from library data class copy have RAW_FIR phase
• KT-65665 Analysis API: support KtDelegatedSuperTypeEntry in KtFirExpressionInfoProvider.isUsedAsExpression
• KT-62899 K2 IDE. IDE ignores @Suppress annotation for errors
• KT-65655 Analysis API: KtCodeCompilationException should not strongly reference FIR sessions
• KT-62302 Support PsiType -> KtType conversion
• KT-64604 K2: IDE K2: "Modules are inconsistent during performance tests"
• KT-65345 K2: unify FirDesignation and LLFirResolveTarget
• KT-61757 K2 IDE: resolution to buitlins does not work for from common module
• KT-65268 K2: Checking the presence of the delegated constructor call forces AST loading
• KT-63330 Analysis API: Stub-based deserialized symbol providers provide unresolved enum entry annotation arguments
• KT-65418 Analysis API: LLFirAbstractSessionFactory loads anchor module sessions eagerly
• KT-64718 Analysis API: do not expose SealedClassInheritorsProvider and FirRegularClass to IDE Plugin
• KT-65075 K2: getContainingDeclaration() is broken for declarations inside code fragments
• KT-61332 Support KtTypeCodeFragment in PsiRawFirBuilder
• KT-65150 AA: incorrect result from KtTypeProvider#getReceiverTypeForDoubleColonExpression for Java static method
• KT-56551 LL FIR: implement parallel resolve for jumping phases
• KT-65223 Psi: avoid KtFile usages
• KT-65307 Analysis API FE10: support KtFe10AnalysisSessionProvider.getAnalysisSessionByUseSiteKtModule
• KT-62695 K2 IDE: Unresolved extension functions in KDoc
• KT-65152 Analysis API: KDoc references to packages are not fully resolved
• KT-64988 K2 IDE: Navigation from the named argument in safe call does not work
• KT-63195 AA: incorrect results from KtTypeProvider#getReceiverTypeForDoubleColonExpression
• KT-64074 K2: Investigate LL divergence for Script.testTopLevelPropertyInitialization
• KT-62441 K2: IDE K2: "No dangling modifier found"
• KT-62895 K2 IDE. FP 'when' expression must be exhaustive with sealed interface from library
• KT-64993 Analysis API: KtExpressionTypeProvider.getExpectedType works incorrectly for arguments of safe calls
• KT-64883 Allow direct creation of KtCommonFile
• KT-64646 K2: properly forbid ast loading during raw fir phase in tests
• KT-64862 Psi: missed parenthesis in type reference presentation
• KT-62893 K2 IDE. FP 'when' expression must be exhaustive with Java sealed interface from library
• KT-63795 K2: lazyResolveToPhase(BODY_RESOLVE) cannot be called from a transformer with a phase BODY_RESOLVE from SealedClassInheritorsProviderIdeImpl
• KT-64805 Analysis API: introduce common entry point for multi-file test cases
• KT-64714 K2: Analysis API: CollectionsKt.map doesn't resolves from Java in kotlin repo
• KT-64647 K2: Allow to calculate decompiled inheritors for sealed classes in tests
• KT-64595 AA: stackoverflow while simplifying a type with a recursive type parameter
• KT-64825 Analysis API. Cannot compute containing PSI for unknown source kind 'org.jetbrains.kotlin.KtFakeSourceElementKind$DefaultAccessor' exception on getContainingSymbol call for default setter parameter
• KT-64080 K2: Analysis API: On-air resolve does not trigger resolution of delegated super call arguments
• KT-64243 K2: proper lazy resolution for fake overrides
• KT-62891 K2 IDE. FP [EXPOSED_FUNCTION_RETURN_TYPE] on overriding library method which returns protected type
• KT-62667 K2: Cannot find enclosing declaration for KtNameReferenceExpression (on-air, imports)
• KT-61890 Analysis API: Migrate KtFirScopeProvider to ContextCollector instead of onAirResolve
• KT-64197 K2: Code fragments are only supported in JVM
• KT-62357 K2 IDE. False positive on generated component methods and false negative on getter of @JvmRecord classes in Java
• KT-62892 K2 IDE. Java outer class from other module is not resolved when nested class is accessed with fq name in a type position
• KT-62888 K2 IDE. IDE infers reference to KMutableProperty as reference to just KProperty
• KT-64584 K2: StubBasedFirDeserializedSymbolProvider: support deserialization of delegated declarations
• KT-60324 K2 IDE: "NoSuchElementException: List is empty at JavaOverrideChecker#buildErasure"
• KT-62896 K2 IDE. FP ABSTRACT_MEMBER_NOT_IMPLEMENTED on inheriting class from library which implements interface by delegation
• KT-62947 Analysis API: Error while resolving FirPropertyImpl
• KT-64468 Analysis API: Implement mixed multi-module tests which support different kinds of KtModule s
• KT-56541 Symbol Light Classes: No @NotNull annotations are generated for accessors of lateinit properties of unresolved types
• KT-63547 K2 IDE. False Positive AMBIGUOUS_ANNOTATION_ARGUMENT
• KT-64205 Analysis API: Do not import non-top-level callables by default
• KT-63056 K2: Cannot mutate an immutable ImplicitReceiverValue on FirCodeFragment analysis
• KT-64108 K2: KtFirSymbolDeclarationOverridesProvider shouldn't provide fake overrides
• KT-63752 K2: java.lang.StackOverflowError FirFieldSymbol.getHasInitializer
• KT-63718 Analysis API: Stub-based dependency symbol providers of library source sessions compute the wrong package name sets
• KT-64225 K2: IDE K2: "FirLazyBlock should be calculated before accessing" in evaluate debuger completion
• KT-64186 Analysis API: ContextCollector provides incorrect scopes for anonymous objects
• KT-63979 K2 IDE: presentation of types in completion is too verbose
• KT-63681 K2: LL FIR: Improve isResolved check coverage of after lazy resolution
• KT-62982 K2: Cannot get a PSI element for 'Enum.values'
• KT-59732 FirLazyResolveContractViolationException: lazyResolveToPhase(IMPORTS) cannot be called from a transformer with a phase IMPORTS from serialisation plugin
• KT-62676 K2 IDE: Reference shortener does not recoginize redundant this references
• KT-63627 K2 IDE: shorten reference shortens required qualifier
• KT-62675 K2 IDE: Reference shortener does not recoginize redundant labels
• KT-60957 K2: Analysis API: Reference shortener does not work correctly with invoke function calls on properties
• KT-63771 fe10: KtNamedClassOrObjectSymbol#isInline does not cover value classes
• KT-60327 K2 IDE. "IllegalArgumentException: source must not be null" during delegation declaration
• KT-62421 K2: IDE K2: " lazyResolveToPhase(BODY_RESOLVE) cannot be called from a transformer with a phase BODY_RESOLVE."
• KT-62587 K2 IDE. FP unresolved reference on accessing nested class in annotation argument
• KT-63700 K2: "FirLazyExpression should be calculated before accessing" in the case of secondary constructor
• KT-61383 K2: 'KtCompilerFacility' fails on code fragment compilation in library sources with duplicated dependencies
• KT-62111 K2 IDE. IllegalArgumentException on for loop with iterator declaration attempt
• KT-63538 Analysis API: Removing a contract statement via PsiElement.delete() does not trigger an out-of-block modification
• KT-63694 K1/K2 IDE. "RuntimeException: Broken stub format, most likely version of kotlin.FILE (kotlin.FILE) was not updated after serialization changes" exception on incorrect class name
• KT-63660 K2: expect-actual gutter icons must be shown when declarations are matched but incompatible
• KT-63560 Analysis API: Modifiable PSI tests cannot rely on the cached application environment to allow write access
• KT-62980 Implement KtFirSimpleNameReference#getImportAlias
• KT-63130 Analysis API: No receiver found for broken code during commit document
• KT-62705 K2: "lazyResolveToPhase(IMPORTS) cannot be called..." from light classes
• KT-60170 K2 IDE: CCE from KtFirCallResolver on invalid code with wrong implicit invoke
• KT-61783 K2: Analyze 'KtCodeFragment' in a separate session
• KT-62010 K2: IDE K2: "ConeClassLikeTypeImpl is not resolved to symbol for on-error type"
• KT-62957 Analysis API: NullPointerException on call resolution when builtins are not available
• KT-61252 K2: IDE K2: "By now the annotations argument mapping should have been resolved"
• KT-62935 Analysis API: kotlin.Cloneable should not be available in Kotlin/Native sources
• KT-62910 Analysis API: create AbstractFirPsiNativeDiagnosticsTest for LL FIR
• KT-63096 K2: Analysis API: KotlinAnnotationsResolver for IDE is created with incorrect scope
• KT-62310 K2 IDE. False positives errors with external annotations
• KT-63282 K2 Script: annotation arguments phase should resolve propagated annotations
• KT-62397 K2 IDE. FP Error in the editor on RequiresOptIn annotation from the lib despite the warning level
• KT-63223 Analysis API: reference to declarations with kotlin* package are not resolved
• KT-62626 IllegalStateException: Cannot build symbol for class org.jetbrains.kotlin.psi.KtScriptInitializer
• KT-62693 K2: IDE K2: "PSI should present for declaration built by Kotlin code"
• KT-62674 K2: "Scope for type ConeClassLikeTypeImpl" is null from transitive dependencies
• KT-61889 Analysis API: Migrate KtFirReferenceShortener to ContextCollector instead of FirResolveContextCollector
• KT-62772 Analysis API: No 'org.jetbrains.kotlin.fir.java.FirSyntheticPropertiesStorage'(31) in array owner: LLFirSourcesSession when analysing builtins in a context of common code
• KT-60319 K2 IDE: "Stability for initialized variable always should be computable"
• KT-62859 K2 IDE: "Evaluate expression" throws exception when calling "Any?.toString()"
• KT-63058 K2 IDE: Code completion unexpectedly imports static/companion object method
• KT-62588 getExpectedType should not calculate type of the expression
• KT-61990 K2: Unexpected returnTypeRef for FirSyntheticProperty
• KT-62625 K2: 'FirLazyExpression should be calculated before accessing' for unresolved super type
• KT-62691 K2: optimize getFirForNonKtFileElement for references inside 'where'
• KT-62834 K2: missing file node level in control flow builder
• KT-62768 Analysis API: No 'org.jetbrains.kotlin.fir.scopes.impl.FirDelegatedMembersFilter'(44) in array owner: LLFirSourcesSession exception on analysing common code
• KT-62874 K2: FirLazyExpression should be calculated before accessing
• KT-62407 Analysis API: resolve [this] in KDoc to extension receiver
• KT-61204 K2: "FirLazyExpression should be calculated before accessing in ktor HttpBinApplication"
• KT-61901 Analysis API: Declared member scopes for Java classes are missing static members
• KT-61800 Analysis API: Provide separate declared member scopes for non-static and static callables
• KT-61255 Analysis API: Get rid of valueOf , values and entries from a declared member scope
• KT-62466 Expected type for functional expression should include inferred types
• KT-61203 IDE K2: "Expected FirResolvedArgumentList for FirAnnotationCallImpl of FirRegularClassImpl(Source) but FirArgumentListImpl found"
• KT-61791 Analysis API: Implement combined getPackage for combined Kotlin symbol providers
• KT-62437 K2 IDE. Resolution does not work inside lambda expression in constructor argument in supertypes
• KT-62244 K2: Analysis API Standalone: Resolving klib dependencies from binary roots terminates application
• KT-62897 K2 IDE. Unresolved declarations from libraries which are doubled in intellij project libraries
• KT-61615 K2: No 'org.jetbrains.kotlin.fir.analysis.js.checkers.FirJsModuleKind' in array owner: LLFirSourcesSession
• KT-59334 K2: LLFirImplicitTypesLazyResolver problems
• KT-62038 K2: Nested classes are missing in symbol light class structure tests for libraries
• KT-61788 Analysis API: Symbol for FirAnonymousInitializer cannot be null
• KT-62139 Analysis API: KtFe10AnalysisSession.createContextDependentCopy does not need validity check
• KT-62090 Analysis API: introduce an API to get a substitution formed by class inheritance
• KT-62268 K2 IDE. No autocompletion and IllegalStateException for Pair
• KT-60325 K2 IDE. "IllegalArgumentException: source must not be null" on throw usage attempt
• KT-61431 K2: KtPropertyAccessorSymbolPointer pointer already disposed for $$result script property
• KT-58490 K2: LLFirTypeLazyResolver problems
• KT-58494 K2: LLFirAnnotationArgumentsLazyResolver problems
• KT-58492 K2: LLFirBodyLazyResolver problems
• KT-58769 K2: LL FIR: implement platform-dependent session factories
• KT-60343 K2 IDE. IllegalArgumentException on passing incorrect type parameter to function
• KT-61842 K2: reduce number of "in-block modification" events
• KT-62012 K2: "KtReadActionConfinementLifetimeToken is inaccessible: Called outside analyse method"
• KT-61371 K2: Analysis API standalone: register compiler symbol provider for libraries in standalone mode
• KT-60611 K2: reduce number of "in-block modification" events
• KT-61425 Analysis API: Provide a way to get a declared member scope for an enum entry's initializing anonymous object
• KT-61405 Analysis API: An enum entry should not be a KtSymbolWithMembers
• KT-55504 AA: remove dependency on :compiler:cli from standalone AA
• KT-60904 K2: IDE K2: "For DESTRUCTURING_DECLARATION_ENTRY with text _ , one of element types expected, but FirValueParameterSymbol found"
• KT-61260 K2 Scripts: Containing function should be not null for KtParameter
• KT-61568 FIR Analysis API: collectCallCandidates gives presence to the top level functions in the presence of more suitable overrides
• KT-60610 K2 IDE: move "out of block" processing logic into LL FIR
• KT-61597 Analysis API: KotlinIllegalStateExceptionWithAttachments: expected as maximum one expect for the actual on errorneous code with multiple expects
• KT-59793 K2: class org.jetbrains.kotlin.fir.declarations.impl.FirErrorImportImpl cannot be cast to class org.jetbrains.kotlin.fir.declarations.FirResolvedImport
• KT-61599 K2: ContextCollector: Support smart cast collection
• KT-61689 Analysis API: ContextCollector provides incorrect context in scripts
• KT-61683 Analysis API: resolve ambiguities in kotlin project
• KT-61245 Analysis API: ContextCollector provides incorrect context for supertype constructor calls
• KT-60384 K2: Opening @JvmName source in IDEA: NPE at PsiRawFirBuilder$Visitor.toFirConstructor()
• KT-60918 K2 IDE: "FirDeclaration was not found for class org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry, fir is null"
• KT-61013 K2 Scripts: LLFirReturnTypeCalculatorWithJump: No designation of local declaration
• KT-59517 K2 IDE: KotlinExceptionWithAttachments: Modules are inconsistent
• KT-61331 K2: add cache restoring in case of existing context
• KT-61408 K2: IDE K2: "Inconsistency in the cache. Someone without context put a null value in the cache"

Analysis. Light Classes

• KT-63486 SLC: a lot of RAM is allocated in org.jetbrains.kotlin.asJava.LightClassUtil.isMangled
• KT-66692 SLC: findAttributeValue for attribute w/ default value in Java returns null
• KT-61734 SLC: wildcard suppression not honored
• KT-65112 Symbol Light Classes don't support annotations on type parameters
• KT-65843 K2: Light method returns kotlin.Unit type for TestResult return type
• KT-65653 SLC: wrong binary resolution to function with value class
• KT-65393 SLC: missing deprecated-hidden property
• KT-64772 SLC: presence of source PSI for compiler-generated declaration
• KT-65425 K2 IDE: Seeing a reference to the class generated by compiler plugin exposed from Java code caused NPE from light classes
• KT-64937 SLC: internal setters are not mangled
• KT-63949 K2 IDE. Analyze hang on @Autowired constructor analysis
• KT-63087 K2 IDE: in .java source reference to JvmName names on unsigned type / value class are unresolved
• KT-64605 K2 IDE: usage of @Repeatable annotation in Java: false positive "Duplicate annotation"
• KT-64795 SLC: distinguish last v.s. non-last vararg value parameter type during binary resolution
• KT-61605 K2 IDE: Light elements do not obey platform contracts
• KT-57536 SLC: no need to populate members with expect modifier
• KT-64320 Decouple kotlin psi from java PSI
• KT-64282 Decouple KotlinIconProviderService from java PSI
• KT-63552 Symbol Light Classes don't support arrayOf and similar without parameters in property initializers and default parameter values

Apple Ecosystem

• KT-63821 Copy framework to BUILT_PRODUCTS_DIR in the embedAndSign task
• KT-67892 KotlinNativeLink task instantiates with a fixed list of apiFiles
• KT-64096 Diagnostic when embedAndSign used for framework with cocoapods-dependencies
• KT-66446 Diagnostic never showed, and build fails when CocoaPods dependency is used with embedAndSign task and linking type is dynamic
• KT-66445 Diagnostic never showed when CocoaPods dependency is used with embedAndSign task and linking type is static
• KT-62373 "Xcode higher than tested" diagnostic
• KT-63212 podInstall task fails without a proper diagnostic when xcodeproj gem is outdated

Backend. Native. Debug

• KT-65553 K2: Native: kt42208WithPassingLambdaToAnotherFunction test fails with K2
• KT-57365 [Native] Incorrect debug info on inline function call site

Backend. Wasm

• KT-65009 Generate TypeScript definitions for the @JsExport declarations in K/Wasm
• KT-58088 [PL] Support & enable partial linkage for Wasm
• KT-66327 Include information about particular Wasm target into KLib manifest
• KT-66465 WASM support doesn't appear to be able to see some common declarations
• KT-66905 K/Wasm: support new version of exception handling proposal
• KT-66515 Wasm: "call param types must match" during the build
• KT-67435 K/Wasm: import.meta.url transforming into absolute local path in webpack
• KT-65777 Implement named export for Kotlin/Wasm
• KT-65660 [WasmJs] Support catching JS exceptions
• KT-65824 Wasm: Allow unsigned primitives to be used inside functions annotated with @JsExport
• KT-66103 Wasm: companion object is not initialized in test initializers1.kt
• KT-66471 Null method reference with Kotlin/Wasm on 2.0.0-Beta4
• KT-65210 K/Wasm ::class operator produces Number KClass for Short expression
• KT-66065 [Wasm] Make specialisations for closured primitive values
• KT-64890 K/Wasm compiler crash with external class and Kodein
• KT-66104 Wasm: compiler crash: NoSuchElementException: Sequence contains no element matching the predicate
• KT-65778 Create the same TypeScript tests infrastructure for Kotlin/Wasm that we have now for Kotlin/JS
• KT-65411 Kotlin/Wasm: Boolean boxed instances are not the same
• KT-65713 Kotlin/Wasm generates a wrapper that cannot run in Deno
• KT-63939 Kotlin/Wasm Support lazy associated object initialisation
• KT-61888 [Kotlin/wasm] in kotlin.test support for @AfterTest for async tests
• KT-64803 K/Wasm: non-capturing lambdas are not singleton unlike same lambdas in jvm
• KT-64449 K2: Implement K1WasmWasiCodegenBoxTestGenerated for K2
• KT-64829 K/Wasm: division remainder has a wrong sign
• KT-58852 WASM: two methods with different varargs: Class korlibs.template.dynamic.DynamicShape has 2 methods with the same signature [register(kotlin.Array)
• KT-61263 K/Wasm: add a way to turn on k2 in wasm examples using Compose
• KT-62863 Execution failed for task ':kotlinx-serialization-properties:wasmJsD8Test' in serialization in the K2 QG
• KT-62657 K/Wasm: switch to json repots for Kotlin Wasm Benchmarks
• KT-62147 [Kotlin/Wasm] Nothing typed when expression cause a backend error
• KT-61958 Update SpiderMonkey and return its usage in box tests when they switch to the final opcodes for GC and FTR proposals
• KT-60828 K/Wasm: return br_on_cast_fail usages
• KT-59084 WASM: "RuntimeError: illegal cast" caused by inline class and JsAny
• KT-60700 [WASM] test FirWasmCodegenBoxTestGenerated.testSuspendUnitConversion failed after KT-60259
• KT-45375 Generate all Kotlin lambdas via invokedynamic + LambdaMetafactory by default
• KT-24664 No smartcast on stable property if receiver had non-null assertion
• KT-23915 Add smart cast to non-nullable type after elvis operator
• KT-61077 Support provideDelegate inference from var property type
• KT-59688 K2: consider removing smartcasts only from the only visibile property with specific name, not from all of them
• KT-7389 Intersection type for type parameter with multiple upper bounds in star projection
• KT-63477 Consider supporting builder-style type inference from Unit coercion of last statements in lambdas
• KT-61907 K2: builder inference works with assignments to member properties
• KT-61909 K2: builder inference infers correct types from assignments to extension properties
• KT-59551 K2: builder inference works with anonymous functions if builder parameter has a receiver with a postponed type variable
• KT-65443 [K/N] Implement header caches
• KT-4113 Smart casts for properties to not-null functional types at invoke calls
• KT-65681 K2: Improve error message of UPPER_BOUND_VIOLATED when upper bound is a captured type or other non-denotable type
• KT-32754 Choose existing extensions over additional built-ins members from JDK except overrides
• KT-57800 Support synthetic properties on super receiver
• KT-64350 K2: deprecate using typealias as a callable qualifier in imports
• KT-26565 Choose existing extensions over additional built-ins members from JDK
• KT-65478 JVM: Change inlined variable naming format
• KT-64702 Upper bound of type parameter is ignored when capturing of in-projection appears in out position
• KT-60274 K2: builder inference works through a delegated local variable inside builder argument
• KT-65859 Calls refinement extension point
• KT-15220 Reuse resolution results of common code for platform modules in multiplatform projects
• KT-60476 K2: False positive NO_VALUE_FOR_PARAMETER in platform code for value class with default parameter in common declaration
• KT-65153 K/N: extract liveness analysis to a separate phase
• KT-59098 Support -Xjdk-release=1.6/1.7 with -jvm-target 1.8
• KT-63670 Implement platform specific declaration clash diagnostics across all backends
• KT-62547 Introduce a language feature flag for smartcasts based on "memory" variables
• KT-60820 K1: Empty vararg value is inserted in serialized annotation call with expect default vararg value
• KT-58172 Forbid expect class A actual constructor
• KT-54443 Smart cast to non-null after safe-call in require
• KT-25747 DFA variables: propagate smart cast results from local variables
• KT-22997 Smart-cast should merge is-check for non-nullable type and a null check to a nullable type
• KT-22996 Smart casts should observe nullability after is-check with a nullable subject type
• KT-22004 Allow to resolve CONFLICTING_OVERLOADS with Deprecated(HIDDEN)
• KT-61955 Support more wider actual member visibility, if the expect member is effectively final
• KT-59504 K2 compiler does not require resolved 'componentX' functions for the placeholder ('_') variables in the destructuring declarations
• KT-62239 Allow enum entries without parentheses uniformly
• KT-11712 Smart cast is not applied for invisible setter
• KT-47545 NI: Slow type inference involving large when-expression (ConstraintInjector.processConstraints)
• KT-62714 Do not add nullability annotations to the methods of inner classes in enum entries
• KT-62903 Unoptimzied when compilation
• KT-67388 FP intellij: performance degradation in build 611
• KT-67507 K2: Slow compilation times when a class has a lot of possibly conflicting declarations
• KT-65005 K2: Investigate testCommonSuperTypeContravariant performance
• KT-65996 Compiler enters endless loop
• KT-66341 K2: Don't build IdSignatures in FIR2IR with IR f/o builder
• KT-66172 K2: Improve memory consumption of KtPsiSourceElement
• KT-50860 Combination of array set convention and plusAssign works exponentially
• KT-62798 'in' range checks are not intrinsified in kotlin-stdlib
• KT-65579 K2: performance regression in FP Space
• KT-61635 K2: getConstructorKeyword call in PsiRawFirBuilder.toFirConstructor forces AST load
• KT-62619 FIR: Checker performance regression due to MISSING_DEPENDENCY checkers
• KT-62044 Do not add nullability annotations to the methods of anonymous class
• KT-62706 Optimize KtSourceElement.findChild()
• KT-62513 Do not add nullability annotations to the methods of local classes
• KT-61991 K2: avoid redundant full body resolution for properties during implicit type phase
• KT-61604 [K/N] Bitcode dependency linking is slow for large compilations
• KT-61121 [K/N] Kotlin Native compiler performance is slow when generating large frameworks
• KT-57616 K2: Consider optimizing reversed versions of persistent lists in FirTowerDataContext
• KT-67993 K2: PCLA Inference throws exception with local objects
• KT-61768 Wrong bytecode index in LineNumberTable when there is an incremental operation
• KT-63580 "AssertionError: access of const val: GET_FIELD" caused by const value and variable with delegation
• KT-63567 "NoSuchMethodError" on getting value of lazily initialized property by companion's const value
• KT-56078 K2: build kotlinx.coroutines
• KT-67609 K2: False negative INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_ERROR
• KT-57750 Report ambiguity error when resolving types and having the same-named classes star imported
• KT-65603 K2: No approximation is done on public, but effectively private property
• KT-59932 K2: Disappeared AMBIGUOUS_ANONYMOUS_TYPE_INFERRED
• KT-59906 K2: Disappeared CAPTURED_VAL_INITIALIZATION
• KT-53886 NoSuchMethodError exception in Kotlin/Native compiler
• KT-57678 K2: Inconsistency in how K2 analyzes unresolved code for loops and changing closures
• KT-57871 K1/K2 inconsistency on if-conditional without else-branch in parenthesis
• KT-56384 K2: build IntelliJ monorepo master branch
• KT-49191 Leaked integer literals from lambda with flexible return type
• KT-65812 K2: "OutOfMemoryError: Java heap space" in kotlin.utils.SmartList.add
• KT-67224 K2/Native: Member overrides different ' @Throws ' filter from separate module
• KT-65623 K2: Unresolved reference in connection with casts
• KT-64136 K2: NSME with Anvil compiler plugin
• KT-51241 Provide a error when override method has different set of context receivers
• KT-52920 Confusing "Multiple arguments applicable for context receiver" error message
• KT-67912 K2: Cannot inference type properly from inline function with Type parameter
• KT-68056 Prohibit referencing java field in case of conflict with property from companion object of the derived class
• KT-61129 K2: Implement error suppression warning
• KT-67367 K2: Incorrect resolution to top-level function with less specific signature in presence of SAM constructor on the same tower level
• KT-50179 Fix DUPLICATE_LABEL_IN_WHEN warning with new rules of complex boolean constants
• KT-45334 Prohibit referencing constructors of sealed classes by its inner members
• KT-59943 K2: Disappeared OPERATOR_MODIFIER_REQUIRED
• KT-67875 K2: Resolution ambiguity between Iterable and varargs
• KT-67699 Not enough information to infer type argument for 'Error' using Arrow's Raise context receiver since Kotlin 2.0.0-Beta3
• KT-67486 K2: Calling method from a Java (implementing a Kotlin class) with named parameters is no longer possible if Java method has different parameter names
• KT-66527 K2: type mismatch on override for type
• KT-59897 K2: Disappeared PACKAGE_OR_CLASSIFIER_REDECLARATION
• KT-50020 K2: False-negative USAGE_IS_NOT_INLINEABLE when lambda in receiver position
• KT-44557 Implement main function detection to FIR
• KT-67810 K2: public-API inline function cannot access non-public-API annotation enum
• KT-66447 Implement KT-59138 under a language feature
• KT-54862 Anonymous type can be exposed from private inline function from type argument
• KT-37592 Property invoke of a functional type with receiver is preferred over extension function invoke
• KT-51194 False negative CONFLICTING_INHERITED_MEMBERS when dependency class contained in two different versions of the same dependency
• KT-67221 K2: "new inference error [NewConstraintError at Incorporate TypeVariable" for captured type
• KT-66701 K2: Java interface method override via Kotlin class rejected
• KT-60604 K2: introduced NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, @PublishedApi needed for constants in annotations
• KT-64309 Generate a variable mapping for continuation parameter in suspend methods just from the start
• KT-65438 K2: Introduce WEAKLY_HIDDEN concept to built-in-JDK content mapping
• KT-65235 JDK 21 might lead to change in overloads resolution
• KT-66768 K1: False positive UNRESOLVED_REFERENCE in super.getFirst/getLast call
• KT-67106 Platforms libs-dependant autotests for ObjC checkers
• KT-65440 K2: Mark all potential implementations of List.getFirst()/getLast() as deprecated independently of JDK
• KT-65594 K2: Type inference fails on NullMarked object with star type
• KT-62849 Unoptimised bytecode for Java synthetic property references
• KT-60174 JVM IR inline: accidental reification in various cases
• KT-57609 K2: Stop relying on the presence of @UnsafeVariance using for contravariant parameters
• KT-54316 Out-of-call reference to companion object's member has invalid signature
• KT-66976 Some value class diagnostics are missed
• KT-57426 Incorrect error message on inapplicable smartcast from alien property
• KT-55111 OptIn: forbid constructor calls with default arguments under marker
• KT-49856 Incorrect smartcast on var assigned in try-catch block
• KT-41237 ReturnsImplies contract for receiver of member function does not work (no smartcast)
• KT-37878 No Smart cast for class literal reference of nullable generic type
• KT-35846 Smart cast with unchecked cast leads to unresolved call that was resolved before (both old and new inference)
• KT-30867 Unsound smartcast if smartcast source and break is placed in for-in header as function arguments
• KT-30267 Inconsistent smart casts in while (true)
• KT-33917 Prohibit to expose anonymous types from private inline functions
• KT-28889 Smart cast does not work with boolean and infix function
• KT-54790 False positive NO_ELSE_IN_WHEN when all interfaces are sealed
• KT-54920 K2: when with a single branch stops being exhaustive the second time it's done
• KT-53364 False positive UNUSED_VARIABLE warning for variable that is used across multiple blocks
• KT-43234 False positive INVALID_IF_AS_EXPRESSION caused by if without else inside else inside synchronized()
• KT-38490 False negative INVALID_IF_AS_EXPRESSION with unreachable code and coercion to Unit
• KT-35510 No INVALID_IF_AS_EXPRESSION ("'if' must have both main and 'else' branches if used as an expression") diagnostic for if-expression with only one branch and Nothing type condition
• KT-34016 Contracts - variable cannot be initialized before declaration
• KT-56408 Inconsistent rules of CFA in class initialization block between K1 and K2
• KT-33829 False positive SENSELESS_COMPARISON with assignment in catch block
• KT-30717 False positive UNUSED_VARIABLE with local var used in inline lambda block with loop, return and other lambda
• KT-28232 RETURN_NOT_ALLOWED in inline lambda argument of '[... ]' operator convention
• KT-26116 No error when class member val is referenced in inline function before it is assigned later on
• KT-25311 Calls on error type values lead to false-positive unreachable code
• KT-24372 Misleading warning on unused setter parameter in some cases
• KT-23680 False positive UNREACHABLE_CODE on throw with a return inside finally clause
• KT-23502 When exhaustiveness is not checked for unreachable code, resulting in JVM back-end error
• KT-22621 "throw throw Exception()": False negative UNREACHABLE_CODE warning
• KT-22317 No INITIALIZATION_BEFORE_DECLARATION without primary constructor
• KT-67307 K2: "Cannot find cached type parameter by FIR symbol" in JpaRepository.saveAll
• KT-67185 K2: Incorrect coercion-to-Unit leading to CCE at runtime
• KT-64891 K2: consider supporting/forbidding foo.(bar)() syntax
• KT-59480 K2: build moko-resources
• KT-65771 K2: "IndexOutOfBoundsException: Cannot pop operand off an empty stack" when calling method imported using typealias as callable qualifier
• KT-67502 K2: "property must be initialized or be abstract" with try-finally in secondary constructor
• KT-67456 K2: "property must be initialized or be abstract" depending on constructor declaration order
• KT-63524 K2: "Not enough information to infer type argument"
• KT-67628 K2: "IllegalArgumentException: Expected nullable type" — alias of nullable type analyzed as non-nullable in type parameter
• KT-67625 K2: Array aliases can't be used as vararg values
• KT-67624 K2: False negative "The feature "break continue in inline lambdas" is experimental and should be enabled explicitly" in elvis operator
• KT-61787 K2 doesn't report warnings for some Gradle tasks
• KT-62550 K2: Different JVM signature of lambda with Unit return type
• KT-65120 K2 Consider turn into platform checkers ones which checks for objC
• KT-60271 K2: origins are not set on compare operators
• KT-28695 Compiler does not detect uninitialized property in lambda
• KT-67593 K2: false negative SUPER_CALL_WITH_DEFAULT_PARAMETERS
• KT-67484 K2: FIR2IR generates incorrect access to f/o of lateinit internal var
• KT-47382 JVM / IR: "AssertionError: Unbound private symbol IrFieldSymbolImpl" caused by string template in constructor and extension property
• KT-67581 K2: Compiler fails on actualizing abstract class with sealed Java class via type alias
• KT-49404 Fix type unsoundness for contravariant captured type based on Java class
• KT-22379 Condition of while-loop with break can produce unsound smartcast
• KT-67021 K2: Cannot find cached type parameter by FIR symbol: E of the owner: FirRegularClassSymbol Function
• KT-67014 K1/K2 handle when expression as annotation target differently
• KT-67254 K1/K2 both allow annotations on loops, assignments, array sets
• KT-66960 K2. KMP. False negative 'when' expression must be exhaustive without sealed class inheritor from common source-set
• KT-65578 K2: implement a deprecation warning for KT-57014 (wrong nullability returned from JDK SAM constructor lambda)
• KT-63466 @NonNull on a type-variable usage doesn't take precedence over a wildcard type argument
• KT-56134 K2: NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER diagnostic is reported for the wrong symbol
• KT-66196 Convert INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_ERROR to warning
• KT-66793 K2: "assigning single elements to varargs in named form is prohibited." caused by varargs supplied from java with elvis operator
• KT-59872 K2: Disappeared TYPE_MISMATCH
• KT-67192 K2: Disappeared TYPE_MISMATCH [3]
• KT-63319 K1/K2: inconsistent behavior around NullMarked and type parameter based types
• KT-59882 K2: Disappeared CANNOT_INFER_PARAMETER_TYPE
• KT-67191 K2: Disappeared TYPE_MISMATCH [4]
• KT-53752 Missed subtyping check for an intersection type
• KT-52628 Deprecate SAM constructor usages which require OptIn without annotation
• KT-54066 Deprecate upper bound violation in typealias constructors
• KT-64860 K2: Consider using different ConstraintPosition when fixing variables for PCLA
• KT-67189 K2: Disappeared TYPE_MISMATCH [5]
• KT-67551 K2: No wrong annotation target error for for statement
• KT-67374 K2: Object is not smartcasted to type parameter type
• KT-67264 K2: "argument type mismatch" with suspend lambda and java wildcard
• KT-63257 K2: FIR2IR inserts incorrect implicit cast for smartcasted variable
• KT-66902 K2: "Named arguments are prohibited for non-Kotlin functions" with Java interop
• KT-67311 K2: "Argument type mismatch" caused by lambda type when using named arguments
• KT-57011 Make real type of a destructuring variable consistent with explicit type when specified
• KT-62043 K2: Fix FirCompileKotlinAgainstCustomBinariesTest.testRawTypes
• KT-66256 K2: compiler FIR2IR crash on SAM-conversion to value parameter of in-projected type
• KT-67124 "Unstable inference behaviour with multiple generic lambdas" compilation error
• KT-59791 K2: Implement partially constrained lambda analysis
• KT-66743 Lambda receivers and anonymous function parameters of inaccessible types are allowed
• KT-67315 K2: Some default imports are not excluded
• KT-56126 Avoid using descriptors at JvmPlatformAnalyzerServices::computePlatformSpecificDefaultImports
• KT-66513 K2: Suppressing OPT_IN_USAGE_ERROR is now a warning in K2, preventing safe code gen compatible with -Werror
• KT-67233 False negative UNSAFE_CALL with type check after null coalescing with 'OR'
• KT-52802 Report ambiguity resolving between property/field and enum entry
• KT-64920 Json.encodeToString yields different results depending on whether typealias is used
• KT-58260 Make invoke convention work consistently with expected desugaring
• KT-67314 PCLA works inconsistently with smart-cast related CS forks
• KT-66797 K2 JS: Primary constructor property annotation with target VALUE_PARAMETER is put on property instead of parameter
• KT-55179 False negative PRIVATE_CLASS_MEMBER_FROM_INLINE on calling private class companion object member from internal inline function
• KT-54663 Projected types don't take into account in-place not null types
• KT-58191 K2: capturing closures successors that are already resolved (thanks to backward edges) must be taken into account for allowing smart casts
• KT-67144 K2: potential NPE when assigning to unstable vars
• KT-66971 K2: missing SMARTCAST_IMPOSSIBLE on open val declared in another module
• KT-66904 K2: possible NPE when reassigning captured variables
• KT-57031 operator assignment, increment/decrement should be considered as variable reassigning in terms of DFA. green in K1 -> red in K2 for unsound code
• KT-67212 K2: "Failed to find functional supertype for class org.jetbrains.kotlin.fir.types.ConeCapturedType"
• KT-67283 K2: No SAM conversion for fun interface with abstract toString
• KT-67318 Compiler fails with OutOfMemoryError on combination of PCLA+smart cast
• KT-66956 K2: false negative CONST_VAL_WITH_NON_CONST_INITIALIZER for inc/dec operators
• KT-64233 K2: K1/K2: ensure JVM ABI consistency for quality gates projects
• KT-63535 K2: Apply DFA implications for nullable Nothing to both sides
• KT-63413 K2 / kotlinx-atomicfu: "IllegalStateException: Expected some types"
• KT-62931 K2: extra class files for @OptionalExpectation marked annotations
• KT-34307 Confusing error message on lambda return type mismatch
• KT-62151 K2. overload resolution ambiguity for calls of Java record compact constructors
• KT-60732 K2 Scripting: TeamCity DSL test
• KT-65062 K2: build kotlinx.collections.immutable and pass to CI
• KT-59467 K2: build toolbox-enterprise
• KT-67205 K2: can't deserialize annotation with local class as argument
• KT-52175 K2: WRONG_ANNOTATION_TARGET for annotation that used inside if
• KT-65449 K2: build KAPT user project and pass it to CI
• KT-61384 IrFakeOverrideBuilder incorrectly checks visibility for friend modules
• KT-67142 K2: IrFakeOverrideBuilder: AbstractMethodError on raw type argument in a Java superclass
• KT-65105 K2 / Native: Member overrides different ' @Throws ' filter
• KT-62570 IncompatibleClassChangeError due to overriding final method
• KT-57812 K2: support serialization of type annotation's arguments
• KT-67190 K2: Disappeared TYPE_MISMATCH [2]
• KT-56683 K2: No control flow analysis for top-level properties
• KT-67188 K2: Disappeared TYPE_MISMATCH [6]
• KT-62063 K2: drop pre-release flag in 2.0-RC
• KT-67187 K2: Disappeared TYPE_MISMATCH [1]
• KT-66909 K2: Implement a diagnostic for returning null from a lambda with expected return type Unit!
• KT-66534 False positive ASSIGNMENT_TYPE_MISMATCH in lambdas with expected return type Unit!
• KT-63381 IrFakeOverrideBuilder: PublishedApi affects overridability of internal members
• KT-63836 K2: No deprecation error message in common metadata compilation
• KT-57618 K2: complex deprecation messages are not printed in the error
• KT-59856 K2: Check ConeDiagnostics that are not mapped to KtDiagnostics
• KT-57502 K2: Smart casts should be forbidden if variable that remembers the smart cast is declared by delegation
• KT-63967 K2: Missing getterSignature in metadata for script variables
• KT-59372 K2: Missing SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR
• KT-60526 K2: Fix the TODO in convertToIr.kt
• KT-67090 K2: Exception from metadata compilation when compiling class with annotations from dependencies
• KT-59479 K2: build KorGE
• KT-64502 K2: Internal error on calling function before declaration
• KT-62560 K2: KAPT4: annotation @ReplaceWith is missing a default value for the element 'imports'
• KT-67027 K2: Review all use-sites of annotation arguments utilities
• KT-65012 IR Evaluator: NoSuchFieldException when evaluating protected/private fields of superclasses
• KT-66953 K2: toByte() call on Char leads to ClassCastException for klib backends
• KT-60096 K2: Introduced API_NOT_AVAILABLE
• KT-59484 K2: build trustwallet sample
• KT-64151 K2: consider implementing FIR-level constant evaluation
• KT-65787 K2: "KotlinIllegalArgumentExceptionWithAttachments: Expected FirResolvedTypeRef with ConeKotlinType" caused by passing lambda expression with multiple labels to function
• KT-53629 K2: forbid multiple labels per statement
• KT-65255 K2 / KJS: "IllegalArgumentException: Candidate is not successful, but system has no contradiction"
• KT-65195 K2: Unexpected exception when executing dynamic array element inc/dec
• KT-63416 K2 / Contracts: False positive "Leaked in-place lambda" warning caused by suspend lambda with callsInPlace contract
• KT-66717 Incorrect diagnostics around intersection property overrides
• KT-63540 Restrict the CONFLICTING_OVERLOADS + DeprecatedLevel.HIDDEN ignore to final callables
• KT-56587 There are no warnings in some cases when Enum.entries is shadowed
• KT-65111 K2: Java star imports don't work in KJK interdependencies
• KT-63709 K2: Argument smartcasting impacting receiver and call resolution for implicit invoke
• KT-63530 K2: Disable passing data flow info from in-place lambdas
• KT-65377 K2: "Argument type mismatch" caused by approximated captured type argument of generic type
• KT-59400 K2: Missing CANNOT_INFER_VISIBILITY
• KT-62305 K2: Missing Fir metadata serialization support for scripts
• KT-64534 K2: org.jetbrains.kotlin.util.FileAnalysisException: Somewhere in file
• KT-57555 [LC] Forbid deferred initialization of open properties with backing field
• KT-65776 [LC] K2 breaks false && ... and false || ...
• KT-64641 K2: Change in inference of supertype of function types with receiver
• KT-65649 K2: IR has incorrect origins for some inplace updating operators
• KT-64295 Forbid recursive resolve in case of potential ambiguity on upper tower level
• KT-62866 K2: Change qualifier resolution behavior when companion object is preferred against static scope
• KT-55446 Change impact of private-to-this visibility to resolution
• KT-64255 Forbid accessing internal setter from a derived class in another module
• KT-64966 Forbid generic delegating constructor calls with wrong type for generic parameter
• KT-63389 K2: WRONG_ANNOTATION_TARGET is reported on incompatible annotations of a type wrapped into ()?
• KT-66748 K2: False-positive AMBIGUOUS_SUPER in toString
• KT-67013 K2: ClassCastException: class FirConstructorSymbol cannot be cast to class FirNamedFunctionSymbol
• KT-64872 K2: do-while condition able to access uninitialized variable
• KT-66350 K2: "IllegalStateException: Unsupported compile-time value STRING_CONCATENATION" when evaluating an annotation argument string
• KT-61798 K2 incorrectly calculates modality of property accessors
• KT-65035 IrFakeOverrideBuilder: AbstractMethodError on inheritance from Java subclass of CharSequence with inherited implementations
• KT-61579 K2: Inconsistent reporting UNINITIALIZED_VARIABLE for top-level properties
• KT-66730 K2: False positive RETURN_TYPE_MISMATCH in return statement in SAM constructor
• KT-66570 Generic wildcard upper bound inference error
• KT-65272 K2: invoke operator applies "restricted suspending call" error differently than K1
• KT-66148 K2. Sources of receivers updated twice because of PCLA
• KT-62525 K2: IllegalStateException: Can't find KotlinType in IrErrorType: IrErrorType(null)
• KT-64266 K2: don't report MISSING_DEPENDENCY_CLASS on lambda parameter for non-generic types
• KT-65300 K2: this-expressions in initializers and local declarations don't introduce type information to either BI or PCLA
• KT-66463 K2: false positive ACCIDENTAL_OVERRIDE_CLASH_BY_JVM_SIGNATURE
• KT-62356 Prohibit using property+invoke for iterator
• KT-63631 K2: constant value UByte.MAX_VALUE is incorrectly deserialized from metadata
• KT-65386 K2: Different signature of invoke for Unit lambda
• KT-60574 K2: generated IR for suspendCoroutineUninterceptedOrReturn is different from K1 (K2 uses Any? instead of Unit)
• KT-66512 K2: Incorrect diagnostic in lambda whose expected type is a type alias to Unit
• KT-66279 K2: False positive INITIALIZER_TYPE_MISMATCH with return Unit in a lambda with the expected type () -> Unit
• KT-66277 K2: False negative RETURN_TYPE_MISMATCH with empty return in lambda assigned to a property
• KT-66654 K2 FIR resolution: Mismatch between actual type and expected type for a value parameter when the parameter type is a function type with special function kind
• KT-66638 Cannot access properties of a generic type with wildcards
• KT-66690 K2: don't report MISSING_DEPENDENCY_CLASS on expression without errors for generic type arguments
• KT-66767 K2: Destructuring declaration inside initializer failure
• KT-63695 JVM: Don't use plugin extensions when compiling code fragment
• KT-65727 K2: add proper package for properties generated from destructuring declarations
• KT-64854 K2: Trying to access private field on runtime with contracts
• KT-65388 IrFakeOverrideBuilder - custom annotation is available in fake getter/setter
• KT-66595 K2: compiler FIR checking crash on destructuring declarations calling hidden componentN declarations
• KT-62129 K2: Verification error on calling an extension from an env with 2+ context receivers
• KT-41607 NI: UNSAFE_CALL caused by try catch block assigning to a nullable variable
• KT-63932 K2/Native codegen test failures around builder inference
• KT-66352 K2: difference between LL FIR and FIR for componentN functions
• KT-66686 K2 Script: Unresolved reference of script-specific entities on out-of-order resolve
• KT-65523 K2: add proper package for result$$ property
• KT-66699 Restore HostManager ABI
• KT-60533 Inliner incorrectly captures non-null value as null in coroutines
• KT-57925 K2: Consider removing FirEmptyContractDescription
• KT-61893 K2: should not resolve to Java function with Kotlin hidden-level deprecation
• KT-59669 K2: Explore assignments in in-place lambdas
• KT-66271 Fir: Deserialize classFile, functionFile and propertyFile from KlibMetadataProtoBuf
• KT-57957 K2: Symbol providers are frequently queried with error-named class IDs
• KT-66046 K2: false negative CANNOT_WEAKEN_ACCESS_PRIVILEGE on property
• KT-66677 K2: OVERRIDE_DEPRECATION isn't reported for WEAKLY_HIDDEN method toArray()
• KT-62793 K2: slightly different bytecode of suspend conversions
• KT-57244 K2: slightly different naming scheme for suspend conversion adapters
• KT-60256 K2: types are not substituted in suspend conversion
• KT-66673 K2/JS: FirJsInheritanceClassChecker doesn't expand type aliases to supertypes
• KT-66475 K2/KMP/Wasm: report WRONG_JS_INTEROP_TYPE from a platform checker
• KT-66474 K2/KMP/JS: report EXTERNAL_TYPE_EXTENDS_NON_EXTERNAL_TYPE from a platform checker
• KT-66473 K2/Wasm: FirWasmExternalInheritanceChecker doesn't expand type aliases
• KT-64407 Implement WriteSignatureTestGenerated for K2
• KT-64438 K2: Port CodegenTestCase to K2
• KT-64404 Implement WriteFlagsTestGenerated for K2
• KT-66491 K2 / KJS: "Name contains illegal characters." caused by backticks in import
• KT-66275 K2: false-positive "Java module does not depend on module" error on access to inherited member from twice-transitive dependency via class from transitive dependency
• KT-65801 IrFakeOverrideBuilder - visibility is lost for setter in KJK hierarchy
• KT-65576 K2: Incorrect resolution of variable+invoke when the property type is not computed
• KT-58575 Private Kotlin property prevents use of Java get- and set-methods from Java-Kotlin-Java hierarchy
• KT-61282 K2: Incorrect overridden function for java.nio.CharBuffer.get
• KT-65464 K2: False positive UNRESOLVED_REFERENCE on extension property call defined in KJK hierarchy
• KT-59470 K2: build KaMPKit
• KT-60510 Smartcast to functional type does not work in when exprssion
• KT-59677 K2: Report diagnostics about missing receiver for delegated constructor call to inner class
• KT-65183 K2: Remove workaround for @OnlyInputTypes and captured types with recursive supertypes from inference
• KT-66120 IrFakeOverrideBuilder: wrong return type in intersection with 3 classes
• KT-65939 IrFakeOverrideBuilder - nullability annotation is lost in intersection without annotation
• KT-59473 K2: build firebase-kotlin-sdk
• KT-66356 K2: type mismatch error when generic type with inaccessible generic type as type argument is produced and consumed by declarations from dependencies
• KT-65193 K2: "JAVA_TYPE_MISMATCH" caused by MutableList
• KT-66636 NoSuchMethodError: 'void org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl. in the FLysto K2 QG
• KT-63941 K2: "IllegalStateException: Unsupported compile-time value STRING_CONCATENATION" caused by class reference in string expression as annotation parameter
• KT-65704 K2: computeCommonSuperType of flexible type with recursive captured type argument produces giant multi-level-deep type
• KT-65410 K2: ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED for 'removeAt' in KJK hierarchy
• KT-65184 K2: disappeared TYPE_MISMATCH for java collections
• KT-66392 K2: Exception in KJK hierarchy with implicit types
• KT-66551 Revert temporary commits after KT-62063 and bootstrapping
• KT-65218 FIR LL and DiagnosticFE10 tests start to fail in case of adding any new declaration into stdlib commonMain
• KT-66552 K2: build of intellij crashes the compiler
• KT-63746 K2: JSpecify: If a class has a @Nullable type-parameter bound, Kotlin should still treat unbounded wildcards like platform types
• KT-66504 K2: plusAssign operator call is resolved differently than function call
• KT-48515 JSpecify: If a class has a @Nullable type-parameter bound, Kotlin should still treat unbounded wildcards like platform types
• KT-57588 K2/Native: False positive '"CONFLICTING_OVERLOADS", "PARAMETER_NAME_CHANGED_ON_OVERRIDE" on overriding objc methods
• KT-58892 K2: Parcelize doesn't work in common code when expect annotation is actualized with typealias to @Parcelize
• KT-65882 K2: "KotlinNothingValueException" caused by unsafe cast and Nothing::class
• KT-66124 K2: Remove FirLambdaArgumentExpression and FirNamedArgumentExpression after resolution
• KT-65959 K2: Incorrect warnings about inline function impact
• KT-64994 K2: @Composable lambda type is not resolved from other modules
• KT-66048 K2: property becomes nullable in KJK hierarchy if base declaration has implicit return type
• KT-47843 No error reported on assigning "continue" to a companion object
• KT-47530 NI: Unexpected TYPE_MISMATCH when combining nested conditional and contravariant type argument
• KT-49583 NI: NullPointerException on compiling anonymous function returning a method reference
• KT-42782 NI: Smart casting for generic type doesn't work if the variable is already smart cast
• KT-38031 FIR: Discrepancy in call resolution for qualifiers with old FE
• KT-65789 K1/K2: Resolve change in constructor/top-level function ambiguity
• KT-66150 K2: expects type argument in super qualifier
• KT-60971 Incorrect "cannot inline bytecode built with JVM target ..." on property setter if only getter is inline
• KT-61514 K2: Build fake overrides using IR during Fir2IR
• KT-65584 K2: "Duplicate parameter name in a function type"
• KT-50008 JSpecify @Nullable annotation on type-parameter bound prevents type-variable usages from being platform types
• KT-37000 IndexOutOfBoundsException from TypeResolver on typealias with cyclic references
• KT-56988 CFG, smart casts: red in K1 -> green in K2 for invalid code
• KT-62118 FIR: "HashMap.entry" has invalid enhanced type
• KT-64840 K2: Bare type are not allowed for TV based values during PCLA
• KT-65415 K2: Stdlib K2 build error: IrConstructorSymbolImpl is already bound
• KT-66449 Make DiagnosticSuppressor a project-level extension
• KT-66411 FIR: Real source on fake block around assignment expression in the "when" branch affects resolve in K2 Analysis API and IDE
• KT-65249 K2: False positive modality is different for native compilation
• KT-65982 K2 Scripts cannot disambiguate declarations imported from default and explicit imports
• KT-65677 K2: Unable to resolve parent class from companion object
• KT-47310 Change qualifier resolution behavior when companion property is preferred against enum entry
• KT-41034 K2: Change evaluation semantics for combination of safe calls and convention operators
• KT-63529 K2: Compiler does not detect tailrec call with nullable type
• KT-66441 Remove symbol table from IR fake override builder in Fir2Ir
• KT-64846 K2: false negative CONFLICTING_JVM_DECLARATIONS on inheritance from Java collection subclass with a conflicting override
• KT-62312 [K2/N] revert putting stdlib to the beginning of libraries list in the compiler
• KT-58203 K2: false-negative incompatible types error on is-check with unrelated type
• KT-65722 K2: Property reference refers to non-existent functions
• KT-65878 K2: "ClassCastException" when passing nun-suspend lambda to SAM constructor with named argument
• KT-66379 K2: No extra message in UPPER_BOUND_VIOLATED for cases with CapturedType
• KT-59475 K2: build nowinandroid
• KT-65926 K2: add tests for all fixed-in-k2 / not-reproducible-in-k2 unresolved issues
• KT-59481 K2: build aws-sdk-kotlin + smithy-kotlin
• KT-65022 K2: Compiler crashes when array literal is used in delegate expression
• KT-62836 K2: Expected FirResolvedTypeRef with ConeKotlinType but was FirImplicitTypeRefImplWithoutSource
• KT-64727 K1: Closing bracket of object inside crossinline lambda or inside lambda in inline function is not hit on step-over
• KT-64726 K1: Cannot stop on closing bracket of crossinline lambda inside of another crossinline lambda
• KT-64725 K1: Cannot stop on closing bracket of lambda of inline-only function
• KT-66272 Could not load module with a combination of type parameters
• KT-66243 Could not load module in a builder inference with lambda with typed parameter
• KT-66229 Could not load module in a builder inference with Map.Entry
• KT-66313 K2: declaration-order-dependent false-positive "recursive problem in type checker" error on getX declaration with implicit return type that calls x declaration via intermediate declaration in getX 's expression body
• KT-61041 K2: Consider getting rid of confusing shouldRunCompletion and shouldAvoidFullCompletion function in FirInferenceSession
• KT-66267 K2: generic function's type parameter is erased if present as type argument in type of callable reference to member of generic function's local class
• KT-61448 K2: Disappeared DEPRECATION in testWithModifiedMockJdk
• KT-60106 K2: Introduced REIFIED_TYPE_FORBIDDEN_SUBSTITUTION
• KT-58279 K2. False-negative Smart cast to is impossible, because is a public API property declared in different module for Java static field
• KT-61626 K2: Module "com.soywiz.korlibs.kmem:kmem" has a reference to symbol korlibs.memory/Buffer|null[1]
• KT-57427 Fix inconsistencies in name manglers that use different declaration representations
• KT-66258 K2: accessor-targeted @Suppress annotation is ignored on primary constructor property
• KT-29559 Smart Cast functionality doesn't behave in an expected way in all cases
• KT-60777 K2: missing INLINE_FROM_HIGHER_PLATFORM
• KT-66260 K2: false-positive "abstract function in non-abstract class" error on abstract member function of open interface
• KT-66067 K2: different overrides are created in a complex hierarchy with raw types and upper-bounded type parameters
• KT-65821 K2: [NONE_APPLICABLE] None of the following functions is applicable: [constructor(message: String?): Throwable, constructor(cause: Throwable?): Throwable, constructor(): Throwable, ...]
• KT-66268 K2: Expected FirResolvedTypeRef with ConeKotlinType but was FirUserTypeRefImpl
• KT-63563 K2: False negative RETURN_TYPE_MISMATCH with empty return
• KT-60797 K2: implement JAVA_MODULE_DOES_NOT_EXPORT_PACKAGE
• KT-28159 Smartcasts don't work with Nothing? values (Nothing? considered a null constant => an unstable value)
• KT-28262 Smartcasts for reference equality don't work if explicit true check is used
• KT-66000 K2: inherited inline getter has not been inlined
• KT-66158 K2: not nullable return type for upper-bounded kotlin type parameter in KJK hierarchy
• KT-57268 K2: extra methods remove and/or getOrDefault are generated for Map subclasses with JDK 1.6 in dependencies
• KT-63577 K2: false-positive "wrong number of type arguments" error on callable reference to member of generic function's local class
• KT-62352 jspecify NonNull annotation seems not supported
• KT-65636 PowerAssert: Negative contains operator not aligned correctly in K2
• KT-64271 K2: Wrong overriddenSymbols for toString of data class
• KT-62779 K2: Difference in fake override generation
• KT-61941 K2: FIR2IR incorrectly generates f/o structure for complex java/kotlin hierarchies with remapped jvm declarations
• KT-60283 K2: fake override for java static method is not generated
• KT-65095 K2: no bridge generated for getOrDefault when inheriting from Java Map implementation
• KT-57301 K2: getOrDefault and bridges are not generated for certain Map subclasses
• KT-50916 K2: store resolved type inside ConeStubType after builder inference
• KT-65857 K2: java.lang.IllegalArgumentException: Unknown visibility: unknown
• KT-66174 -Xjdk-release 6 and 7 have a misleading error message
• KT-66175 Wrong supported options list for -jvm-target compiler option
• KT-58814 Too eager subtype inference in when expression
• KT-65408 K1: "There are still 2 unbound symbols after generation of IR module" caused by data object's copy function usage
• KT-65844 False Positive "This class can only be used as an annotation or as an argument to @OptIn " when passing as an array
• KT-58697 K2: Tests: Assert no dump files exist when dump directive isn't present
• KT-63258 NPE with function reference from within lambda during init
• KT-60597 K1: IllegalArgumentException: fromIndex(0) > toIndex(-1) when wrapping receiver with backticks
• KT-33108 USELESS_CAST false positive for cast inside lambda
• KT-58458 K1: "java.lang.NullPointerException" with 'var equals' or 'val equals' as argument in when
• KT-58447 K1: "AssertionError: Recursion detected on input" with @ParameterName and extension
• KT-41013 OVERLOAD_RESOLUTION_AMBIGUITY for functions takes lambda: can not resolve it, but only named lambda parameter
• KT-56032 [LC issue] Incorrect wrapping when passing java vararg method to inline function
• KT-65588 K2: typealias of primitive type in vararg causes ABI incompatibility
• KT-23873 Indexed access operator can cause false USELESS_CAST warning
• KT-31191 Contract not smartcasting for extension functions in if-statement with multiple conditions
• KT-28725 ReenteringLazyValueComputationException during resolution & inference
• KT-35429 ReenteringLazyValueComputationException when accessing property with same name
• KT-63826 K2: expect for expect crashes the compiler
• KT-25668 False-positive error on restricted suspending function call with callable reference
• KT-18055 SMARTCAST_IMPOSSIBLE on mutable data class variable with a read-only property
• KT-15904 Improve error message when type of generic extension call is inferred from receiver
• KT-66186 K1 diagnostics miss some reporting messages
• KT-65101 Generics behaving different when parenthesized
• KT-63444 TYPE_MISMATCH caused by Inner class with nullable type and star projection
• KT-62022 K1 False positive EXPOSED_FUNCTION_RETURN_TYPE on generics with anonymous object types
• KT-58751 Definitely non-nullable type gets lost with star projection
• KT-56624 "Unresolved reference" with import alias and enum constructor call
• KT-54726 K1: StackOverflowError on mutually recursive typealiases
• KT-35134 False negative INCOMPATIBLE_TYPES, EQUALITY_NOT_APPLICABLE when comparing smartcast value to Boolean
• KT-20617 Qualified this @property does not work in extension properties with body expression
• KT-10879 OVERLOAD_RESOLUTION_AMBIGUITY for synthetic property accessor with smartcasted receiver
• KT-26768 K1 IDE: False positive "Smart cast to '$CLASS$' is impossible", on local variable in run closure
• KT-63525 K2: "IllegalStateException: Fake override should have at least one overridden descriptor" caused by unreachable code
• KT-65333 K2: UNRESOLVED_REFERENCE for java inner class in intersection scope
• KT-61060 K2: Rewrite delegate inference
• KT-63712 Make it possible to add new stdlib API with SinceKotlin(2.0)
• KT-63741 K2: fix visibility inference with overridden + inherited member
• KT-64488 K2: False positive DEPRECATED_ACCESS_TO_ENTRY_PROPERTY_FROM_ENUM with context receivers
• KT-62283 K2: build Dokka with K2 user project and pass it to CI
• KT-57585 K2/MPP: false-negative errors on expect/actual modifiers mismatch
• KT-66077 IrFakeOverrideBuilder: NPE from IrJavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds
• KT-57044 K2 LL Tests: false-positive 'Overload resolution ambiguity between candidates: [ @Override () fun test(): Unit , fun test(): Unit]'
• KT-66020 K2: ISE "IrPropertySymbolImpl is unbound. Signature: null" on a property with getter with @JvmName
• KT-62135 K2, KLIB: Classes are still sorted before serializing them to metadata
• KT-65866 [K/N] Fix java.lang.IllegalArgumentException: Unknown visibility: unknown
• KT-66005 K2: "Should not be here: class org.jetbrains.kotlin.fir.expressions.impl.FirResolvedReifiedParameterReferenceImpl" on incorrect comparison of reified type parameter
• KT-65840 [K2] Initializer type mismatch: expected 'Type', actual 'Type'
• KT-65002 K2: Incorrect suspend conversion if argument is an aliased functional type
• KT-65984 K2 scripting: failure on processing SUPPRESS annotation in the last script statement
• KT-65680 K2: Class redeclaration leads to BackendException during IR fake override builder
• KT-66028 K2: Convert FirExpectActualDeclarationChecker to platform checker
• KT-65592 K2: IrFakeOverrideBuilder: ISE "should not be called" on diamond hierarchy with explicit dependency on annotations.jar
• KT-65277 IrFakeOverrideBuilder: NPE from IrJavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds
• KT-65983 K2 gradle scripting: "'val' cannot be reassigned" errors
• KT-60452 K2 Scripting: implement overriding of the script params
• KT-65975 K2: Implicit receivers resolution order in K2 scripting
• KT-60249 K2: No unit coercion generated for loops body
• KT-65937 K2: order of enum entries changed
• KT-65933 K2: Type missmatch in arrays in annotations
• KT-65343 JVM IR: Source parameter is lost when copying with DeepCopyIrTreeWithSymbols
• KT-65103 K2: IllegalArgumentException: IrErrorCallExpressionImpl(5388, 5392, "Unresolved reference: R?C|/cont|") found but error code is not allowed
• KT-62788 K2: difference in annotation inheritance in overriddings
• KT-65669 K2: ClassCastException class FirDeclarationStatusImpl cannot be cast to class FirResolvedDeclarationStatus
• KT-65493 IrFakeOverrideBuilder: difference in return type for intersection with raw type
• KT-65207 IrFakeOverrideBuilder - nullable return type for intersection override
• KT-65972 Fix problems related to Unknown visibility in [FP] intellij
• KT-65246 K2: Overiding java method that takes vararg parameter causes WRONG_NULLABILITY_FOR_JAVA_OVERRIDE warning
• KT-59883 K2: Disappeared INVALID_IF_AS_EXPRESSION
• KT-57300 K2: subclass of MutableCollection with primitive element type has methods with boxed type
• KT-58476 Context receivers: "No mapping for symbol: VALUE_PARAMETER" with context-receiver inside suspended lambda calling another suspended function
• KT-52213 Context receivers: "No mapping for symbol: VALUE_PARAMETER" caused by contextual suspending function type with receiver
• KT-56545 Fix incorrect functions mangling in JVM backend in case of accidental clashing overload in a Java subclass
• KT-13650 Right-hand side of a safe assignment is not always evaluated, which can fool smart-casts
• KT-61823 K2: Render list of declarations in diagnostic messages with linebreak as separator
• KT-65302 IrFakeOverrideBuilder - missing @EnhancedNullability
• KT-65241 K2: [LT] Compiler crash on assignment expression with incorrect lvalue
• KT-60006 K2: Disappeared EXPRESSION_EXPECTED
• KT-65817 K2: Check if callable reference vararg adaption can be affected by primitive type aliases
• KT-62847 K2: Introduce FIR node for SAM conversion
• KT-65920 K2: no field for delegation is created
• KT-65487 K2: Different fake overrides and false positive NOTHING_TO_OVERRIDE for intersection/override with Collection.remove
• KT-65460 Don't compare order of functions in IR dump
• KT-64276 [K/N][K2] K2 behaviorial difference with inconsistent inheritance of ObjCName
• KT-65572 [K/N][K2] INCOMPATIBLE_OBJC_NAME_OVERRIDE error message changed from K1
• KT-63420 Prevent weakening visibility in implicit overrides
• KT-64635 K2: "KotlinIllegalArgumentExceptionWithAttachments: Expected expression 'FirAnonymousFunctionExpressionImpl' to be resolved" when provideDelegate is extension of function with receiver
• KT-63879 K2: Redundant flag declaresDefaultValue for parameter of function inherited from delegate
• KT-56744 Prepare language committee ticket about DFA/Smart-cast related changes in K2
• KT-65790 K2: Move check for private-to-this visibility into checker
• KT-65551 K2: Property redeclaration on native compilation leads to NotImplementedError
• KT-65770 K2: Diagnostic rendering of vararg Foo parameter produces vararg Array<Foo>
• KT-65555 K2: must override 'spliterator' because it inherits multiple implementations for it
• KT-59921 K2: Disappeared NULL_FOR_NONNULL_TYPE
• KT-65290 K2: No override for FUN DEFAULT_PROPERTY_ACCESSOR
• KT-19446 False positive "Smart cast to 'Foo' is impossible" due to same variable names in different closures
• KT-65337 K2: False positive UNRESOLVED_REFERENCE when lambda labeled by illegal label and operator-invoked
• KT-65448 K2: fake overrides are not generated for 'containsAll', 'removeAll', 'retainAll' if inherited from raw type
• KT-65298 K2: not nullable return type and parameter for raw types
• KT-63377 K2: conflict between type parameter and nested class
• KT-63286 K2: Top-level properties in scripts are missing initialization checks
• KT-59744 K2: false negative VAL_REASSIGNMENT in case of reassignment inside custom setter
• KT-58579 K2: false-positive new inference error on invoking a generic function on Java wildcard type bounded by raw-typed Java inner class
• KT-60258 Support java-kotlin interop for @SubclassOptInRequired
• KT-60262 Support for inter-module interaction for @SubclassOptInRequired
• KT-62878 K2: missing implicit coercion to unit
• KT-59715 K2: Check behaviour of property + operator in operator position
• KT-63441 IrFakeOverrideBuilder: "accidental override" when implementing a Java function taking an array parameter
• KT-65706 K2: IrFakeOverrideBuilder: ISE "Fake override should have at least one overridden descriptor" on J-K-J-K hierarchy with interface delegation
• KT-61362 K2: Properties/fields are missing from system libraries
• KT-63344 K2: False positive ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED
• KT-58845 K2: SAM checker can run incorrectly in presence of an expect supertype
• KT-61843 K2: Missing TYPE_MISMATCH for nested array literals
• KT-62752 expect-actual matcher/checker: return type must be "checking" incompatibility
• KT-59887 K2: Disappeared ACTUAL_MISSING
• KT-65604 K2: INAPPLICABLE_JVM_NAME: effective modality
• KT-65637 Prepare documentation for PCLA implementation
• KT-65341 K2: "Cannot find cached type parameter by FIR symbol" caused by not-null assertion operator inside string in throw
• KT-49283 Support contribution type info from a nested builder inference call
• KT-64077 K2: Builder inference ignores constraints from nested builder inference
• KT-49160 Couldn't infer a type argument through several builder inference calls broken by a local class
• KT-63827 K2: Array += desugaring doesn't have origin
• KT-65057 K2: Wrong type inferred in code with heavy use of generics
• KT-63514 ISE “Inline class types should have the same representation: [I != I” during compilation on submitting UIntArray to vararg
• KT-61088 K2: return types of non-last-expression calls to @PolymorphicSignature methods inside try-expressions don't resolve to void when required
• KT-62476 K2: Enable building fake overrides by ir on non-JVM targets
• KT-59839 Prohibit header and impl in MPP
• KT-61310 K2: "Not enough information to infer type variable R" for transformLatest
• KT-63733 Builder-style type inference can't resolve to extension overloads when they're more applicable than member ones
• KT-57707 K1: inconsistent TYPE_MISMATCH in builder inference
• KT-55057 Builder inference changes behaviour sporadically based on BI annotation on unrelated call
• KT-60663 Builder inference does not work inside a nested unrelated builder inference lambda
• KT-53639 TYPE_MISMATCH: compiler can't infer the list's type when using buildList {} builder or Collection#isNotEmpty
• KT-60291 K2: "IllegalStateException: Cannot serialize error type: ERROR CLASS: Cannot infer argument for type parameter T" during FIR serialization
• KT-65033 K2: Fir2LazyIr: Lazy type aliases not supported
• KT-57709 Inconsistent extension function call resolution in builder inference
• KT-53740 Builder inference with multiple lambdas leads to unsound type
• KT-60877 Builder inference from the null literal results in Nothing instead of Nothing? for producing positions of the postponed type variable
• KT-53553 Builder inference: inconsistent types in different lambda scopes
• KT-54400 K2: builder inference does not work with assignments of literals to member properties
• KT-63840 Builder inference fails on calls to identity-shaped functions with postponed type variables inside select-constructions
• KT-65262 K2: Exception in DFA for combination of try-finally + PCLA + DI
• KT-58169 K2: make equals bounded smart casts work the same as in K1
• KT-64967 K2: false positive TYPE_MISMATCH with generic type parameters
• KT-64102 K2: Missing (disappeared in this case) DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_ERROR
• KT-63988 K2: Reflection cannot find type of local class of local class
• KT-63901 K2: Different naming of inner class in metadata
• KT-63655 K2: incorrect short class name in metadata for anonymous object inside a local class
• KT-59664 Inline modifier can be added to a constructor parameter, but it does not have any effect
• KT-59418 K2: Missing DUPLICATE_PARAMETER_NAME_IN_FUNCTION_TYPE
• KT-63612 K2: Class is not abstract and does not implement abstract member
• KT-63737 Wasm: revise external declaration FE checker for WASI mode
• KT-59782 K2: Forbid local delegated properties with private accessors in public inline functions
• KT-65482 K2: NoSuchFieldError due to using unboxed type
• KT-61182 Unit conversion is accidentally allowed to be used for expressions on variables + invoke resolution
• KT-62998 Forbid assignment of a nullable to a not-null Java field as a selector of unsafe assignment
• KT-63208 K2: Implement deprecation cycle and fix missing errors for error-level nullable arguments of warning-level Java types
• KT-57600 Forbid overriding of Java method with raw-typed parameter with generic typed parameter
• KT-63147 K2: False negative DSL_SCOPE_VIOLATION when member is annotated with @LowPriorityInOverloadResolution
• KT-62134 K2: handle non-simple types during FirStatusResolver.isPrivateToThis check
• KT-42020 Psi2ir: IllegalStateException: "IrSimpleFunctionPublicSymbolImpl for public [...] is already bound" on generic function whose substitution leads to IdSignature clash

See the full 2.0.0 ChangeLog here - https://github.com/JetBrains/kotlin/blob/2.0.0/ChangeLog.md

• 👍 353 reactions
• 😄 93 reactions
• 🎉 402 reactions
• ❤️ 211 reactions
• 🚀 231 reactions
• 👀 79 reactions

Class LinkedHashMap<K, V>

Hash table and linked list implementation of the Map interface, with well-defined encounter order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the encounter order (the order of iteration), which is normally the order in which keys were inserted into the map ( insertion-order ). The least recently inserted entry (the eldest) is first, and the youngest entry is last. Note that encounter order is not affected if a key is re-inserted into the map with the put method. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.) The reverse-ordered view of this map is in the opposite order, with the youngest entry appearing first and the eldest entry appearing last. The encounter order of entries already in the map can be changed by using the putFirst and putLast methods.

This implementation spares its clients from the unspecified, generally chaotic ordering provided by HashMap (and Hashtable ), without incurring the increased cost associated with TreeMap . It can be used to produce a copy of a map that has the same order as the original, regardless of the original map's implementation: void foo(Map<String, Integer> m) { Map<String, Integer> copy = new LinkedHashMap<>(m); ... } This technique is particularly useful if a module takes a map on input, copies it, and later returns results whose order is determined by that of the copy. (Clients generally appreciate having things returned in the same order they were presented.)

A special constructor is provided to create a linked hash map whose encounter order is the order in which its entries were last accessed, from least-recently accessed to most-recently ( access-order ). This kind of map is well-suited to building LRU caches. Invoking the put , putIfAbsent , get , getOrDefault , compute , computeIfAbsent , computeIfPresent , or merge methods results in an access to the corresponding entry (assuming it exists after the invocation completes). The replace methods only result in an access of the entry if the value is replaced. The putAll method generates one entry access for each mapping in the specified map, in the order that key-value mappings are provided by the specified map's entry set iterator. No other methods generate entry accesses. Invoking these methods on the reversed view generates accesses to entries on the backing map. Note that in the reversed view, an access to an entry moves it first in encounter order. Explicit-positioning methods such as putFirst or lastEntry , whether on the map or on its reverse-ordered view, perform the positioning operation and do not generate entry accesses. Operations on the keySet , values , and entrySet views or on their sequenced counterparts do not affect the encounter order of the backing map.

The removeEldestEntry(Map.Entry) method may be overridden to impose a policy for removing stale mappings automatically when new mappings are added to the map. Alternatively, since the "eldest" entry is the first entry in encounter order, programs can inspect and remove stale mappings through use of the firstEntry and pollFirstEntry methods.

This class provides all of the optional Map and SequencedMap operations, and it permits null elements. Like HashMap , it provides constant-time performance for the basic operations ( add , contains and remove ), assuming the hash function disperses elements properly among the buckets. Performance is likely to be just slightly below that of HashMap , due to the added expense of maintaining the linked list, with one exception: Iteration over the collection-views of a LinkedHashMap requires time proportional to the size of the map, regardless of its capacity. Iteration over a HashMap is likely to be more expensive, requiring time proportional to its capacity .

A linked hash map has two parameters that affect its performance: initial capacity and load factor . They are defined precisely as for HashMap . Note, however, that the penalty for choosing an excessively high value for initial capacity is less severe for this class than for HashMap , as iteration times for this class are unaffected by capacity.

Note that this implementation is not synchronized. If multiple threads access a linked hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the map. If no such object exists, the map should be "wrapped" using the Collections.synchronizedMap method. This is best done at creation time, to prevent accidental unsynchronized access to the map: Map m = Collections.synchronizedMap(new LinkedHashMap(...)); A structural modification is any operation that adds or deletes one or more mappings or, in the case of access-ordered linked hash maps, affects iteration order. In insertion-ordered linked hash maps, merely changing the value associated with a key that is already contained in the map is not a structural modification. In access-ordered linked hash maps, merely querying the map with get is a structural modification. )

The iterators returned by the iterator method of the collections returned by all of this class's collection view methods are fail-fast : if the map is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException . Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

The spliterators returned by the spliterator method of the collections returned by all of this class's collection view methods are late-binding , fail-fast , and additionally report Spliterator.ORDERED .

This class is a member of the Java Collections Framework .

• Object.hashCode()
• Serialized Form

Nested Class Summary

Nested classes/interfaces declared in class java.util. abstractmap, constructor summary, method summary, methods declared in class java.util. hashmap, methods declared in class java.util. abstractmap, methods declared in class java.lang. object, methods declared in interface java.util. map, methods declared in interface java.util. sequencedmap, constructor details, linkedhashmap, method details.

If this map already contains a mapping for this key, the mapping is relocated if necessary so that it is first in encounter order.

If this map already contains a mapping for this key, the mapping is relocated if necessary so that it is last in encounter order.

containsValue

More formally, if this map contains a mapping from a key k to a value v such that (key==null ? k==null : key.equals(k)) , then this method returns v ; otherwise it returns null . (There can be at most one such mapping.)

A return value of null does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to null . The containsKey operation may be used to distinguish these two cases.

• HashMap.put(Object, Object)

removeEldestEntry

Sample use: this override will allow the map to grow up to 100 entries and then delete the eldest entry each time a new entry is added, maintaining a steady state of 100 entries. private static final int MAX_ENTRIES = 100; protected boolean removeEldestEntry(Map.Entry eldest) { return size() > MAX_ENTRIES; }

This method typically does not modify the map in any way, instead allowing the map to modify itself as directed by its return value. It is permitted for this method to modify the map directly, but if it does so, it must return false (indicating that the map should not attempt any further modification). The effects of returning true after modifying the map from within this method are unspecified.

This implementation merely returns false (so that this map acts like a normal map - the eldest element is never removed).

sequencedKeySet

The returned view has the same characteristics as specified for the view returned by the keySet method.

sequencedValues

The returned view has the same characteristics as specified for the view returned by the values method.

sequencedEntrySet

The returned view has the same characteristics as specified for the view returned by the entrySet method.

newLinkedHashMap

Modifications to the reversed view and its map views are permitted and will be propagated to this map. In addition, modifications to this map will be visible in the reversed view and its map views.

Scripting on this page tracks web page traffic, but does not change the content in any way.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Unchecked assignment for 'java.util.ArrayList'

I get the warning:

Unchecked assignment for 'java.util.ArrayList' to 'java.util.ArrayList < com.test.mytest >'

How to fix it?

• Yes, you have right. Thanks! –  gogoloi Commented May 19, 2017 at 20:00
• Simple. Don't use raw types. –  Lew Bloch Commented May 19, 2017 at 20:10

You want new ArrayList<>(); so that you use the right generic type. At the moment you're using the raw type on the right hand side of = . So you want:

Or just be explicit:

(You might also consider making the type of the variable List<LocoList> instead of ArrayList<LocoList> , unless you're using ArrayList -specific members. I'd also ditch the "my" prefix, personally.)

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged java android arraylist warnings or ask your own question .

• Featured on Meta
• Announcing a change to the data-dump process
• We've made changes to our Terms of Service & Privacy Policy - July 2024

Hot Network Questions

• Why doesn't Oppenheimer like the word "bomb" being used to describe the bomb?
• How to use the すぎ suffix to mean "too much"?
• Star Gold additional baggage allowance on connecting JetBlue flight from Air India
• What might be causing ls to ignore LS_COLORS for setgid (sg, g+s) directories?
• Please “weigh in” on my shelf weight question
• Why is the E in 'collega' long?
• Why are the Founders in Star Trek: Deep Space Nine considered so powerful?
• Automata reaching the same state when reading the same word long enough
• Child's teddies "being mean" after dark
• How to reconcile different teachings of Jesus regarding self defense?
• Is it a good practice to share a certificate between two applications
• Is it correct to say: "To solve an addiction"?
• What is/was float option n? Unknown float option `n'
• Is there any airplane that doesn't use a headset but speakers?
• Could Swashplate be replaced with small electric motors?
• File headers and formats of Sinclair QL QDOS executable files
• How does the grammar in 这不关你的事 work?
• Xichang is a spaceport
• How to show the range is independent of the smallest order variable?
• In terms of Material Science, why do household garbage bag seal water and air, but allow odor to pass through?
• How would tunneling mold tunnel?
• Best practice for using models between layers in mvc
• Is "Non-Trivial amount of work" a correct phrase?
• DC motor pump always transports in same direction, regardless of polarity