c++里的集合对应与Java里的那些集合

C++ 和 Java 都提供了丰富的集合类库，但它们的实现和使用方式有所不同。以下是一些常见的 C++ 集合类和它们在 Java 中的对应关系：

1. std::vector vs. ArrayList

• C++: std::vector

  • 动态数组，支持随机访问和动态调整大小。
  • 位于 <vector> 头文件中。
  • 示例：

    #include <vector>
    #include <iostream>
    
    int main() {
        std::vector<int> vec = {1, 2, 3, 4, 5};
        vec.push_back(6);
        for (int i : vec) {
            std::cout << i << " ";
        }
        return 0;
    }
    

• Java: ArrayList

  • 动态数组，支持随机访问和动态调整大小。
  • 位于 java.util 包中。
  • 示例：

    import java.util.ArrayList;
    
    public class Main {
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            for (int i : list) {
                System.out.print(i + " ");
            }
        }
    }
    

2. std::list vs. LinkedList

• C++: std::list

  • 双向链表，支持高效的插入和删除操作。
  • 位于 <list> 头文件中。
  • 示例：

    #include <list>
    #include <iostream>
    
    int main() {
        std::list<int> lst = {1, 2, 3, 4, 5};
        lst.push_back(6);
        for (int i : lst) {
            std::cout << i << " ";
        }
        return 0;
    }
    

• Java: LinkedList

  • 双向链表，支持高效的插入和删除操作。
  • 位于 java.util 包中。
  • 示例：

    import java.util.LinkedList;
    
    public class Main {
        public static void main(String[] args) {
            LinkedList<Integer> list = new LinkedList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            for (int i : list) {
                System.out.print(i + " ");
            }
        }
    }
    

3. std::set vs. HashSet / TreeSet

• C++: std::set

  • 有序集合，不允许重复元素，底层实现通常是红黑树。
  • 位于 <set> 头文件中。
  • 示例：

    #include <set>
    #include <iostream>
    
    int main() {
        std::set<int> s = {1, 2, 3, 4, 5};
        s.insert(6);
        for (int i : s) {
            std::cout << i << " ";
        }
        return 0;
    }
    

• Java: HashSet

  • 无序集合，不允许重复元素，底层实现是哈希表。
  • 位于 java.util 包中。
  • 示例：

    import java.util.HashSet;
    
    public class Main {
        public static void main(String[] args) {
            HashSet<Integer> set = new HashSet<>();
            set.add(1);
            set.add(2);
            set.add(3);
            set.add(4);
            set.add(5);
            set.add(6);
            for (int i : set) {
                System.out.print(i + " ");
            }
        }
    }
    

• Java: TreeSet

  • 有序集合，不允许重复元素，底层实现是红黑树。
  • 位于 java.util 包中。
  • 示例：

    import java.util.TreeSet;
    
    public class Main {
        public static void main(String[] args) {
            TreeSet<Integer> set = new TreeSet<>();
            set.add(1);
            set.add(2);
            set.add(3);
            set.add(4);
            set.add(5);
            set.add(6);
            for (int i : set) {
                System.out.print(i + " ");
            }
        }
    }
    

4. std::map vs. HashMap / TreeMap

• C++: std::map

  • 有序键值对集合，底层实现通常是红黑树。
  • 位于 <map> 头文件中。
  • 示例：

    #include <map>
    #include <iostream>
    
    int main() {
        std::map<int, std::string> m;
        m[1] = "one";
        m[2] = "two";
        m[3] = "three";
        for (const auto &pair : m) {
            std::cout << pair.first << ": " << pair.second << "\n";
        }
        return 0;
    }
    

• Java: HashMap

  • 无序键值对集合，底层实现是哈希表。
  • 位于 java.util 包中。
  • 示例：

    import java.util.HashMap;
    
    public class Main {
        public static void main(String[] args) {
            HashMap<Integer, String> map = new HashMap<>();
            map.put(1, "one");
            map.put(2, "two");
            map.put(3, "three");
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }
    

• Java: TreeMap

  • 有序键值对集合，底层实现是红黑树。
  • 位于 java.util 包中。
  • 示例：

    import java.util.TreeMap;
    
    public class Main {
        public static void main(String[] args) {
            TreeMap<Integer, String> map = new TreeMap<>();
            map.put(1, "one");
            map.put(2, "two");
            map.put(3, "three");
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }
    

5. std::unordered_map vs. HashMap

• C++: std::unordered_map

  • 无序键值对集合，底层实现是哈希表。
  • 位于 <unordered_map> 头文件中。
  • 示例：

    #include <unordered_map>
    #include <iostream>
    
    int main() {
        std::unordered_map<int, std::string> um;
        um[1] = "one";
        um[2] = "two";
        um[3] = "three";
        for (const auto &pair : um) {
            std::cout << pair.first << ": " << pair.second << "\n";
        }
        return 0;
    }
    

• Java: HashMap

  • 无序键值对集合，底层实现是哈希表。
  • 位于 java.util 包中。
  • 示例：

    import java.util.HashMap;
    
    public class Main {
        public static void main(String[] args) {
            HashMap<Integer, String> map = new HashMap<>();
            map.put(1, "one");
            map.put(2, "two");
            map.put(3, "three");
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }
    

通过以上对比，可以看出 C++ 和 Java 的集合类在功能上有很多相似之处，但在具体实现和使用方式上有一些差异。了解这些差异有助于在不同语言间进行迁移或选择合适的数据结构。