Hytale Modding
Hytale Modding
Fundamentos do Java

11 — HashMap e armazenamento de chaves-Valor

Aprenda a armazenar e recuperar dados usando pares de chave-valor.

Um HashMap armazena dados em pares de chave-valor, como um dicionário no mundo real. Você busca por uma palavra (chave) para encontrar a sua definição (valor). Isso é perfeito para dados de jogadores, propriedades de itens e configurações.

Noções básicas de HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Cria uma HashMap (String keys, Integer values)
        HashMap<String, Integer> playerLevels = new HashMap<>();
        
        // Adiciona pares de valor-chave
        playerLevels.put("Alice", 10);
        playerLevels.put("Bob", 15);
        playerLevels.put("Charlie", 8);
        
        // Obtém um valor por chave
        int aliceLevel = playerLevels.get("Alice");  // 10
        
        System.out.println("O nível de Alice é: " + aliceLevel);
    }
}
HashMap vs. ArrayList
HashMapArrayList
Não ordenadoOrdenado por índice (0, 1, 2...)
Acesso por chave (de qualquer tipo)Acesso por posição
Bom para procurar valoresBom para listas de itens
Cada chave é únicaPode haver duplicatas
// ArrayList — acesso por número
ArrayList<String> players = new ArrayList<>();
players.add("Alice");
String player = players.get(0);  // Obtém o primeiro jogador

// HashMap — acesso por nome
HashMap<String, Integer> levels = new HashMap<>();
levels.put("Alice", 10);
int level = levels.get("Alice");  // Obtém o nível de Alice

Métodos comuns de HashMap

Adicionar e atualizar

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)

Obtendo valores

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)

Verificando chaves/valores

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

Removendo entradas

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);       // {}

Verificação de tamanho e espaço vazio

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

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

Repetição por HashMaps

Por chaves

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)

Por valores

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

Por chaves e valores

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);
}
Ordem do HashMap

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)

Exemplos práticos

Sistema de estatísticas do jogador

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();
    }
}

Banco de dados de propriedades de itens

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");
    }
}

Gerenciador de configuração

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());
        }
    }
}

Inventário do jogador com quantidades

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();
    }
}

Gerenciador de tempo de recarga

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 com objetos personalizados

Armazene suas próprias classes como valores:

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);
    }
}

HashMaps aninhadas

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);

Exercícios práticos

  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
Edit on GitHub

10 — ArrayList e coleções

Aprenda a usar coleções flexíveis e responsivas em Java.

12 — Tratamento de exceções

Aprenda a lidar com os erros indicados pelas exceções de forma adequada em seus programas Java.

On this page

Noções básicas de HashMap
Métodos comuns de HashMap
Adicionar e atualizar
Obtendo valores
Verificando chaves/valores
Removendo entradas
Verificação de tamanho e espaço vazio
Repetição por HashMaps
Por chaves
Por valores
Por chaves e valores
Exemplos práticos
Sistema de estatísticas do jogador
Banco de dados de propriedades de itens
Gerenciador de configuração
Inventário do jogador com quantidades
Gerenciador de tempo de recarga
HashMap com objetos personalizados
HashMaps aninhadas
Exercícios práticos