一、集合概述

1、集合是java api提供的一系列的类，可以动态的存储多个对象（集合只能存储对象，不能存储基本数据类型数据，但是可以存放基本数据类型的包装类；数组两者皆可）；
2、集合的大小可以改变，且能存储不同数据类型的对象，而数组的大小不能改变，只能存放一种数据类型的数据；
3、集合类支持泛型。

二、集合框架关系

list集合存mysql list集合能存多少条数据_泛型类型


集合类可以分类两大类：Collection和Map

1、Collection集合及其它的子类存储的是单一的对象；
2、Map集合及其它的子类存储的是key-value（键值对）数据；
3、Iterator（迭代器）接口，用于遍历Collection及其子类；
4、Comparator（比较器）接口，在集合存储对象的时候，用于对象间的比较；
5、Collections是集合的一个工具类，里面有许多工具方法用来对集合进行操作。

三、Collection

Collection是List接口和Set接口的父接口。

List接口：存放的元素是有序可重复的接口；
Set接口：存放的元素是有序不可重复的接口，元素是否重复是依靠hashCode()和equals()方法来判断的。

Collection接口中的常用方法：

1、 int size();　返回此collection中的元素个数。
2、 boolean isEmpty();　判断collection中是否是空集合（是否有元素）。
3、 boolean contains(Object obj);　判断collection是否包含指定的元素（obj）。
4、 boolean contains(Collection c);　判断collection是否包含指定collection中的所有元素（集合包含另一个集合元素）。
5、 boolean add(Object element);　向collection中添加元素。
6、 boolean addAll(Collection c); 将指定collection（c）中的所有元素添加到此collection中（集合中添加另一个集合元素）
7、 boolean remove(Object element); 从collection中移除指定的元素。
8、 boolean removeAll(Collection c);　移除此collection中那些也包含在指定collection中的所有元素（集合中移除另一个集合元素）。
9、 void clear();　移除collection中所有的元素（清空集合）。
10、 boolean retainAll(Collection c);　保留此collection中那些也包含在指定collection的元素（两个集合间的交集）。
11、Iterator iterator();　返回在collection的元素上进行迭代的迭代器。
12、Object[] toArray();　把collection转成数组。

Collection和List集合都是接口，不能实例化，只能通过创建它们的子类对象来调用这些方法，List集合的子类如下：

1、ArrayList集合（最常用）：数据结构是数组，使用该集合优点是通过索引获取元素的效率较快，缺点是删除和添加元素的效率较低；
2、LinkedList集合：数据结构是双向链表，该类也实现了Deque双向队列的接口；
3、Vector集合（很少使用）：Vector类出现的比较早，它跟ArrayList相比，它是线程安全的，但是由于使用了同步的方式，性能较低下，目前使用该类较少，了解即可；
4、Stack：Stack是Vector的一个子类，它的数据结构类似于栈，了解即可。

四、泛型

泛型是在JDK1.5加入的，在这之前集合在加入元素时，都是把元素当做Object对象，从而失去了元素的实际类型。引入泛型之后，在创建集合对象时，就可以指定集合接收的数据类型，在添加元素时就只能添加一种数据类型的元素，例如：Collection collection = new ArrayList(); 这时集合collection就只能添加String类型的元素，添加其他数据类型的数据，则编译的时候就会报错。

  • 1）泛型类
  • 把泛型定义在类上
  • 格式:public class 类名<泛型类型1,…>
  • 注意:泛型类型必须是引用类型
  • 2）泛型方法
  • 把泛型定义在方法上
  • 格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
  • 3）泛型接口
  • 把泛型定义在接口上
  • 格式:public interface 接口名<泛型类型1…>

1）泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
2）? extends E：向下限定，E及其子类（接收E或者E的子类对象）
3）? super E：向上限定，E及其父类（接收E或者E的父类对象）

下面定义一个泛型类：

/**
 * 定义泛型类格式：
 * [访问修饰符]  class 类名<泛型1,泛型2,…>{
 * 	[访问权限] 泛型类型标识  变量名;
 * 	[访问权限] 构造方法([<泛型类型>] 参数){
 * 	//代码
 * }
 * [访问权限] 返回值类型声明	方法名称(泛型类型标识 参数){
 * 
 * 	}
 * }
 */
public class GenericDemo<T> {
    private T t;
    public GenericDemo() {
    }
    public GenericDemo(T t) {
        this.t = t;
    }
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}
class GenericTest {
    public static void main(String[] args) {
        // 创建泛型类对象
        GenericDemo<Integer> gd = new GenericDemo<Integer>();
        gd.setT(1);
        // gd.setT("hello");// 不能添加
        System.out.println(gd.getT());// 1
    }
}

下面仅对ArrayLIst和LinkedList做代码示例：

ArrayList:
public class CollectionDemo1 {
    public static void main(String[] args) {
        // 创建集合对象，不使用泛型
        Collection collection = new ArrayList();
        // 添加元素
        collection.add("hello");
        int i = 2;
        collection.add(i);
        collection.add(1);
        collection.add(true);
        /*  这里需要注意，之所以能添加基本数据类型，
         *  是因为在JDK1.5中引入了自动装箱，这里
         *  会自动的把这些基本数据类型转成它们的
         *  包装类
         */
        Student student = new Student();
        student.setName("张三");
        student.setAge(20);
        collection.add(student);
        // 直接打印集合
        System.out.println(collection);// [hello, 2, 1, true, Student{name='张三', age=20}]

        // 使用泛型
        Collection<String> collection2 = new ArrayList<String>();
        collection2.add("hello");
        // collection2.add(student); // 不能添加
    }
}
1）ArrayList构造方法：
public class ArrayListDemo {
    public static void main(String[] args) {
        /**
         * 构造方法：
         * ArrayList()
         *          构造一个初始容量为 10 的空列表。
         *
         * ArrayList(Collection<? extends E> c)
         *           构造一个包含指定 collection 的元素的集合（<? extends E>，E表示Collection或者Collection的子类）
         *
         *  ArrayList(int initialCapacity)
         *           构造一个具有指定初始容量的空列表。
         */
        ArrayList list = new ArrayList();
        ArrayList list2 = new ArrayList(new ArrayList());
        ArrayList list3 = new ArrayList(2);
        // 打印集合大小
        System.out.println("list:" + list.size()); // 0
        System.out.println("list2:" + list2.size()); // 0
        System.out.println("list3:" + list3.size()); // 0
        // 集合的初识容量大小是10，如果集合中的元素超过10个，
        // 这时候集合就要进行扩容，大小是原来的1.5倍。

        // 如果创建集合的时候指定了容量，则集合中的元素个数
        // 超过了指定容量，集合才会进行扩容
    }
}
2）ArrayList成员方法：
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象，使用泛型
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("word");
        System.out.println(list);//[hello, word]
        list.add(1, "我是插入的"); // 在索引1处插入数据
        System.out.println(list);//[hello, 我是插入的, word]
        //返回此collection中的元素个数。
        System.out.println("size:" + list.size());//size:3
        //判断collection是否包含指定的元素（obj）。
        System.out.println("contains:" + list.contains("hello"));//contains:true
        // 返回此列表中指定位置上的元素。
        System.out.println("get:" + list.get(0)); // get:hello
        System.out.println("get:" + list.get(1)); // get:我是插入的
        ArrayList<Integer> integerList1 = new ArrayList<Integer>();
        ArrayList<Integer> integerList2 = new ArrayList<>();
        integerList1.add(0);
        integerList2.add(1);
        integerList2.add(2);
        integerList2.add(3);
        //将指定collection（c）中的所有元素添加到此collection中（集合中添加另一个集合元素）
        integerList1.addAll(integerList2);
        System.out.println(integerList1); // [0, 1, 2, 3]
        // ...
    }
}
3）集合的遍历：
public class IteratorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<String> list = new ArrayList<String>();
        // 添加元素
        list.add("hello");
        list.add("java");
        list.add("world");
        // 通过for循环遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //通过迭代器遍历
        //通过集合获取迭代器对象
        //迭代器，集合的专用遍历方式
        Iterator<String> iterator = list.iterator();
        // 通过迭代器对象的hashNext()方法判断集合中是否有元素，因为不知道遍历的次数，所以使用while循环
        while (iterator.hasNext()) {
            // 通过迭代器对象的next()方法获取元素
            String s = iterator.next();
            System.out.println(s);
        }
        // 在JDK1.5新增增强for循环，它也是for循环的一种，不过它简化数组和Collection集合的遍历
        /*
           格式：
            for(元素数据类型 变量 : 数组或者Collection集合) {
                使用变量即可（该变量就是元素）
            }
        */
        // list是集合对象，list中的元素是String类型，s就是list集合中的元素
        for (String s : list) {
            System.out.println(s);
        }
    }
}
LinkedList：
public class LinkedListDemo {
    public static void main(String[] args) {
        // A: LinkedList的特有添加功能addFirst()
        // 创建集合对象
        LinkedList<String> link = new LinkedList<String>();
        //
        // // 添加元素
        link.addFirst("hello");
        link.addFirst("world");
        link.addFirst("java");
        // addLast()在集合的尾部添加一个元素
        link.addLast("最后一个");
        System.out.println(link);//[java, world, hello, 最后一个]
        // // 遍历
        Iterator<String> it = link.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        // getFirst()获取但是不删除第一个元素
        System.out.println(link.getFirst());
        //getLast()获取但不删除最后一个元素
        System.out.println(link.getLast());
        // ...
    }
}

ArrayLiheLinkedList集合就介绍到这里，它们中还有许多成员方法，可以去api文档中去查看并使用。