Java集合框架（一）

集合类存放于java.util包中，集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)

集合类型主要有3种：set(集）、list(列表）和map(映射)

通俗的说，集合就是一个放数据的容器，准确的说是放数据对象引用的容器

Collection接口

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素，Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)

Collecton接口常用的子接口有：List接口、Set接口

List接口常用的子类有：ArrayList类、LinkedList类
Set接口常用的子类有：HashSet类、LinkedHashSet类如

接口多态的调用

Collection<String> collection = new ArrayList<String>();

741560-20170330144456389-1484217347.png
注意
学习Java中三种长度表现形式

• 数组.length 属性，返回值int
• 字符串.length() 方法，返回值int
• 集合.size()方法， 返回值int

Iterator接口

迭代器概述

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。 我们要取出这些集合中的元素，可通过一种通用的获取方式来完成

每种集合的底层的数据结构不同,例如ArrayList是数组,LinkedList底层是链表,但是无论使用那种集合,我们都会有判断是否有元素以及取出里面的元素的动作,那么Java为我们提供一个迭代器定义了统一的判断元素和取元素的方法

• hasNext()如果有元素可以迭代，则返回true
• next()返回迭代的下一个元素

Iterator接口，找实现类，Collection接口定义方法，ArrayList重写方法iterator()返回了Iterator接口的实现类的对象

public class Test {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>();
        collection.add("cuzz1");
        collection.add("cuzz2");
        collection.add("cuzz3");
        collection.add("cuzz4");
        
        // 迭代器，对集合ArrayList中的元素进行取出
        // 调用集合iterator()方法取出，Iterator接口的实现类的对象
        Iterator<String> iterator = collection.iterator();
        // 接口的实现类对象，调用方法hasNext()判断集合中是否有元素
        boolean bool = iterator.hasNext();
        // 接口的实现类的对象，调用方法next()取出集合中的元素
        // String str = iterator.next();
        // System.out.println(str);
        
        // 迭代是反复的内容，使用循环实现
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
    }
}

集合元素的转型

使用集合时，我们需要注意以下几点：

• 集合中储存都是对象的地址，那集合可以储存基本数据类型吗？
  jdk1.5版本以后可以存储了，因为出现类基本类型包装类，可以自动装箱操作，这样集合中的元素就是基本数值的包装类对象
• 存储时提升了Object。取出时要使用元素的特有内容，必须向下转型

public class Test {
    public static void main(String[] args) {
        // Collection<String> collection = new ArrayList<String>();
        // 不指定数据类型
        Collection collection = new ArrayList();
        collection.add("cuzz1");
        collection.add("cuzz2");
        collection.add("cuzz3");
        collection.add("cuzz4");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()){
            // 由于元素别放进集合后全部被提升为Object类型
            // 当需要使用子类特有的方法时，需要向下转型
            String str = (String) iterator.next();
            System.out.println(str.length());
        }
    }
}

注意如果集合中放的是多个对象，这时进行向下转型会发生类型转换异常

增强for循环

JDK1.5新特性，增强for循环，JDK1.5版本后，出现新的接口 java.lang.Iterable
Collection开是继承Iterable，Iterable作用，实现增强for循环
格式:
for( 数据类型 变量名 : 数组或者集合 ){
}

泛型

泛型的引入

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。比如下面程序：

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("abc");
        list.add("itcast");
        list.add(5);                        // 由于集合没有做任何限定，任何类型都可以给其中存放
                                            // 相当于:Object obj=new Integer(5);
    
        Iterator it = list.iterator();
        while(it.hasNext()){

         // 需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
         String str = (String) it.next();   // String str=(String)obj;
                                            // 编译时期仅检查语法错误,String是Object的儿子可以向下转型
                                            // 运行时期String str=(String)(new Integer(5))
                                            // String与Integer没有父子关系所以转换失败
                                            // 程序在运行时发生了问题java.lang.ClassCastException
         System.out.println(str.length());
        }
    }
}

泛型的定义和使用

从JDK1.5开始，引入了参数化类型（Parameterized Type）的概念，改造了所有的Java集合，使之都实现泛型，允许程序在创建集合时就可以指定集合元素的类型，比如List<String>就表名这是一个只能存放String类型的List

public class Test {     
    public static void main(String[] args) {  
        ArrayList<String> list = new ArrayList<>();  
        list.add("cuzz1");  
        list.add("cuzz2");  
        // list.add(1);   // 类型不符，直接报错
}

伪泛型

Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经被替换为原来的原始类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此对于运行期的Java语言来说，ArrayList与ArrayList就是同一个类。所以说泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型被称为伪泛型

泛型类

一个泛型类（generic class）就是具有一个或多个类型变量的类。定义一个泛型类十分简单，只需要在类名后面加上<>，再在里面加上类型参数：

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }
    public E get(int index){ }
}

创建对象时，确定泛型的类型
ArrayList<String> list = new ArrayList<String>();
此时的变量E就代表String类型

class ArrayList<String>{ 
    public boolean add(String e){ }
    public String get(int index){ }
}

泛型的方法

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

例如，API中的ArrayList集合中的方法：
public <T> T[] toArray(T[] a){ } ,该方法，用来把集合元素存储到指定数据类型的数组中，返回已存储集合元素的数组

ArrayList<String> list = new ArrayList<String>();
String[] arr = new String[100];
String[] result = list.toArray(arr);

泛型的接口

与泛型类定义类似

public interface List <E>{
    abstract boolean add(E e);
}

实现类，先实现接口，不理会泛型

public class ArrayList<E> implements List<E>{
}

后期创建集合对象的时候指定数据类型，new ArrayList<String>()

泛型的通配符

通配符 “？”

如果定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，“？”，如List<?>，“？”可以代表任意类型，“任意”也就是未知类型。

public class GenericTest {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        HashSet<Integer> set = new HashSet<Integer>();

        array.add("123");
        array.add("456");

        set.add(789);
        set.add(890);

        printItems(array);
        printItems(set);
    }
    public static void printItems(Collection<?> collection){
        Iterator<?> iterator = collection.iterator();
        while(iterator.hasNext()){
             System.out.println(iterator.next());
        }
    }
}

通配符上界

<? extends Employee>限制的是父类, 上限限定

酒店员工是厨师，服务员，经理三者的父类，所在只有这三个限定在其中

public static void iterator(ArrayList<? extends Employee> array){

    Iterator<? extends Employee> it = array.iterator();
    while(it.hasNext()){
    // 获取出的next() 数据类型,是什么Employee
    Employee e = it.next();
    e.work();
    }
}

通配符下界

<? super Employee> 限制的是子类, 下限限定
只能传递Employee的父类