一、Collection集合

集合的概念

概念：集合是java中提供的一种容器，可以用来存储多个数据。
数组：存储一组相同数据类型的数据结构。
局限：定长
集合：动态存放多个对象。
动态：集合的大小随着存储的数据量而改变。
多个：0-多个数据
对象：存储类的实例。基本数据类型—->包装类对象。

集合框架

Collection 常用功能

示例1：

package com.alpaak.part8;
import java.util.ArrayList;
import java.util.Collection;
/**
 Collection 常用功能
 */
public class Demo1_Collection {
    public static void main(String[] args) {
        //step1:创建一个容器
        Collection collection1 = new ArrayList();
        System.out.println("集合的样子：" + collection1);
        //step2:往容器中添加元素
        boolean flag = collection1.add("abc");//返回一个boolean值，判断是否添加成功
        System.out.println("add操作flag:"+flag);
        //System.out.println(collection1);
        collection1.add(true);
        collection1.add(123);//---->int---->Integer---->Object
        System.out.println("添加后：" + collection1);//重写了toString()方法
        System.out.println("集合的元素个数："+collection1.size());
        System.out.println("-----------------");
        Collection c2 = new ArrayList();
        c2.add(12);
        c2.add(45);
        c2.add(67);
        collection1.addAll(c2);
        System.out.println("将集合中元素一次性添加到目标集合中" + collection1);
        System.out.println("---------");
        System.out.println(collection1.contains("abc"));
        System.out.println(collection1.containsAll(c2));//判断是否包含集合c2中所有的元素
        System.out.println("-------------");
        System.out.println(collection1.isEmpty());//判断集合是否为空
        System.out.println("------------");
        collection1.remove(true);//删除集合中的一个元素
        System.out.println("remove删除操作后： " + collection1);
        collection1.removeAll(c2);//删除指定的集合中所有的元素
        System.out.println("removeAll删除操作后： " + collection1);
        System.out.println("--------------");
        collection1.clear();
        System.out.println("清空后的集合： " + collection1);
        System.out.println("------------");
        Collection c3 = new ArrayList();
        c3.add(123);
        c3.add(345);
        collection1.add(123);
        collection1.add(true);
        collection1.add("abc");
        System.out.println("集合1：" + collection1);
        System.out.println("集合3：" + c3);
        collection1.retainAll(c3);//交集：仅保留此集合中包含在指定集合中的元素
        System.out.println("集合1通过retainAll交集操作后： "+ collection1);
    }
}

Iterator迭代器

在程序开发中，经常需要遍历集合中的所有元素。
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器
下面介绍一下获取迭代器的方法：
public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
Iterator接口的常用方法如下：
public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回 true。
step1：先获取集合上的迭代器
Iterator it = c1.iterator();
step2：先判断迭代器后是否有数据
it.hasNext()—>boolean
step3：通过迭代器获取集合的元素
it.next()—->E

示例2：

package com.alpaak.part8;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 Iterator迭代器
 */
public class Demo2_Iterator {
    public static void main(String[] args) {
        Collection<String> c1 = new ArrayList<>();
        c1.add("aa");
        c1.add("bb");
        c1.add("cc");
        c1.add("dd");
        //3.2使用迭代器(迭代器专门用来遍历集合的一种方式)
        //hasNext();有没有下一个元素，
        //next();获取下一个元素
        //remove();删除当前元素
        Iterator<String> iterator = c1.iterator();
        if(iterator.hasNext()){
            System.out.println(iterator.next());
            //不能使用collection删除方法，因为遍历同时不能使用集合删除方法，否则出现并发修改异常。
            //可以使用迭代器的删除方法
            //c1.remove(s);
            //iterator.remove();
        }
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());//java.util.NoSuchElementException
    }
}

概念

我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
没有泛型的话，取出来的话，需要向下转型，效率低下。容易产生错误。
泛型：保护数据类型的安全。
语法：

Collection<数据类型> c1 = new ArrayList();//JDK1.7版本之后

示例

Collection<String> c1 = new ArrayList();//jdk1.7版本之后，后面不用再声明<String>
c1.add("hello");
c1.add("world");
//c1.add(123);
System.out.println(c1);

泛型的定义

定义含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

什么时候确定泛型？在创建对象的时候确定泛型

定义含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

什么时候确定泛型？调用方法时，确定泛型的类型

示例3：

package com.alpaak.part8;
//作用在类上的泛型：当数据类型不确定的时候，可以一个泛型，通过创建对象传递过来一个类型，来确定T的类型
class Point<T>{
    private T x;
    private T y;
    public static <M> void test(M m){//静态方法上要单独声明，它不能使用类上面的声明的泛型，调用静态方法的时候，确定类型
        System.out.println("检测到了静态方法上的泛型："+m);
    }
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }
}
/**
 * 泛型
 */
public class Demo3_Paradigm {
    public static void main(String[] args) {
        Point<String> point = new Point<>();
        point.setX("wowow");
        point.setY("wowow");
        Point<Integer> point4 = new Point<>();
        point4.setY(2);
        point4.setX(3);
        Point.test("wowo");
        Point.test(23);
    }
}

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

示例4

package com.alpaak.part8.demo4;
/**
 * 接口上声明泛型
 * @param <T1>
 * @param <T2>
 */
public interface A<T1,T2> {
    void test1(T1 t1);
    void test2(T2 t2);
}

package com.alpaak.part8.demo4;
//实现类使用
public class AImpl implements A<String,Integer> {
    @Override
    public void test1(String s) {
    }
    @Override
    public void test2(Integer integer) {
    }
}

泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
？：通配符，不确定类型，代表集合中可以存储任意类型的数据。
List