Hytale Modding
Java Basics

11 - HashMap and Key-Value Storage

Learn to store and retrieve data using key-value pairs.

A HashMap stores data in key-value pairs, like a real-world dictionary. You look up a word (key) to find its definition (value). This is perfect for player data, item properties, and configuration settings.

HashMap Basics

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Create a HashMap (String keys, Integer values)
        HashMap<String, Integer> playerLevels = new HashMap<>();
        
        // Add key-value pairs
        playerLevels.put("Alice", 10);
        playerLevels.put("Bob", 15);
        playerLevels.put("Charlie", 8);
        
        // Get a value by key
        int aliceLevel = playerLevels.get("Alice");  // 10
        
        System.out.println("Alice is level " + aliceLevel);
    }
}
HashMap vs ArrayList
HashMapArrayList
UnorderedOrdered by index (0, 1, 2...)
Access by key (can be any type)Access by position
Good for looking up valuesGood for lists of items
Each key is uniqueCan have duplicates
// ArrayList - access by number
ArrayList<String> players = new ArrayList<>();
players.add("Alice");
String player = players.get(0);  // Get first player

// HashMap - access by name
HashMap<String, Integer> levels = new HashMap<>();
levels.put("Alice", 10);
int level = levels.get("Alice");  // Get Alice's level

Common HashMap Methods

Adding and Updating

HashMap<String, Integer> scores = new HashMap<>();

scores.put("Alice", 100);     // Add new entry
scores.put("Bob", 150);
scores.put("Alice", 200);     // Update existing (Alice now 200)

Getting Values

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);

int score = scores.get("Alice");        // 100
Integer missing = scores.get("Dave");   // null (doesn't exist)

// Get with default value
int score2 = scores.getOrDefault("Dave", 0);  // 0 (returns default)

Checking for Keys/Values

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);

boolean hasAlice = scores.containsKey("Alice");    // true
boolean hasDave = scores.containsKey("Dave");      // false

boolean has100 = scores.containsValue(100);        // true
boolean has200 = scores.containsValue(200);        // false

Removing Entries

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);
scores.put("Bob", 150);

scores.remove("Alice");           // Remove by key
System.out.println(scores);       // {Bob=150}

scores.clear();                   // Remove everything
System.out.println(scores);       // {}

Size and Empty Check

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);

int size = scores.size();         // 1
boolean empty = scores.isEmpty(); // false

Looping Through HashMap

Loop Through Keys

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);
scores.put("Bob", 150);
scores.put("Charlie", 75);

for (String name : scores.keySet()) {
    System.out.println(name);
}
// Output: Alice, Bob, Charlie (order may vary)

Loop Through Values

for (Integer score : scores.values()) {
    System.out.println(score);
}
// Output: 100, 150, 75 (order may vary)

Loop Through Both Keys and Values

for (String name : scores.keySet()) {
    int score = scores.get(name);
    System.out.println(name + ": " + score);
}

// Or using entrySet (more efficient)
for (var entry : scores.entrySet()) {
    String name = entry.getKey();
    int score = entry.getValue();
    System.out.println(name + ": " + score);
}
HashMap Order

HashMap does not maintain insertion order! If you need order, use LinkedHashMap:

import java.util.LinkedHashMap;

LinkedHashMap<String, Integer> orderedScores = new LinkedHashMap<>();
orderedScores.put("Alice", 100);
orderedScores.put("Bob", 150);
orderedScores.put("Charlie", 75);

// Will print in insertion order
for (String name : orderedScores.keySet()) {
    System.out.println(name);
}
// Output: Alice, Bob, Charlie (guaranteed order)

Practical Examples

Player Statistics System

import java.util.HashMap;

public class PlayerStats {
    private HashMap<String, Integer> stats;
    
    public PlayerStats() {
        this.stats = new HashMap<>();
        // Initialize default stats
        stats.put("health", 100);
        stats.put("mana", 50);
        stats.put("strength", 10);
        stats.put("defense", 5);
        stats.put("speed", 8);
    }
    
    public int getStat(String statName) {
        return stats.getOrDefault(statName, 0);
    }
    
    public void setStat(String statName, int value) {
        stats.put(statName, value);
    }
    
    public void modifyStat(String statName, int amount) {
        int current = getStat(statName);
        stats.put(statName, current + amount);
    }
    
    public void displayStats() {
        System.out.println("=== Player Stats ===");
        for (var entry : stats.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        PlayerStats stats = new PlayerStats();
        stats.displayStats();
        
        stats.modifyStat("strength", 5);
        stats.modifyStat("health", -20);
        
        System.out.println("\nAfter modifications:");
        stats.displayStats();
    }
}

Item Properties Database

import java.util.HashMap;

public class ItemDatabase {
    private HashMap<String, HashMap<String, Object>> items;
    
    public ItemDatabase() {
        this.items = new HashMap<>();
    }
    
    public void addItem(String itemName) {
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("damage", 0);
        properties.put("durability", 100);
        properties.put("rarity", "Common");
        properties.put("stackable", true);
        
        items.put(itemName, properties);
    }
    
    public void setProperty(String itemName, String property, Object value) {
        if (items.containsKey(itemName)) {
            items.get(itemName).put(property, value);
        }
    }
    
    public Object getProperty(String itemName, String property) {
        if (items.containsKey(itemName)) {
            return items.get(itemName).get(property);
        }
        return null;
    }
    
    public void displayItem(String itemName) {
        if (!items.containsKey(itemName)) {
            System.out.println("Item not found!");
            return;
        }
        
        System.out.println("=== " + itemName + " ===");
        HashMap<String, Object> props = items.get(itemName);
        for (var entry : props.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ItemDatabase db = new ItemDatabase();
        
        db.addItem("Iron Sword");
        db.setProperty("Iron Sword", "damage", 15);
        db.setProperty("Iron Sword", "rarity", "Uncommon");
        
        db.displayItem("Iron Sword");
    }
}

Configuration Manager

import java.util.HashMap;

public class GameConfig {
    private HashMap<String, String> settings;
    
    public GameConfig() {
        this.settings = new HashMap<>();
        loadDefaults();
    }
    
    private void loadDefaults() {
        settings.put("difficulty", "normal");
        settings.put("musicVolume", "50");
        settings.put("sfxVolume", "50");
        settings.put("renderDistance", "10");
        settings.put("showFPS", "false");
    }
    
    public String getSetting(String key) {
        return settings.getOrDefault(key, "");
    }
    
    public void setSetting(String key, String value) {
        settings.put(key, value);
        System.out.println("Set " + key + " to " + value);
    }
    
    public int getIntSetting(String key) {
        String value = getSetting(key);
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            return 0;
        }
    }
    
    public boolean getBooleanSetting(String key) {
        return "true".equalsIgnoreCase(getSetting(key));
    }
    
    public void displaySettings() {
        System.out.println("=== Game Settings ===");
        for (var entry : settings.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}

Player Inventory with Quantities

import java.util.HashMap;

public class Inventory {
    private HashMap<String, Integer> items;
    private int maxSlots;
    
    public Inventory(int maxSlots) {
        this.items = new HashMap<>();
        this.maxSlots = maxSlots;
    }
    
    public boolean addItem(String itemName, int quantity) {
        if (items.size() >= maxSlots && !items.containsKey(itemName)) {
            System.out.println("Inventory full!");
            return false;
        }
        
        int current = items.getOrDefault(itemName, 0);
        items.put(itemName, current + quantity);
        System.out.println("Added " + quantity + "x " + itemName);
        return true;
    }
    
    public boolean removeItem(String itemName, int quantity) {
        if (!items.containsKey(itemName)) {
            System.out.println("Don't have that item!");
            return false;
        }
        
        int current = items.get(itemName);
        if (current < quantity) {
            System.out.println("Not enough " + itemName);
            return false;
        }
        
        if (current == quantity) {
            items.remove(itemName);
        } else {
            items.put(itemName, current - quantity);
        }
        
        System.out.println("Removed " + quantity + "x " + itemName);
        return true;
    }
    
    public int getQuantity(String itemName) {
        return items.getOrDefault(itemName, 0);
    }
    
    public boolean hasItem(String itemName) {
        return items.containsKey(itemName);
    }
    
    public void displayInventory() {
        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
        if (items.isEmpty()) {
            System.out.println("Empty");
        } else {
            for (var entry : items.entrySet()) {
                System.out.println(entry.getKey() + " x" + entry.getValue());
            }
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Inventory inv = new Inventory(10);
        
        inv.addItem("Wood", 64);
        inv.addItem("Stone", 32);
        inv.addItem("Wood", 20);  // Adds to existing
        
        inv.displayInventory();
        
        inv.removeItem("Wood", 50);
        inv.displayInventory();
    }
}

Cooldown Manager

import java.util.HashMap;

public class CooldownManager {
    private HashMap<String, Long> cooldowns;
    
    public CooldownManager() {
        this.cooldowns = new HashMap<>();
    }
    
    public void startCooldown(String ability, long durationMs) {
        long endTime = System.currentTimeMillis() + durationMs;
        cooldowns.put(ability, endTime);
        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
    }
    
    public boolean isOnCooldown(String ability) {
        if (!cooldowns.containsKey(ability)) {
            return false;
        }
        
        long endTime = cooldowns.get(ability);
        long now = System.currentTimeMillis();
        
        if (now >= endTime) {
            cooldowns.remove(ability);
            return false;
        }
        
        return true;
    }
    
    public long getRemainingTime(String ability) {
        if (!isOnCooldown(ability)) {
            return 0;
        }
        
        long endTime = cooldowns.get(ability);
        long now = System.currentTimeMillis();
        return (endTime - now) / 1000;  // Return seconds
    }
    
    public boolean useAbility(String ability, long cooldownSeconds) {
        if (isOnCooldown(ability)) {
            long remaining = getRemainingTime(ability);
            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
            return false;
        }
        
        System.out.println("Used " + ability + "!");
        startCooldown(ability, cooldownSeconds * 1000);
        return true;
    }
}

HashMap with Custom Objects

Store your own classes as values:

public class Player {
    private String name;
    private int level;
    private int health;
    
    public Player(String name, int level) {
        this.name = name;
        this.level = level;
        this.health = 100;
    }
    
    // Getters and setters...
    
    @Override
    public String toString() {
        return name + " (Lv. " + level + ", HP: " + health + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        HashMap<String, Player> players = new HashMap<>();
        
        players.put("player1", new Player("Alice", 10));
        players.put("player2", new Player("Bob", 15));
        
        // Get and use player
        Player alice = players.get("player1");
        System.out.println(alice);
    }
}

Nested HashMaps

HashMaps can contain other HashMaps:

// Store multiple properties per player
HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();

// Add player with stats
HashMap<String, Integer> aliceStats = new HashMap<>();
aliceStats.put("level", 10);
aliceStats.put("health", 100);
aliceStats.put("mana", 50);
playerData.put("Alice", aliceStats);

// Access nested data
int aliceLevel = playerData.get("Alice").get("level");
System.out.println("Alice's level: " + aliceLevel);

Practice Exercises

  1. Phone Book: Create a phone book that stores names and phone numbers. Add methods to:

    • Add contact
    • Find number by name
    • Delete contact
    • Display all contacts

  2. Grade Manager: Store student names and grades. Create methods to:

    • Add student with grade
    • Update grade
    • Calculate class average
    • Find highest grade

  3. Word Counter: Write a program that counts how many times each word appears in a sentence using a HashMap.

  4. Item Shop: Create a shop where items have names and prices. Add methods to:

    • Add item with price
    • Get item price
    • Apply discount to all items
    • Display all items and prices

Last updated on

Edit on GitHub

10 - ArrayList and Collections

Learn to use flexible, resizable collections in Java.

12 - Exception Handling

Learn how to handle errors gracefully in your Java programs.

On this page

HashMap Basics
Common HashMap Methods
Adding and Updating
Getting Values
Checking for Keys/Values
Removing Entries
Size and Empty Check
Looping Through HashMap
Loop Through Keys
Loop Through Values
Loop Through Both Keys and Values
Practical Examples
Player Statistics System
Item Properties Database
Configuration Manager
Player Inventory with Quantities
Cooldown Manager
HashMap with Custom Objects
Nested HashMaps
Practice Exercises