经常使用的API--集合

# 经常使用的API --> 集合
     * 首先咱们须要明白的是，集合和数组有什么区别呢，咱们何时能够使用集合，又在何时能够使用数组呢？
         A:数组的长度不可变化,集合的长度能够变化
         B:数组只能存储同一种数据类型,集合能够存储任意数据类型的数据
             ArrayList list = new ArrayList();
             list.add(10); // list.add(new Integer(10));
             list.add("abc");
         C:数组能够存储基本数据类型,也能够存储引用数据类型(对象)
             int[] arr = new int[4];
             Student[] arr = new Student[3];
             集合只能存储引用数据类型(对象)
     1. 集合的体系
         学顶层，用底层，子类均能继承父类方法
         Collection(接口)
             |--List:特色 有序，有索引，可存储重复元素
                 |--ArrayList
                 |--LinkedList
                 |--Vector
             |--Set:无序，无索引，不可存储重复元素
                 |--HashSet
                     |--LinkedHashSet
                 |--TreeSet
     2. Collection接口中的方法
             boolean add(E e) : 给集合添加元素
             boolean remove(Object obj) : 删除集合中指定的元素
             boolean contains(Object obj) : 判断集合中是否包含指定的元素
             int size() : 获取集合中元素的个数
             Object[] toArray(): 将集合转换为数组 , 能够使用该方法遍历集合
             clear() : 清除全部的元素
             boolean isEmpty() : 判断集合中元素的个数是否为0
     3. 迭代器
         * 做用：遍历集合
         * Iterator是一个接口，其中包含的方法
             boolean hasNest()：判断是否还有元素，一般用做判断循环退出的条件
             E next()：获取下一个元素。用以对迭代器遍历的数据进行单个操做
         * 一般操做步骤：
             Iterator it = new Iterator();
             while(it.hasnext()){
                 E 变量名 = it.next();
                 变量操做语句;
             }
 
         * 使用迭代器遍历集合标准代码:
             Collection<String> c = new ArrayList<String>();
             //添加元素
             
             //遍历集合
             Iterator it = c.iterator();
             while(it.hasNext()) {
                 String str = it.next();
                 System.out.println(str);
             }
     4. 加强for循环
         使用起来特别方便
         
         做用: 遍历集合或者数组
         
         格式:
             for(数组/集合元素的类型 变量名: 数组/集合对象) {
                 
             }
         注意:
         加强for循环遍历集合底层使用的是迭代器
         加强for循环遍历数组底层使用的是普通for循环
         使用加强for循环只是遍历集合,若是要对集合的元素的个数进行改变的话,咱们就不能使用加强for循环
     5. 集合的遍历方式:
                 (1)转数组--> toArray()
                 (2)迭代器--> Iterator
                 (3)加强for循环-->只能遍历，不能改变
     
     6. 泛型
         * 概述
         在定义类或者接口或者方法的时候,不能肯定具体的数据类型,而是在使用的时候确认
         * 要求:
         会使用就行,对于泛型类,泛型接口,泛型方法的定义做为了解,由于开发中通常不会定义泛型类
         
         * 定义泛型类
         public class 类名<T> {
             能够使用T,把T看作是数据类型就能够了
         }
         例如：
             public class MyOwnClass<MVC> {
                 private MVC mvc;
             
                 public MVC getMvc() {
                     return mvc;
                 }
             
                 public void setMvc(MVC mvc) {
                     this.mvc = mvc;
                 }
             }
         而后在main方法中使用时赋予泛型具体的类型：
             MyOwnClass<String> mo = new MyOwnClass<String>();
             mo.setMvc("James");
             String mvp = mo.getMvc();
         
         * 定义泛型方法
         修饰符 <T> 返回值类型 方法名(T t) {
             方法体;
             return 返回值;
         }
         例如：
             public class FanXingMethod {
 
                 public <MVP> void show(MVP mvp){
                     System.out.println(mvp.getClass());
                 }
             
                 public <MVP> MVP show2(MVP mvp){
                     return mvp;
                 }
             }
         而后再main方法中使用泛型方法时赋予其具体的类型：
             public static void main(String[] args) {
                 FanXingMethod fx = new FanXingMethod();
                 fx.show("aaa");
                 fx.show(123);
                 fx.show(12.45);
                 String bbb = fx.show2("bbb");
                 Integer a = fx.show2(123);
                 Double b = fx.show2(12.45);
             }
         
         * 定义泛型接口
             public interface 接口名<T> {
                 
             }
             
             泛型接口的子实现类:
                 带泛型的
                     public class 类名<T> implements 接口名<T> {
                         
                     }
                 不带泛型的
                     public class 类名 implements 接口名<具体的数据类型> {
                         
                     }