第七章.集合及泛型

1.集合

1.1集合概述

集合与数组相似都是一种容器，可以存储一组数据,集合的出现是因为有这样一种需求（程序在运行时，数据数量会不断发生变化，）

对于数组而言：

特点：同一类型（即就是定义时需要声明数组的类型，这个数组就只能存储这类数据）；

创建时指定容量，长度不变；

在一片连续的内存空间中存储（注：必须是连续空间，如果并未指明空间是否连续，则无法确定是否可以创建一个数组）

不足之处：长度固定，无法改变

1.2集合体系（仅包含单列集合）

 

1.3常用的方法（即单列集合中共有的方法）

创建对象时，java集合类推荐使用泛型，如果没有定义集合中存储的数据类型，默认为object类型 

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

 传入的参数必须是类类型，且可以有多个。

针对一种集合的方法

1).add()方法  向集合中添加元素

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        System.out.println(e);
    }
}

2)clear()方法  清除集合中所有元素

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        c.clear();
        //清楚集合中所有的元素
        System.out.println(c);
    }
}

3）contains()方法  判断集合中是否含有某一元素，如果有返回true

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        //向集合中添加指定类型的元素
        System.out.println(c);
        System.out.println(c.contains("b"));
        //判断集合中是否含有某一元素，包含的话返回true，否则返回false；
        
    }
}

4）isEmpty()方法 判断是否为空，是为true

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        //向集合中添加指定类型的元素
        System.out.println(c.isEmpty());
        //判断集合是否为空，为空返回吞日月，反之返回false
      
    }
}

5）remove()方法  删除指定的元素，删除成功返回true

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        //向集合中添加指定类型的元素
        System.out.println(c.remove("c"));
        //判断删除集合中的某一元素是否成功，成功返回true，反之返回false
    }
}

6)size()方法 求集合中实际存在的元素数量

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        System.out.println(c.size());
        //求集合中元素的数量
 
    }
}

针对两种集合的方法

1）addAll()  将一种集合添加到另一种集合中

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        c.addAll(e);
        //将e集合中的内容添加到集合c
        System.out.println(c);
    }
}

2）containsAll()   判断一种集合中是否包含了另一种集合

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        System.out.println(c.contains(e));
        //判断一个集合是否包含了另外一个数组
    }
}

3）remove()方法  判断在一个集合中是否成功删除了另外一个数组，成功返回true

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        System.out.println(c.remove(e));
        //判断在一个集合中是否删除了另一个集合
        
    }
}

4）retainAll()方法  保留两个集合中的交集，如果发生改变，则返回true

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDome1 {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("5");
        e.add("5");
        Collection<String > c=new ArrayList<String>();
        //建议使用泛型，避免出现类型不统一
        c.add("a");
        c.add("b");
        //向集合中添加指定类型的元素
        System.out.println(c.retainAll(e));
        //判断一个集合与另一个集合求交集后是否发生变化，发生变化则返回true
    }
}

2.泛型

2.1为什么会有泛型的出现？

当创建一个Collection集合对象时，指向new ArrayList(),父类指向子类

Collection e=new ArrayList();

此时对象e的类型不明确，默认为Object类型，在需要时向下转型，可能会出现转型异常，这时虽然可以通过instenceof关键字处理这类问题，但是在有需要的情况下会出现多种转型异常，这时就会造成麻烦，因此出现了泛型的需求。

Collection g=new ArrayList();
        for (Object obj:g) {
            if(obj instanceof String){
                String s=(String)obj;
            }
        }

此上就是用Instenceof处理转型异常的过程。

2.泛型的特点

泛型中必须是引用类型，基本类型会被自动装箱为包装类型

应用案例为：

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

泛型实质上是类型参数化，参数只能是类类型，且可以是多个类类型