1.13Java-Iterator迭代器、增强for、迭代、递归

骑猪看日落 2024-04-01 09:34 20阅读 0赞

**目录**

1.13.1 Iterator迭代器

1.13.1.1什么是Iterator迭代器

1.13.1.2获取Iterator迭代器

1.13.1.3Iterator迭代器原理

1.13.2 Collections

1.13.2.1 什么是collections

1.13.2.2 常用方法

1.13.2.3 比较元素

1.13.2.3.1 Collections 的 sort()方法如何比较元素

1.13.2.3.2 TreeMap 和 TreeSet 在排序时如何比较元素

1.13.2.4 Collections类和collection的区别和联系

1.13.3 增强for

1.13.4 迭代

1.13.5 递归

--------------------

## 1.13.1 Iterator迭代器 ##

### 1.13.1.1什么是Iterator迭代器 ###

对于遍历，JDK专门提供了一个接口`java.util.Iterator`。`Iterator`接口也是Java集合中的一员，但它与`Collection`、`Map`接口有所不同，`Collection`接口与`Map`接口主要用于存储元素，而`Iterator`主要用于迭代访问（即遍历）`Collection`中的元素，因此`Iterator`对象也被称为迭代器。

### 1.13.1.2获取Iterator迭代器 ###

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

**常用方法**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
  <tr> 
   <td>public E next()</td> 
   <td>返回迭代的下一个元素。</td> 
  </tr> 
  <tr> 
   <td>public boolean hasNext()</td> 
   <td>如果仍有元素可以迭代，则返回 true。</td> 
  </tr> 
 </tbody> 
</table>

//使用迭代器 遍历   每个集合对象都有自己的迭代器
            Iterator<String> it = 集合对象.iterator();
            //  泛型指的是 迭代出 元素的数据类型
            while(it.hasNext()){ //判断是否有迭代元素
                String s = it.next();//获取迭代出的元素
                System.out.println(s);
            }

### 1.13.1.3Iterator迭代器原理 ###

当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素。在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

## 1.13.2 Collections ##

### 1.13.2.1 什么是collections ###

*  Java.util.Collections是一个集合工具类，用于操作LIst，Set，Map等集合。
 *  Collections类提供了一系列的**静态方法，**可以实现对集合元素的排序，添加一些元素，随机排序，替换等操作

### 1.13.2.2 常用方法 ###

<table style="width:638px;"> 
 <tbody> 
  <tr> 
   <td style="width:311px;"><strong>方法</strong></td> 
   <td style="width:324px;"><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td style="width:311px;">addAll(Collection&lt;T&gt; c, T... elements)</td> 
   <td style="width:324px;">添加元素</td> 
  </tr> 
  <tr> 
   <td style="width:311px;">binarySearch(List list, Object key)</td> 
   <td style="width:324px;">使用二分搜索法搜索指定的 List 集合，以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于有序状态。</td> 
  </tr> 
  <tr> 
   <td style="width:311px;">copy(List &lt;? super T&gt; dest,List&lt;? extends T&gt; src)</td> 
   <td style="width:324px;">用于将指定集合中的所有元素复制到另一个集合中。</td> 
  </tr> 
  <tr> 
   <td style="width:311px;">shuffle(List)</td> 
   <td style="width:324px;"> <p>混乱排序</p> <p><strong>shuffle中的集合只能是List集合</strong></p> </td> 
  </tr> 
  <tr> 
   <td style="width:311px;">sort(List&lt;T&gt; list，Comparator&lt;? super T&gt; ）</td> 
   <td style="width:324px;">将集合中元素按照指定规则排序</td> 
  </tr> 
  <tr> 
   <td style="width:311px;">sort(List&lt;T&gt; list)</td> 
   <td style="width:324px;">将集合中元素按照默认规则排序。</td> 
  </tr> 
  <tr> 
   <td style="width:311px;">replaceAll（）</td> 
   <td style="width:324px;">替换集合中所有的旧元素为新元素</td> 
  </tr> 
 </tbody> 
</table>

### 1.13.2.3 比较元素 ###

#### 1.13.2.3.1 Collections 的 sort()方法如何比较元素 ####

**Collections 工具类的 sort 方法有两种重载的形式：**

1.  对象实现 Comparable 接口
2.  要求传入第二个参数Comparator 接口的子类型

**方式一**

//定义一个学生类，实现Comparable
    public class Student implements Comparable<Student> {
        private String name; // 姓名
        private int age; // 年龄
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + "]";
        }
        @Override
        public int compareTo(Student o) {
            return this.age - o.age; // 比较年龄(年龄的升序)
        }
    }
    
    
    
    //测试类
    class Test01 {
        public static void main(String[] args) {
            Set<Student> set = new TreeSet<>(); // Java 7 的钻石语法(构造器后面的尖括号中不需要写类型)
            set.add(new Student("Hao LUO", 33));
            set.add(new Student("XJ WANG", 32));
            set.add(new Student("Bruce LEE", 60));
            set.add(new Student("Bob YANG", 22));
    
            for(Student stu : set) {
                System.out.println(stu);
            }
        }
    }
    
    // 输出结果:
    // Student [name=Bob YANG, age=22]
    // Student [name=XJ WANG, age=32]
    // Student [name=Hao LUO, age=33]
    // Student [name=Bruce LEE, age=60]

**方式二**

//创建学生类
    public class Student {
        private String name; // 姓名
        private int age; // 年龄
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    /**
    * 获取学生姓名
    */
        public String getName() {
            return name;
        }
    /**
    * 获取学生年龄
    */
        public int getAge() {
            return age;
        }
        @Override
        public String toString() {
           return "Student [name=" + name + ", age=" + age + "]";
        }
    }
    
    //测试类
    class Test02 {
        public static void main(String[] args) {
            List<Student> list = new ArrayList<>(); // Java 7 的钻石语法(构造器后面的尖括号中不需要写类型)
            list.add(new Student("Hao LUO", 33));
            list.add(new Student("XJ WANG", 32));
            list.add(new Student("Bruce LEE", 60));
            list.add(new Student("Bob YANG", 22));
    // 通过 sort 方法的第二个参数传入一个 Comparator 接口对象
    // 相当于是传入一个比较对象大小的算法到 sort 方法中
    // 由于 Java 中没有函数指针、仿函数、委托这样的概念
    // 因此要将一个算法传入一个方法中唯一的选择就是通过接口回调
    
            Collections.sort(list, new Comparator<Student> () {
                @Override
                public int compare(Student o1, Student o2) {
                    return o1.getName().compareTo(o2.getName()); //比较学生姓名
                }
            });
    
            for(Student stu : list) {
                System.out.println(stu);
            }
        }
    }
    // 输出结果:
    // Student [name=Bob YANG, age=22]
    // Student [name=Bruce LEE, age=60]
    // Student [name=Hao LUO, age=33]
    // Student [name=XJ WANG, age=32]

#### 1.13.2.3.2 TreeMap 和 TreeSet 在排序时如何比较元素 ####

TreeSet 要求存放的对象所属的类必须实现 Comparable 接口，该接口提供了比较元素的 compareTo()方法，当插入元素时会回调该方法比较元素的大小。

TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进行排序。

### 1.13.2.4 Collections类和collection的区别和联系 ###

## 1.13.3 增强for ##

> 增强for循环(也称for each循环)是**JDK1.5**以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

**格式**

for(元素的数据类型  变量 : Collection集合or数组){ 
      	//写操作代码
    }

## 1.13.4 迭代 ##

迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”。

## 1.13.5 递归 ##

指在当前方法内调用自己的这种现象