问题1: 两数之和

描述： 给定一个整数数组 nums 和一个目标值 target，请返回数组中和为目标值的两个整数的索引。

你可以假设每个输入只会有一种答案，且你不能重复使用相同的元素。

示例：

javaCopy code输入: nums = [2, 7, 11, 15], target = 9
输出: [0, 1]

解法（使用Map）：

javaCopy codeimport java.util.HashMap;
import java.util.Map;

public class TwoSum {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }
            map.put(nums[i], i);
        }

        throw new IllegalArgumentException("没有两个数的和等于目标值");
    }

    public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();
        int[] nums = {2, 7, 11, 15};
        int target = 9;
        int[] result = twoSum.twoSum(nums, target);
        System.out.println("两个数的索引是: [" + result[0] + ", " + result[1] + "]");
    }
}

问题2: 有效的字母异位词

描述： 给定两个字符串 s 和 t，判断 t 是否是 s 的字母异位词。

示例：

javaCopy code输入: s = "anagram", t = "nagaram"
输出: true

解法（使用Map）：

javaCopy codeimport java.util.HashMap;
import java.util.Map;

public class ValidAnagram {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }

        Map<Character, Integer> charCount = new HashMap<>();

        for (char ch : s.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }

        for (char ch : t.toCharArray()) {
            int count = charCount.getOrDefault(ch, 0);
            if (count == 0) {
                return false;
            }
            charCount.put(ch, count - 1);
        }

        return true;
    }

    public static void main(String[] args) {
        ValidAnagram validAnagram = new ValidAnagram();
        String s = "anagram";
        String t = "nagaram";
        System.out.println("t 是否是 s 的字母异位词？" + validAnagram.isAnagram(s, t));
    }
}

问题3: 宝石与石头

描述： 给定字符串 J 代表石头中宝石的类型，字符串 S 代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型。你想知道你拥有的石头中有多少是宝石。

示例：

javaCopy code输入: J = "aA", S = "aAAbbbb"
输出: 3

解法（使用Map）：

javaCopy codeimport java.util.HashMap;
import java.util.Map;

public class JewelsAndStones {
    public int numJewelsInStones(String J, String S) {
        Map<Character, Integer> jewelMap = new HashMap<>();

        for (char jewel : J.toCharArray()) {
            jewelMap.put(jewel, 0);
        }

        for (char stone : S.toCharArray()) {
            if (jewelMap.containsKey(stone)) {
                jewelMap.put(stone, jewelMap.get(stone) + 1);
            }
        }

        int count = 0;
        for (int value : jewelMap.values()) {
            count += value;
        }

        return count;
    }

    public static void main(String[] args) {
        JewelsAndStones jewelsAndStones = new JewelsAndStones();
        String J = "aA";
        String S = "aAAbbbb";
        int result = jewelsAndStones.numJewelsInStones(J, S);
        System.out.println("宝石的数量是: " + result);
    }
}

这三个问题分别使用了Map来解决，你可以尝试编写代码并运行来验证解法。

问题4: 字符串中的第一个唯一字符

描述： 给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

示例：

javaCopy code输入: s = "leetcode"
输出: 0

解法（使用Map）：

javaCopy codeimport java.util.HashMap;
import java.util.Map;

public class FirstUniqueCharacter {
    public int firstUniqChar(String s) {
        Map<Character, Integer> charCount = new HashMap<>();

        for (char ch : s.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }

        for (int i = 0; i < s.length(); i++) {
            if (charCount.get(s.charAt(i)) == 1) {
                return i;
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        FirstUniqueCharacter firstUniqueCharacter = new FirstUniqueCharacter();
        String s = "leetcode";
        int result = firstUniqueCharacter.firstUniqChar(s);
        System.out.println("第一个不重复字符的索引是: " + result);
    }
}

问题5: 存在重复元素

描述： 给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例：

javaCopy code输入: [1,2,3,1]
输出: true

解法（使用Map）：

javaCopy codeimport java.util.HashSet;
import java.util.Set;

public class ContainsDuplicate {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> numSet = new HashSet<>();

        for (int num : nums) {
            if (!numSet.add(num)) {
                return true;
            }
        }

        return false;
    }

    public static void main(String[] args) {
        ContainsDuplicate containsDuplicate = new ContainsDuplicate();
        int[] nums = {1, 2, 3, 1};
        boolean result = containsDuplicate.containsDuplicate(nums);
        System.out.println("是否存在重复元素？" + result);
    }
}

这两个问题同样使用了Map或Set来解决，你可以尝试编写代码并运行来验证解法。如果有任何问题，欢迎提问！