java基础编程分享8——合并表记录

package niuke;
/*
假设我们有一个简单的泛型类 `Pair`，用于存储一对值。这个类可以存储任意类型的一对值，并且可以重复使用在不同类型的情况下。以下是一个示例展示了 `Pair` 类如何实现代码的重用性：

```java
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(U second) {
        this.second = second;
    }

    public static void main(String[] args) {
        Pair<String, Integer> pair1 = new Pair<>("One", 1);
        System.out.println("Pair 1: " + pair1.getFirst() + " - " + pair1.getSecond());

        Pair<Double, String> pair2 = new Pair<>(3.14, "Pi");
        System.out.println("Pair 2: " + pair2.getFirst() + " - " + pair2.getSecond());
    }
}
```

在上面的示例中，我们定义了一个泛型类 `Pair`，它可以存储任意两种类型的值。
通过实例化 `Pair` 类并指定不同类型的类型参数，我们可以创建不同类型的一对值。
这展示了如何通过泛型实现代码重用性，因为我们可以使用同一个类来存储不同类型的值，而不需要为每种类型都创建一个新的类。
通过这种方式，我们可以在不同情况下重复使用 `Pair` 类，而不需要针对每种类型都编写一个新的类。
这体现了泛型的重用性，使代码更加灵活和通用。
 */
import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeMap;

/*
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，
即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4
 */
public class answer_8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        HashMap<Integer, Integer> sumMap = new HashMap<>();
        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        int i = 0;
        while(i<a){
            int key = sc.nextInt();
            int value = sc.nextInt();
            if(sumMap.get(key) != null){
                sumMap.put(key , value+ sumMap.get(key));
            }else{
                sumMap.put(key,value);
            }
            i++;
        }
        treeMap.putAll(sumMap);
        for(int keyNum:treeMap.keySet()){
            System.out.println(keyNum + " " + treeMap.get(keyNum));
        }
            /*
            每次循环都会覆盖：
            for(int keyNum2 : indexMap.keySet()){
                if(keyNum == keyNum2){
                    System.out.println(true);
                    sumMap.put(keyNum2,indexMap.get(keyNum2));
                    System.out.println(keyNum2 + " " + indexMap.get(keyNum2));//注意keyNum和keyNum2不可以乱用
                }
            }
             */
    }
}

//        TreeMap<Integer, Integer> treeMap = new TreeMap<>(sumMap);//直接将HashMap对象 sumMap 的内容复制到新的TreeMap对象
//        for(int key:treeMap.keySet()){
//            System.out.println(key + " " + treeMap.get(key));
//        }

/*
HashMap<String, Integer> map = new HashMap<>();
map.put("key1", 5); // 原始键值对
使用 putIfAbsent 添加键值对，如果键已存在则不添加
map.putIfAbsent("key1", 10);
在这个示例中，因为键 "key1" 已经存在，所以 putIfAbsent 方法不会覆盖原始值 5，而是保持原有的键值对 ("key1", 5)。
 */

/*
HashMap 是 Java 中常用的集合类，它实现了 Map 接口，用于存储键值对。以下是 HashMap 的基本用法：

创建 HashMap 对象：
HashMap<KeyType, ValueType> hashMap = new HashMap<>();

添加键值对：
hashMap.put(key1, value1);
hashMap.put(key2, value2);

获取值：
ValueType value = hashMap.get(key);

检查是否包含某个键：
boolean containsKey = hashMap.containsKey(key);

删除键值对：
ValueType removedValue = hashMap.remove(key);

遍历 HashMap：
迭代HashMap或TreeMap集合就像是查看集合中每个元素的清单一样。
遍历键集：
for (KeyType key : hashMap.keySet()) {
    // 使用 key 获取对应的值
    ValueType value = hashMap.get(key);
}
遍历值集：
for (ValueType value : hashMap.values()) {
    // 处理每个值
}
遍历键值对：
for (Map.Entry<KeyType, ValueType> entry : hashMap.entrySet()) {
    KeyType key = entry.getKey();
    ValueType value = entry.getValue();
    // 处理键值对
}
获取 HashMap 的大小：
int size = hashMap.size();
清空 HashMap：
hashMap.clear();
HashMap 具有常量时间复杂度（O(1)）的查找、插入和删除操作。请注意，HashMap 不保证键值对的顺序。如果需要有序存储键值对，可以考虑使用 LinkedHashMap。
 */

/*
   使用 TreeMap 来存储键值对，并按键的自然顺序（升序）进行排序
   TreeMap<Integer, String> treeMap = new TreeMap<>();
   创建一个 TreeMap 对象，并指定自定义比较器来按值降序排序
   TreeMap<Integer, String> treeMap = new TreeMap<>(Comparator.reverseOrder());
   使用 putAll() 方法将第一个 HashMap 的内容赋值给第二个 HashMap
   secondHashMap.putAll(firstHashMap);
*/
//for(int keyNum : indexMap.values()) 遍历map中所有值
// 删除键为 "B" 的键值对  hashMap.remove("B");
//sumMap.keySet() 表示获取 HashMap 中所有键（key）的集合。
// 具体来说，它返回一个 Set 对象，其中包含了 sumMap 中所有的键。