1、集合的体系结构

集合是java中提供的一种容器，可以用来存储多个数据，并且可以存储任意类型的数据！
集合和数组的区别：
1、数组的长度是固定的，集合的长度是可变的
2、数组中存储的是同一类型的元素，可以储存基本数据类型值，集合存储的都是对象，而且对象的类型可以不一致。
集合按照其存储结构分为两大类，分为单列集合java.util.Collection和双列集合java.util.Map
Conllection：单列集合类的根接口
List: 元素有序，元素可重复
主要实现类：ArrayList、LinkedList
Set: 元素无序，不可重复
主要实现类：HashSet、LinkedHashSet

2、Collection集合

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）的一些方法，这些方法可用于操作所有的单列集合
1、点一个add（E e）：把给定的对象添加到当前集合中，返回值为boolean
2、点一个remove（E e）：把给定的对象在当前集合中删除，返回值为boolean
3、点一个contains（E e）：判断当前集合中是否包含给定的对象，返回值为boolean
4、点一个isEmpty（）：判断当前集合是否为空，返回值为boolean
5、点一个size（）：返回集合中元素的个数，返回值为int
6、点一个toArray（）：把集合中的元素，储存到数组中，返回值为Object[]
7、点一个clear（）：清空集合中的所有元素，无返回值

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  4. public class Demo1Collection {
  5.     public static void main(String[] args) {
  6.         // 创建集合对象 
  7.         // 使用多态形式
  8.         Collection<String> coll = new ArrayList<String>();
  9.         // 使用方法
  10.         // 添加功能  boolean  add(String s)
  11.         coll.add("小李广");
  12.         coll.add("扫地僧");
  13.         coll.add("石破天");
  14.         System.out.println(coll);
  16.         // boolean contains(E e) 判断o是否在集合中存在
  17.         System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));
  19.         //boolean remove(E e) 删除在集合中的o元素
  20.         System.out.println("删除石破天："+coll.remove("石破天"));
  21.         System.out.println("操作之后集合中元素:"+coll);
  23.         // size() 集合中有几个元素
  24.         System.out.println("集合中有"+coll.size()+"个元素");
  26.         // Object[] toArray()转换成一个Object数组
  27.         Object[] objects = coll.toArray();
  28.         // 遍历数组
  29.         for (int i = 0; i < objects.length; i++) {
  30.             System.out.println(objects[i]);
  31.         }
  33.         // void  clear() 清空集合
  34.         coll.clear();
  35.         System.out.println("集合中内容为："+coll);
  36.         // boolean  isEmpty()  判断是否为空
  37.         System.out.println(coll.isEmpty());      
  38.     }
  39. }

3、Iterator迭代器

由于Collection集合，是没有索引的，如果我们遍历Collection集合，for循环是无法使用的，当然了，我们可以用Collection中的（toArray）方法转成数组，然后再遍历，不过这种方法总是不舒服，所以JDk提供了一个Iterator接口来专门用来遍历集合
因为Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器
迭代：就是Collection集合的通用获取方式，在取元素之前先要判断集合中有没有元素，如果有，就取出来，继续判断，继续取，一直把集合中的所有元素全部取出，这种取出方式专业术语称为迭代
获取Iterator：

  1. public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

点一个next（）：返回迭代的下一个元素，返回值为一个对象
点一个hasNext（）：如果仍有元素可以迭代，则返回 true

  1. public class IteratorDemo {
  2.       public static void main(String[] args) {
  3.         // 使用多态方式 创建对象
  4.         Collection<String> coll = new ArrayList<String>();
  6.         // 添加元素到集合
  7.         coll.add("串串星人");
  8.         coll.add("吐槽星人");
  9.         coll.add("汪星人");
  10.         //遍历
  11.         //使用迭代器 遍历   每个集合对象都有自己的迭代器
  12.         Iterator<String> it = coll.iterator();
  13.         //  泛型指的是 迭代出 元素的数据类型
  14.         while(it.hasNext()){ //判断是否有迭代元素
  15.             String s = it.next();//获取迭代出的元素
  16.             System.out.println(s);
  17.         }
  18.       }
  19. }

4、增强for

增强for循环（也称for each循环）是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的，它的内部原理其实是个iterator迭代器，所以在遍历的过程中，不能对集合的元素进行增删操作

  1. for(元素的数据类型  变量 : Collection集合or数组){ 
  2.       //写操作代码
  3. }
  4. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  5. public class NBForDemo1 {
  6.     public static void main(String[] args) {
  7.         int[] arr = {3,5,6,87};
  8.            //使用增强for遍历数组
  9.         for(int a : arr){//a代表数组中的每个元素
  10.             System.out.println(a);
  11.         }
  12.     }
  13. }
  14. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  15. public class NBForDemo2 {
  16.     public static void main(String[] args) {        
  17.         Collection<String> coll = new ArrayList<String>();
  18.         coll.add("小河神");
  19.         coll.add("老河神");
  20.         coll.add("神婆");
  21.         //使用增强for遍历
  22.         for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
  23.             System.out.println(s);
  24.         }
  25.     }
  26. }

新for循环必须有被遍历的不妙，目标只能是Collection或者是数组，新式for仅仅作为遍历操作出现

5、List集合

List接口继承Collection接口，是单列集合的一个重要的分支，习惯性的会将实现了list接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线性方程进行存储的，在程序中可以通过索引来访问集合中的指定元素，另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致
1、它是一个元素存取有序的集合
2、它是一个带有索引的集合，通过索引就可以精准的操作集合中的元素
3、集合中可以有有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

public void add(int index, E element) 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) 返回集合中指定位置的元素·。
public E remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) 用指定元素替换集合中指定位置的元素,返回值的更新前的元素。 
  1. public class ListDemo {
  2.     public static void main(String[] args) {
  3.         // 创建List集合对象
  4.         List<String> list = new ArrayList<String>();
  6.         // 往 尾部添加 指定元素
  7.         list.add("图图");
  8.         list.add("小美");
  9.         list.add("不高兴");
  11.         System.out.println(list);
  12.         // add(int index,String s) 往指定位置添加
  13.         list.add(1,"没头脑");
  15.         System.out.println(list);
  16.         // String remove(int index) 删除指定位置元素  返回被删除元素
  17.         // 删除索引位置为2的元素 
  18.         System.out.println("删除索引位置为2的元素");
  19.         System.out.println(list.remove(2));
  21.         System.out.println(list);
  23.         // String set(int index,String s)
  24.         // 在指定位置 进行 元素替代（改） 
  25.         // 修改指定位置元素
  26.         list.set(0, "三毛");
  27.         System.out.println(list);
  29.         // String get(int index)  获取指定位置元素
  31.         // 跟size() 方法一起用  来 遍历的 
  32.         for(int i = 0;i<list.size();i++){
  33.             System.out.println(list.get(i));
  34.         }
  35.         //还可以使用增强for
  36.         for (String string : list) {
  37.             System.out.println(string);
  38.         }      
  39.     }
  40. }

6、List集合的子类

ArrayList集合：

  1. java.util.ArrayList`集合数据存储的结构是数组结构。元素增删慢，查找快，
  2. 由于日常开发中使用最多的功能为查询数据、遍历数据，
  3. 所以`ArrayList`是最常用的集合。方法名说明
  4. public void add(int index, E element)将指定的元素，添加到该集合中的指定位置上。
  5. public E get(int index)返回集合中指定位置的元素·。
  6. public E remove(int index)移除列表中指定位置的元素, 返回的是被移除的元素。
  7. public E set(int index, E element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
  8. public boolean add(E e)将指定的元素添加到此列表的尾部

LinkedList集合：

  1. 实际开发中对一个集合元素的添加与删除经常涉及到首尾操作
  2. 而LinkedList提供了大量首尾操作的方法。
  3.     这些方法我们作为了解即可：
  4. public void addFirst(E e)将指定元素插入此列表的开头。
  5. public void addLast(E e)将指定元素添加到此列表的结尾。
  6. public E getFirst()返回此列表的第一个元素。
  7. public E getLast()返回此列表的最后一个元素。
  8. public E removeFirst()移除并返回此列表的第一个元素。
  9. public E removeLast()移除并返回此列表的最后一个元素。
  10. public E pop()从此列表所表示的堆栈处弹出一个元素。
  11. public void push(E e)将元素推入此列表所表示的堆栈。
  12. public boolean isEmpty()如果列表不包含元素，则返回true。
  13. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  14. public class LinkedListDemo {
  15.     public static void main(String[] args) {
  16.         LinkedList<String> link = new LinkedList<String>();
  17.         //添加元素
  18.         link.addFirst("abc1");
  19.         link.addFirst("abc2");
  20.         link.addFirst("abc3");
  21.         System.out.println(link);
  22.         // 获取元素
  23.         System.out.println(link.getFirst());
  24.         System.out.println(link.getLast());
  25.         // 删除元素
  26.         System.out.println(link.removeFirst());
  27.         System.out.println(link.removeLast());
  29.         while (!link.isEmpty()) { //判断集合是否为空
  30.             System.out.println(link.pop()); //弹出集合中的栈顶元素
  31.         }
  32.         System.out.println(link);
  33.     }
  34. }

7、数据结构