一、Collections类

​ Collections类是单列集合Collection的工具类，Collections工具类为集合提供了许多静态方法，常用方法如下

二、迭代器Iterator

• 在对集合进行迭代的过程中，不要进行增删操作！！！
• 对ArrayList集合中的元素进行修改或删除时，先遍历找到对应元素的索引，遍历结束以后根据索引进行修改或删除

迭代器Iterator是用来遍历Collection集合的，Map集合不能直接使用Iterator迭代器遍历集合元素。

自定义对象并迭代
测试类:

public static void main(String[] args) {
        Person p1 = new Person("张三", 20);
        Person p2 = new Person("李四", 21);
        Person p3 = new Person("王五", 22);
        Person p4 = new Person("赵六", 23);

        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);

        Iterator<Person> iterator = list.iterator();
        while (iterator.hasNext()) {
            Person per = iterator.next();
            System.out.println(per);
        }
    }

Person.java

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

三、Map集合的遍历

3.1 keySet()遍历

实现思想：

1、Map接口定义了方法 keySet() ，可以利用这个方法获取Map集合中所有键的Set集合。

2、使用Iterator迭代器遍历Set集合。

3、利用步骤2中获取的key，调用Map集合的get()方法，获取键对应的值。

 /**
     * - Map接口定义了方法  keySet() 所有的键,存储到Set集合
     * - 遍历Set集合
     * - 取出Set集合元素 **Set集合的元素是Map集合的键**
     * - Map集合方法get()传递键获取值
     */
public static void mapKeySet(){
    Map<String,String> map = new HashMap<String, String>();
    map.put("a","java");
    map.put("b","c++");
    map.put("c","php");
    map.put("d","python");
    map.put("e","erlang");
    //Map接口定义了方法  keySet() 所有的键,存储到Set集合
    Set<String> set = map.keySet();
    //遍历Set集合
    Iterator<String> it = set.iterator();
    //取出Set集合元素 **Set集合的元素是Map集合的键**
    while (it.hasNext()){
        String key = it.next();
        //Map集合方法get()传递键获取值
        String value =  map.get(key);
        System.out.println(key+"==="+value);
    }
}

3.2 entrySet()遍历

实现思想：

1、调用Map接口的方法 Set< Map.Entry<Key,Value> > entrySet()

• 方法返回Set集合，集合中存储的元素，比较特别
• 存储的是Map集合中,键值对映射关系的对象 , 内部接口 Map.Entry

2、利用Iterator迭代器遍历Set集合

3、取出Set集合中的元素

• 是Map.Entry接口对象
• 接口的对象方法: getKey() ,getValue()

 public static void mapEntrySet(){
     Map<String,String> map = new HashMap<String, String>();
     map.put("a","java");
     map.put("b","c++");
     map.put("c","php");
     map.put("d","python");
     map.put("e","erlang");
     //Map接口的方法 Set< Map.Entry<Key,Value> > entrySet()
     Set<Map.Entry<String,String>>  set = map.entrySet();
     //- 遍历Set集合
     Iterator<Map.Entry<String,String>> it = set.iterator();
     while (it.hasNext()){
         //取出Set集合的元素
         Map.Entry<String,String> entry =  it.next();
         //- 接口的对象方法: getKey() ,getValue()
         String key = entry.getKey();
         String value = entry.getValue();
         System.out.println(key +"==="+ value);
     }
 }

四、增强for循环

JDK1.5出现的特性 : 循环的特性 (少些代码)

Collection是单列集合的顶级接口,但是到JDK1.5后,为Collection找了个爹

java.lang.Iterable接口 : 实现接口,就可以成为 "foreach"语句的目标

Collection，List，Set都实现了接口,包括数组。

map接口及其子类没有实现该接口。

4.1 for的格式

for(数据类型 变量名 : 集合或者数组){}

• 遍历数组

 /**
     * for循环遍历数组
     * for(数据类型 变量名 : 集合或者数组){}
     */
    public static void forArray(){
        int[] arr = {1,3,5,7,9};
        for(int i : arr){
            System.out.println(i+1);
        }
        System.out.println("arr=="+arr[0]);
    }

• 遍历集合

/** for循环遍历集合
     */
    public static void forList(){
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        for(String s : list){
            System.out.println(s);
        }
    }

五、泛型

5.1 泛型的概念

​ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

​ 这样说可能也比较抽象，用一句话总结泛型的作用：强制集合存储固定的数据类型

5.2 泛型的格式

集合类<存储的数据类型>  变量名 = new 集合类<存储的数据类型>();
                                       类型可以不写:钻石操作符

加入泛型后，程序的安全性提高了

public static void main(String[] args) {
        /**
         *  JDK没有泛型技术,就是这样写
         *  集合可以存储任何数据类型
         *  添加元素的数据类型是Object
         */
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add(1); //编译错误,数据类型不匹配

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String obj =it.next(); //类型转换不需要
            System.out.println(obj);
        }
    }

5.3 泛型的好处

• 安全性提高了
• 程序的代码量减少
• 避免了类型的强制转换
• 程序的问题,由运行时期,提前到编译时期

5.4 自定义泛型类

/**
 *  定义类,类名叫工厂
 *  自定义泛型类
 *  Factory<什么都可以写> 只是变量名而已
 */
public class Factory<QQ> {
    private QQ q;

    public void setQ(QQ q){
        this.q = q;
    }

    public QQ getQ(){
        return q;
    }
}

public static void main(String[] args) {
    //创建对象Factory类对象
    // Factory factory = new Factory();//没有泛型,QQ就是Object

    Factory<String> factory = new Factory<String>();
    factory.setQ("abc");
    String s = factory.getQ();
    System.out.println(s);

    Factory<Double> factory2 = new Factory<Double>();
    factory2.setQ(1.5);
    Double q = factory2.getQ();
    System.out.println(q);
}

5.5 自定义泛型方法

/**
 * 泛型的方法,方法参数上
 */
public class Factory<Q> {

    /*
     * 静态方法
     * Q是非静态的, Q的数据类型,是new的时候指定的
     *
     * 静态方法参数中的泛型,不能和类一样
     * 静态方法的泛型,需要在方法上单独定义
     * 写在返回值类型的前面
     */
    public static <T> void staticMethod(T q){
        System.out.println(q);
    }

    public void print(Q q){
        System.out.println(q);
    }
}

5.6 泛型接口

1、实现类实现接口，不指定泛型的具体的类型

2、实现类实现接口，指定泛型的具体类型

//泛型接口
public interface Inter <T> {
    public abstract void inter(T t);
}

/**
 * 实现接口,不理会泛型
 * 对象创建的时候,指定类型
 */
public class InterImpl<T> implements Inter<T>{
    public void inter(T t){
        System.out.println(t);
    }
}

/**
 * 实现接口,同时指定泛型
 */
public class InterImpl2 implements Inter<String> {

    public void inter(String s) {
        System.out.println("s=="+s);
    }
}

public class GenericTest {
    public static void main(String[] args) {
        Inter<String> in = new InterImpl<String>();
        in.inter("ok");

        Inter in2 = new InterImpl2();
        in2.inter("kkk");
    }
}

5.7 泛型通配符

//泛型的通配符
public class GenericTest {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<String>();
        stringList.add("abc");
        stringList.add("bbc");

        List<Integer> integerList =  new ArrayList<Integer>();
        integerList.add(1);
        integerList.add(2);

        each(stringList);
        each(integerList);
    }
    /**
     * 定义方法,可以同时迭代器 遍历这两个集合
     * 方法的参数,是要遍历的集合,不确定是哪个集合
     * 定义参数,写接口类型,不要写实现类
     */
    public static void each(List<?> list){
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

5.8 泛型限定

泛型限定 : 限制的是数据类型

• 传递E类型或者是E的子类,泛型上限限定 - 传递类型可以是Company或者是他的子类
• 传递E类型或者是E的父类,泛型下限限定

public static void main(String[] args) {
    //创建集合,存储员工对象

    //开发部的
    List<Development> devList = new ArrayList<Development>();
    //存储开发部员工对象
    Development d1 = new Development();
    d1.setName("张三");
    d1.setId("开发部001");

    Development d2 = new Development();
    d2.setName("张三2");
    d2.setId("开发部002");
    devList.add(d1);
    devList.add(d2);

    //财务部集合
    List<Financial> finList = new ArrayList<Financial>();
    Financial f1 = new Financial();
    f1.setName("李四");
    f1.setId("财务部001");

    Financial f2 = new Financial();
    f2.setName("李四2");
    f2.setId("财务部002");
    finList.add(f1);
    finList.add(f2);
    System.out.println(devList);
    System.out.println(finList);

    each(devList);
    each(finList);

    //        List<Integer> integerList = new ArrayList<>();
    //        integerList.add(1);
    //        each(integerList);
}
/**
     * 要求 : 定义方法
     * 同时遍历2个集合
     * 遍历的同时取出集合元素,调用方法work()
     * ? 接收任何一个类型
     * 只能接收 Company和子类对象
     * 明确父类,不能明确子类
     */
public static void each(List<? extends Company> list){
    Iterator<? extends Company> it = list.iterator();
    while (it.hasNext()){
        //取出元素
        Company obj =it.next();
        obj.work();
    }
}

六、Properties集合

6.2 Properties集合的特点

• 继承Hashtable,实现Map接口
• 底层是哈希表结构
• 线程是安全的,运行速度慢
• 集合没有泛型的写法，键和值的数据类型锁定为String类型
• 集合有自己的特有方法
• 此集合可以和IO流对象结合使用,实现数据的持久化存储

6.3 Properties集合的常用方法

6.3.1 添加获取

• public Object setProperty(String key,String value)：向集合内添加数据
• public String getProperty(String key)：使用指定的键获取集合中的值

	private static void show01() {
        // setProperty() 通过该方法向Properties内添加一对字符串键值对
        Properties properties = new Properties();
        properties.setProperty("kelvin", "180");
        properties.setProperty("jack", "168");
        properties.setProperty("siri", "170");

        // stringPropertyNames() 通过该方法获取Properties集合内的所有键组成的set集合
        Set<String> strings = properties.stringPropertyNames();
        for (String key : strings) {
            String value = properties.getProperty(key);
            System.out.println(key + "--" + value);
        }
    }

6.3.2 store()方法持久化集合数据

• public void store(OutputStream out,String comments)：将此 Properties 表中的属性列表（键和元素对）写入输出流。

// store() 持久化数据
    private static void show02() throws IOException {
        /*
        持久化数据步骤：
         1 创建Properties对象，存储数据
         2 创建字节输出流/字符输出流对象，指定将数据持久化的位置（字节流不能持久化中文）
         3 调用Properties对象的store()方法，将集合中的临时数据持久化到指定位置
         4 释放资源
        */
        Properties properties = new Properties();
        properties.setProperty("kelvin", "180");
        properties.setProperty("jack", "168");
        properties.setProperty("siri", "170");

        FileWriter fw = new FileWriter("prop.txt");
        properties.store(fw, "store data");
        fw.close();
    }

6.3.3 load()方法加载文件数据到集合

• public void load(InputStream inStream)：从输入流中读取属性列表（键和元素对）。

/*
        加载数据步骤：
             1 创建Properties对象
             2 调用load方法加载指定文件
             3 遍历Properties集合
        注意事项：
            1 存储键值对的文件中，可以使用=，空格或其他符号进行连接
            2 存储键值对的文件中，可以使用#进行注释，注释内容不会加载
            3 读取内容默认是字符串格式
        */
    private static void show03() throws IOException {
        Properties properties = new Properties();
        properties.load(new FileReader("prop.txt"));
        Set<String> strings = properties.stringPropertyNames();
        for (String key : strings) {
            String value = properties.getProperty(key);
            System.out.println(key + "--" + value);
        }

    }