AJPFX关于Collection接口的总结

###15Collection-List-ArrayList/LinkedList/
*  * Collection接口中的方法
* A:添加功能
*                 boolean add(Object obj):把obj这个元素，添加到集合中去
*                 boolean addAll(Collection c)：将 c 这个集合中的所有元素，都添加到本集合中来
* B:删除功能
*                 void clear()：删除集合中的所有元素。
*                 boolean remove(Object obj)：从集合中删除  obj 这个元素
*                 boolean removeAll(Collection c):从集合中删除c中含有的所有元素 
* C:判断功能
*                 boolean isEmpty()：判断集合是否为空。
*                 boolean contains(Object obj)：判断集合中是否存在 obj这个元素。
*                 boolean containsAll(Collection c)：判断集合中是否存在 c 集合中的所有元素。
* D:遍历功能
*                 Iterator iterator():就是用来获取集合中每一个元素。
* E:长度功能
*                 int size():获取集合中的元素个数
* F:交集功能
*                 boolean retainAll(Collection c): 保留本集合和c这个集合中的共同元素
* G:把集合转换成数组
*                 Object[] toArray():把集合变成 Object类型的数组。 
*/

/*
* List接口中的方法（List接口继承了Collection接口，所以下面只列出了List接口的特有方法）
* List的特有功能：
* 
* A:添加功能
*                 void add(int index, Object obj):在索引为 index的位置，添加 obj这个元素
* B:删除功能
*                 Object remove(int index):删除索引为index的元素，并把这个元素返回
* C:修改功能
*                 Object set(int index, Object obj):把索引为index的位置，修改为 obj这个元素， 并且把修改之前的元素返回。
* D:获取功能
*                 int indexOf(Object obj):返回 obj这个元素在集合中第一次出现的索引
*                 Object get(int index):获取索引为 index的元素对象
*                 ListIterator listIterator()：列表迭代器
* E:截取功能
*                 List subList(int fromIndex, int toIndex)：返回一个新的集合，这个集合里面的元素，是原来集合中的一部分，直接看下面代码
*         
###15.08_集合框架(迭代器的原理及源码解析)(了解)
Iterator it = iterator iterator();//获取迭代器
it.hasNext()//判断是否有元素一般while(it.hasNext())
It.next();//获取元素

###15.12_集合框架(ListIterator)(了解)
* boolean hasNext()是否有下一个
* boolean hasPrevious()是否有前一个
* Object next()返回下一个元素
* Object previous();返回上一个元素

###15.13_集合框架(Vector的特有功能)(面试用开发中不用)
* A:Vector类概述
* B:Vector类特有功能
        * public void addElement(E obj)
        * public E elementAt(int index)
        * public Enumeration elements()
B:List有三个儿子，我们到底使用谁呢?
                查询多用ArrayList
                增删多用LinkedList
                如果都多ArrayList
集合框架(LinkedList的特有功能)(掌握)
* A:LinkedList类概述
* B:LinkedList类特有功能
        * public void addFirst(E e)及addLast(E e) //在开始加入元素//在最后加入元素
        * public E getFirst()及getLast()////获取第一个元素//获取最后元素
        * public E removeFirst()及public E removeLast() //删除第一个元素//删除最后一个元素
        * public E get(int index);// 获取索引处的元素

_集合框架(栈和队列数据结构)(掌握)
* 栈
        * 先进后出 
* 队列
        * 先进先出

_集合框架(泛型概述和基本使用)(掌握)
* A:泛型概述
* B:泛型好处
        * 提高安全性(将运行期的错误转换到编译期) 
        * 省去强转的麻烦
* C:泛型基本使用
        * <>中放的必须是引用数据类型 
* D:泛型使用注意事项
        * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)  
集合框架(增强for的概述和使用)(掌握)
* A:增强for概述
        * 简化数组和Collection集合的遍历
* B:格式：
* 
                for(元素数据类型 变量 : 数组或者Collection集合) {
                        使用变量即可，该变量就是元素
                }
_集合框架(三种迭代的能否删除)(掌握)
* 普通for循环,可以删除,但是索引要--
* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
* 增强for循环不能删除只能遍历

_集合框架(静态导入的概述和使用)(了解)
* A:静态导入概述
* B:格式：
        * import static 包名….类名.方法名;
        * 可以直接导入到方法的级别
* C:注意事项
        * 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?
        这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
_集合框架(可变参数的概述和使用)(掌握)
* A:可变参数概述
        * 定义方法的时候不知道该定义多少个参数
* B:格式
        * 修饰符 返回值类型 方法名(数据类型…  变量名){}
* C:注意事项：
        * 这里的变量其实是一个数组
        * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
/**
         * * A:可变参数概述
                        * 定义方法的时候不知道该定义多少个参数
                * B:格式
                        * 修饰符 返回值类型 方法名(数据类型…  变量名){}
                * C:注意事项：
                        * 这里的变量其实是一个数组
                        * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
         */
        public static void main(String[] args) {
                int[] arr = {11,22,33,44,55};
                //print(arr);
                print(11,22,33,44,55);
                System.out.println("---------------");
                //print();
        }
        
        /*public static void print(int[] arr) {
                for (int i = 0; i < arr.length; i++) {
                        System.out.println(arr[i]);
                }
        }*/
public static void print(int ... arr) {                        //可变参数其实是一个数组
                for (int i = 0; i < 
错误！未找到目录项。
arr.length; i++) {
                        System.out.println(arr[i]);
                }
        }

集合框架(Arrays工具类的asList()方法的使用)(掌握)
* A:案例演示
        * Arrays工具类的asList()方法的使用
                Integer[] i = {1,2,3,4,5};
                List<Integer> l = Arrays.asList(i);//将数组转成集合只能用引用类型数组
                System.out.println(l);

* Collection中toArray(T[] a)泛型版的集合转数组
        
_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)
* A:案例演示
        * 集合嵌套之ArrayList嵌套ArrayList
HashSet方法
1)基本数据类型去掉重复元素并且无索引(进 出不同)
2)引用数据类型:要重写toString方法
  如果要去除重复就要重写hashCode()方法与equals()方法
Hashcode()设置的原则:/如果对象的成员变量值一样，那么就想办法让这个方法的返回值一样，否则让返回值不一样
HashSet中想去掉重复元素必须重写hashCode()和equals()方法;

LinkedHashSet方法
特点:底层是链表实现的 是Set()集合中唯一一个能保证怎么存怎么取得功能
因为是HashSet的子类,索引也是保证元素的唯一性

TreeSet 集合: 
一般类型 用来对元素进行排序的并且保证元素的唯一(去除重复元素,并排序)
引用数据类型:首先:重写toString()方法;(如果不重写输出的是地址值)
实现接口implements comparable<本类名> 此时类名会报错(ctrl+1) 
自动创建一个方法compareTo(类名) {
判断成员变量
}
以上三步缺一不可
        /*@Override
        //按照年龄排序
        public int compareTo(Person o) {
                int num = this.age - o.age;        //年龄是比较的主要条件
                return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
        }*/
        /*@Override
        //按照姓名排序
        public int compareTo(Person o) {
                int num = this.name.compareTo(o.name);                //姓名是主要条件
                return num == 0 ? this.age - o.age : num;        //年龄是次要条件
        }*/
        /*
         * aaa
         * bbb
         */
        public int compareTo(Person o) {
                int length = this.name.length() - o.name.length();                                //比较长度为主要条件
                int num = length == 0 ? this.name.compareTo(o.name) : length;        //比较内容为次要条件
                return num == 0 ? this.age - o.age : num;                                                //比较年龄为次要条件
        }            
面试手写 
        public boolean equals(Object obj) {
                System.out.println("执行了吗");
                Person p = (Person)obj;
                return this.name.equals(p.name) && this.age == p.age;
        }
        @Override
        public int hashCode() {
                final int NUM = 38;
                return name.hashCode() * NUM + age;
        }*/

HashSet()
* 1.特点
        * TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
* 2.使用方式
        * a.自然顺序(Comparable)
                * TreeSet类的add()方法中会把存入的对象提升为Comparable类型
                * 调用对象的compareTo()方法和集合中的对象比较
                * 根据compareTo()方法返回的结果进行存储
        * b.比较器顺序(Comparator)
                * 创建TreeSet的时候可以制定 一个Comparator
                * 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
                * add()方法内部会自动调用Comparator接口中compare()方法排序
                * 调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
        * c.两种方式的区别
                * TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
                * TreeSet如果传入Comparator, 就优先按照Comparator