What is the relationship between Collections and ImmutableCollections

I'm studying Java Collections FrameWork.
I'm having trouble understanding a hierarchy of Collections.

Since ArrayList implements List interface, we can use

List<String> list = new ArrayList();

However, In

List<String> names = List.of("Larry", "Kenny", "Sabrina");

,List.of()method returns ImmutableCollections.List12
I've never heard of that class in the Collection hierarchy and I found it is not implementing List interface(then how it is casted to List?)

in addition, I think It is weird I can't make ImmutalbeList by

List<String> names = new ImmutableList("Larry", "Kenny", "Sabrina");

I Know little about Kotlin and there was a hierarchy between mutable and immutable. But I can't find any connection between them in Java.
what is happening here?

Immutable Collection are same as Normal collection but cannot be modified after creation (i.e it is read only). you cannot add, delete or update items, if you try it throws unsupportetOperationException.
You cannot instantiate ImmutableList by new ImmutableList() because it is a abstract class. you can use ImmutableList.of() method to get immuatabel list.
If you want to know more about immutableList see Geeksforgeeks - ImmutableList in java

In order to thoroughly analyse why this is happening lets start with a definition on immutability:

'An object is considered immutable if its state cannot change after it is constructed. Maximum reliance on immutable objects is widely accepted as a sound strategy for creating simple, reliable code.

We can also confirm we cannot change the state when we look at one of the well known classes in Java. De string class.

public class Main {
public static void main(String[] args) {
    String hello = "hello";
    hello.concat("world");
    System.out.println(hello);
}

}

This will not change the objects state if we apply the concat method and will only return "hello". However if we initialize the result to a new variable then it will have the appropriate result like this

public class Main {
public static void main(String[] args) {
    String hello = "hello";
    String newHello = hello.concat("world");
    System.out.println(newHello);
}

}

The problem with this is that the concat method is lying to me. It says it will concatenate something, but it actually doesn't because string is immutable. It therefore follows that since an immutable object cannot change its state we also shouldn't have methods that changes its state.

Since we cannot have these methods for an immutable type and we we cannot just implement part of the interface we need to create another interface that only contains methods that can read from the list but don't change the state of the object like for example List.add() does.