10.8

软件设计                  石家庄铁道大学信息学院

 

实验18：迭代器模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解迭代器模式的动机，掌握该模式的结构；

2、能够利用迭代器模式解决实际问题。

 

[实验任务一]：JAVA和C++常见数据结构迭代器的使用

信1305班共44名同学，每名同学都有姓名，学号和年龄等属性，分别使用JAVA内置迭代器和C++中标准模板库（STL）实现对同学信息的遍历，要求按照学号从小到大和从大到小两种次序输出学生信息。

实验要求：

1.     搜集并掌握JAVA和C++中常见的数据结构和迭代器的使用方法，例如，vector, list, map和set等；

 以下是对Java和C++中常见数据结构及迭代器使用方法的介绍：

 

### Java

1. `ArrayList`（类似于C++中的`vector`）

   数据结构特点：

     动态数组，可以根据需要自动调整大小。

     允许快速随机访问元素，通过索引获取元素的时间复杂度为O(1)。

     插入和删除元素时，可能需要移动后续元素，平均时间复杂度为O(n)。

   迭代器使用方法：

     通过`iterator()`方法获取迭代器。

     示例代码：

```java

import java.util.ArrayList;

import java.util.Iterator;

 

public class ArrayListIteratorExample {

    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();

        list.add("apple");

        list.add("banana");

        list.add("cherry");

 

        // 获取迭代器

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {

            String element = iterator.next();

            System.out.println(element);

        }

    }

}

``

2. `LinkedList`（类似于C++中的`list`）

   数据结构特点：

     双向链表结构，每个节点包含数据和指向前一个及后一个节点的引用。

     插入和删除操作在特定位置（如链表头部或尾部）比较高效，时间复杂度为O(1)。

     随机访问元素效率较低，需要遍历链表，时间复杂度为O(n)。

   迭代器使用方法：

     同样使用`iterator()`方法获取迭代器，与`ArrayList`类似。

     示例代码：

```java

import java.util.LinkedList;

import java.util.Iterator;

 

public class LinkedListIteratorExample {

    public static void main(String[] args) {

        LinkedList<String> list = new LinkedList<>();

        list.add("apple");

        list.add("banana");

        list.add("cherry");

 

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {

            String element = iterator.next();

            System.out.println(element);

        }

    }

}

```

3. HashMap（类似于C++中的`map`）

   数据结构特点：

      基于哈希表实现，存储键值对。

      提供快速的插入、删除和查找操作，平均时间复杂度接近O(1)，但在最坏情况下可能退化为O(n)（哈希冲突严重时）。

     不保证键值对的顺序。

   迭代器使用方法：

     可以通过`entrySet().iterator()`获取键值对的迭代器，或者使用`keySet().iterator()`获取键的迭代器，`values().iterator()`获取值的迭代器。

     示例代码（使用键值对迭代器）：

```java

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

 

public class HashMapIteratorExample {

    public static void main(String[] args) {

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

        map.put("apple", 1);

        map.put("banana", 2);

        map.put("cherry", 3);

 

        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();

        while (iterator.hasNext()) {

            Map.Entry<String, Integer> entry = iterator.next();

            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());

        }

    }

}

```

4. `HashSet`（类似于C++中的`set`）

   数据结构特点：

     基于哈希表实现，用于存储不重复元素。

      提供快速的添加、删除和查找操作，平均时间复杂度接近O(1)，最坏情况为O(n)。

     不保证元素的顺序。

   迭代器使用方法：

     使用`iterator()`方法获取迭代器。

      示例代码：

```java

import java.util.HashSet;

import java.util.Iterator;

 

public class HashSetIteratorExample {

    public static void main(String[] args) {

        HashSet<String> set = new HashSet<>();

        set.add("apple");

        set.add("banana");

        set.add("cherry");

 

        Iterator<String> iterator = set.iterator();

        while (iterator.hasNext()) {

            String element = iterator.next();

            System.out.println(element);

        }

    }

}

```

 

### C++

1. vector

   数据结构特点：

     动态数组，可以自动管理内存分配和调整大小。

     支持快速随机访问元素，通过下标访问元素的时间复杂度为O(1)。

     在末尾插入和删除元素效率较高，平均时间复杂度为常数时间，但在中间或开头插入/删除元素可能需要移动大量元素，时间复杂度为O(n)。

   迭代器使用方法：

     通过`begin()`和`end()`方法获取迭代器范围。

     示例代码：

```cpp

#include <iostream>

#include <vector>

 

int main() {

    std::vector<int> v = {1, 2, 3, 4, 5};

 

    // 使用迭代器遍历

    for (std::vector<int>::iterator it = v.begin(); it!= v.end(); ++it) {

        std::cout << *it << " ";

    }

    std::cout << std::endl;

 

    return 0;

}

```

2. list

   数据结构特点：

     双向链表结构，每个节点包含数据和指向前一个及后一个节点的指针。

     插入和删除操作在任何位置都比较高效，时间复杂度为O(1)。

      随机访问元素效率低，需要遍历链表，时间复杂度为O(n)。

   迭代器使用方法：

      使用`begin()`和`end()`方法获取迭代器范围，与`vector`类似，但迭代器类型为`std::list<T>::iterator`。

     示例代码：

cpp

#include <iostream>

#include <list>

 

int main() {

    std::list<int> l = {1, 2, 3, 4, 5};

 

    // 使用迭代器遍历

    for (std::list<int>::iterator it = l.begin(); it!= l.end(); ++it) {

        std::cout << *it << " ";

    }

    std::cout << std::endl;

 

    return 0;

}

```

3. map

   数据结构特点：

     基于红黑树实现，存储键值对，键是唯一的且按照特定顺序排列（默认升序）。

     插入、删除和查找操作的时间复杂度为O(log n)。

   迭代器使用方法：

     通过`begin()`和`end()`方法获取迭代器范围，迭代器指向的是键值对（`std::pair<K, V>`）。

     示例代码：

cpp

#include <iostream>

#include <map>

 

int main() {

    std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};

 

    // 使用迭代器遍历

    for (std::map<std::string, int>::iterator it = m.begin(); it!= m.end(); ++it) {

        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;

    }

 

    return 0;

}

```

4. set

   数据结构特点：

     基于红黑树实现，用于存储不重复元素，元素按照特定顺序排列（默认升序）。

      插入、删除和查找操作的时间复杂度为O(log n)。

   迭代器使用方法：

     使用`begin()`和`end()`方法获取迭代器范围，迭代器指向集合中的元素。

      示例代码：

```cpp

#include <iostream>

#include <set>

 

int main() {

    std::set<std::string> s = {"apple", "banana", "cherry"};

 

    // 使用迭代器遍历

    for (std::set<std::string>::iterator it = s.begin(); it!= s.end(); ++it) {

        std::cout << *it << " ";

    }

    std::cout << std::endl;

 

    return 0;

}

```

 

2. 提交源代码；

Java：

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

 

// 学生类

class Student {

    private String name;

    private String id;

    private int age;

 

    public Student(String name, String id, int age) {

        this.name = name;

        this.id = id;

        this.age = age;

    }

 

    public String getName() {

        return name;

    }

 

    public String getId() {

        return id;

    }

 

    public int getAge() {

        return age;

    }

}

 

public class StudentIteratorJava {

    public static void main(String[] args) {

        // 创建学生列表

        List<Student> students = new ArrayList<>();

        students.add(new Student("张三", "2022001", 20));

        students.add(new Student("李四", "2022002", 21));

        students.add(new Student("王五", "2022003", 19));

 

        // 按照学号从小到大排序

        Collections.sort(students, new Comparator<Student>() {

            @Override

            public int compare(Student s1, Student s2) {

                return s1.getId().compareTo(s2.getId());

            }

        });

 

        // 使用迭代器遍历并输出（从小到大）

        Iterator<Student> iterator = students.iterator();

        System.out.println("按照学号从小到大输出：");

        while (iterator.hasNext()) {

            Student student = iterator.next();

            System.out.println("姓名：" + student.getName() + "，学号：" + student.getId() + "，年龄：" + student.getAge());

        }

 

        // 按照学号从大到小排序

        Collections.sort(students, new Comparator<Student>() {

            @Override

            public int compare(Student s1, Student s2) {

                return s2.getId().compareTo(s1.getId());

            }

        });

 

        // 使用迭代器遍历并输出（从大到小）

        iterator = students.iterator();

        System.out.println("按照学号从大到小输出：");

        while (iterator.hasNext()) {

            Student student = iterator.next();

            System.out.println("姓名：" + student.getName() + "，学号：" + student.getId() + "，年龄：" + student.getAge());

        }

    }

}

 

 

 

C++:#include <iostream>

#include <vector>

#include <algorithm>

#include <string>

 

// 学生结构体

struct Student {

    std::string name;

    std::string id;

    int age;

};

 

// 比较函数，用于按照学号从小到大排序

bool compareByIdAsc(const Student& s1, const Student& s2) {

    return s1.id < s2.id;

}

 

// 比较函数，用于按照学号从大到小排序

bool compareByIdDesc(const Student& s1, const Student& s2) {

    return s1.id > s2.id;

}

 

int main() {

    // 创建学生向量

    std::vector<Student> students;

    students.push_back({"张三", "2022001", 20});

    students.push_back({"李四", "2022002", 21});

    students.push_back({"王五", "2022003", 19});

 

    // 按照学号从小到大排序

    std::sort(students.begin(), students.end(), compareByIdAsc);

 

    // 遍历并输出（从小到大）

    std::cout << "按照学号从小到大输出：" << std::endl;

    for (const auto& student : students) {

        std::cout << "姓名：" << student.name << "，学号：" << student.id << "，年龄：" << student.age << std::endl;

    }

 

    // 按照学号从大到小排序

    std::sort(students.begin(), students.end(), compareByIdDesc);

 

    // 遍历并输出（从大到小）

    std::cout << "按照学号从大到小输出：" << std::endl;

    for (const auto& student : students) {

        std::cout << "姓名：" << student.name << "，学号：" << student.id << "，年龄：" << student.age << std::endl;

    }

 

    return 0;

}

 

3. 注意编程规范。