第二十五讲 Collections工具类、Optional类、队列与栈、迭代器设计模式

导读：

        在日常的开发中，不免要处理很复杂的算法或者是程序逻辑等等。这个时候上级又需要快速而平稳地处理这些问题，那么这个时候就需要动动脑子了。起码要做的不是自己从零开始编写代码，而是要在网上寻求帮助吧。讲到这里，我们先回到目前的内容，比如：工具。对，把已经形成、成熟的技术工具来处理我们的项目问题。

一、Collections工具类

    概述：它是一个集合操作工具类，可以快速帮助我们处理集合元素。

（1）排序常用方法：

    Collections提供以下方法对List进行排序操作

    void reverse(List list)：反转

    void shuffle(List list),随机排序

    void sort(List list),按自然排序的升序排序

    void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑

    void swap(List list, int i , int j),交换两个索引位置的元素

    void rotate(List list, int distance),旋转。当distance为正数时，将list后distance个元素整体移到前面。

    当distance为负数时，将 list的前distance个元素整体移到后面。

    

（2）、查找，替换操作

    int binarySearch(List list, Object key), 对List进行二分查找，返回索引，注意List必须是有序的

    int max(Collection coll),根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)

    int max(Collection coll, Comparator c)，根据定制排序，返回最大元素，排序规则由Comparatator类控制。

    类比int min(Collection coll, Comparator c)

    void fill(List list, Object obj),用元素obj填充list中所有元素

    int frequency(Collection c, Object o)，统计元素出现次数

    int indexOfSubList(List list, List target), 统计targe在list中第一次出现的索引，找不到则返回-1。

    类比int lastIndexOfSubList(List source, list target).

    boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素。

（3）、同步控制

    Collections中几乎对每个集合都定义了同步控制方法。

    例如 SynchronizedList(), SynchronizedSet()等方法，来将集合包装成线程安全的集合。

(4)、设置不可变（只读）集合：

    Collections提供了三类方法返回一个不可变集合，

    emptyXXX(),返回一个空的只读集合（这不知用意何在？）

    singleXXX()，返回一个只包含指定对象，只有一个元素，只读的集合。

    unmodifiablleXXX()，返回指定集合对象的只读视图。

二、Optional类

Optional不是对null关键字的一种替代，而是对于null判定提供了一种更加优雅的实现。

Optional<String> optStr = Optional.empty();

创建对象：不允许为空，Optional<String> optStr = Optional.of(str); // 当str为null的时候，将抛出NullPointException！

创建对象：允许为空，Optional<String> optStr = Optional.ofNullable(str); // 如果str是null，则创建一个空对象

流式处理也是java8给我们带来的一个重量级新特性，让我们对集合的操作变得更加简洁和高效，后面的文章将对流失处理进行全面的讲解。

这里Optional也提供了两个基本的流失处理：映射和过滤。

public class User {

    /** 用户编号 */

    private long id;

    private String name;

    private int age;

    private Optional<Long> phone;

    private Optional<String> email;

    public User(String name, int age) {

    this.name = name;

    this.age = age;

    }

    // 省略setter和getter

}

手机和邮箱不是一个人的必须有的，所以我们利用Optional定义。

具体的阐述地址，推荐阅读该博客：https://blog.youkuaiyun.com/canot/article/details/52956230

三、队列与栈的区别

1、概述：队列先进先出，栈先进后出。

2、对插入和删除操作的"限定"。 栈是限定只能在表的一端进行插入和删除操作的线性表。 队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。 从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定"。 栈和队列是在程序设计中被广泛使用的两种线性数据结构，它们的特点在于基本操作的特殊性，栈必须按"后进先出"的规则进行操作，而队列必须按"先进先出" 的规则进行操作。和线性表相比，它们的插入和删除操作受更多的约束和限定，故又称为限定性的线性表结构。

3.遍历数据速度不同。栈只能从头部取数据 也就最先放入的需要遍历整个栈最后才能取出来，而且在遍历数据的时候还得为数据开辟临时空间，保持数据在遍历前的一致性队列怎不同，他基于地址指针进行遍历，而且可以从头或尾部开始遍历，但不能同时遍历，无需开辟临时空间，因为在遍历的过程中不影像数据结构，速度要快的多

栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。
队列（Queue）是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。
从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定"。

四、迭代器设计模式

目的：提供一种方法顺序访问或者遍历一个聚合对象中的各个元素，且不希望暴露该对象的内部结构。

一、设计

1. 因为是聚合对象，所以设计的这个类应该使用类似list这样的结构体存储聚合对象；

2.迭代器应该是通用的，适用于各种类型的聚合对象，所以设计的类应该是模板类型；

3.还需要对外提供统一的访问接口，以及获取当前元素，递增到下一个元素，判断是否末尾元素。

测试代码——

interface MyIterator<T>{  
     void next();  
     boolean hasNext();  
     T getItem();  
}  
public class Test<T>{  
      
    private List<T> list = new ArrayList<T>();  
    private int i = 0;  
    public void add(T item){  
        list.add(item);  
    }  
    public MyIterator getIterator(){  
            return new TestIterator();  
  
    }  
 
    class TestIterator implements MyIterator<T>{  
        public void next(){  
            i++;  
        }  
        public boolean hasNext(){  
            return (i >= list.size())? false:true;  
        }  
        public T getItem(){  
            return list.get(i);  
        }  
  
    }  
      
  }  

二、使用

Test<String> test = new Test<String>();  
test.add("1");  
test.add("2");  
test.add("3");  
test.add("4");  
test.add("5");  
MyIterator iterator = test.getIterator();  
while(iterator.hasNext()){  
    String item = (String)iterator.getItem();  
    Log.d(TAG,"item:"+item);  
    iterator.next();  
}