How to insert triple items in a map in Java?

So, the main idea is to create for example:

Map<Map<String, String>, Integer> map = new LinkedHashMap<>();

And I need to put in this map for example items:

{{France=Paris}=12, {Spain=Madrid}=2, ... }

How to make this? How to implement the "put" function?
map.put("France","Paris",2) does not work.

You need to first create a Map (e.g. Map.of("France", "Paris")) and put it inside the bigger Map.

Do it as follows:

import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
	public static void main(String[] args) {
		Map<Map<String, String>, Integer> map = new LinkedHashMap<>();
		map.put(Map.of("France", "Paris"), 2);
		System.out.println(map);
	}
}

Output:

{{France=Paris}=2}

Alternatively,

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
	public static void main(String[] args) {
		Map<Map<String, String>, Integer> map = new LinkedHashMap<>();
		Map<String, String> data = new HashMap<>();
		data.put("France", "Paris");
		map.put(data, 2);
		System.out.println(map);
	}
}

Caution: As already mentioned by Mureinik, having mutable objects as the keys (the alternative solution) in a map is error-prone. You can check this answer for an explanation.

Though Arvind Kumar Avinash's answer perfectly solves the question, please note that you should reconsider your data structure.

Having a Map as a key for another Map is not advisable. You should rather craft another class that serves the purpose of being a key of a Map. If you are interested in having capitals as keys, consider implementing an immutable class such as this one, in which equals() and hashcode() are properly overridden:

public class Capital {

    private final String country;
    private final String name;

    public Capital(String country, String name) {
        this.country = country;
        this.name = name;
    }

    public boolean equals(final Object o) {
        if (o == this) return true;
        if (!(o instanceof Capital)) return false;
        final Capital other = (Capital) o;
        if (!other.canEqual((Object) this)) return false;
        final Object this$country = this.country;
        final Object other$country = other.country;
        if (this$country == null ? other$country != null : !this$country.equals(other$country)) return false;
        final Object this$name = this.name;
        final Object other$name = other.name;
        if (this$name == null ? other$name != null : !this$name.equals(other$name)) return false;
        return true;
    }

    protected boolean canEqual(final Object other) {
        return other instanceof Capital;
    }

    public int hashCode() {
        final int PRIME = 59;
        int result = 1;
        final Object $country = this.country;
        result = result * PRIME + ($country == null ? 43 : $country.hashCode());
        final Object $name = this.name;
        result = result * PRIME + ($name == null ? 43 : $name.hashCode());
        return result;
    }

    public String toString() {
        return "Capital(country=" + this.country + ", name=" + this.name + ")";
    }
}

If you want to get rid of the boilerplate code, consider using the Lombok Project. The above-listed class is the delomboked version of the following code:

@ToString
@EqualsAndHashCode
@RequiredArgsConstructor
public class Capital {

    private final String country;
    private final String name;
    
}

Update after Holger's comment:

Other implementations for equals() and hashCode() than the above-mentioned, delomboked version are possible, differing in some criterias such as code style and performance. Same as Holger, I think the delomboked implementation should not be hand-crafted. It is simply the implementation that results through the usage of the Lombok @EqualsAndHashCode annotation.

There are requirements to be fulfilled in order to properly override hashCode() and equals():

• hashCode()
• equals()

Though performance and good code-sytle are important, they are not amongst these requirements. With the usage of Lombok, in my opinion, code-style is less important, since the code is generated. One usually does not see it during development.

The canEqual() method is present since Lombok also generates it.

As you are using one pair of string as the key, you can use Map.Entry as key of map rather use Map<String, String>

Map<Map.Entry<String, String>, Integer> map = new LinkedHashMap<>();
map.put(Map.entry("France", "Paris"), 12);
map.put(Map.entry("Spain", "Madrid"), 2);
System.out.println(map.get(Map.entry("France", "Paris")));

Output : 12