JAVASE之集合

集合：

List和Set

List可重复，Set可重复

重不重复就是用equals比较的结果

查看集合中是否包含给定的元素

没重写equals还是判断是否是同一个对象，用的双等于

c.contanins(元素); 判断集合中是否包含某元素

包含取决于集合中的元素是否有与给定元素equals比较为true的
但是没有放进集合也有可能不包含。

给定的元素与集合中的每一个元素equals比较。

集合的其他方法

public static void main(String[] args) {        Collection c = new ArrayList();        int s1 = c.size();        System.out.println("size:"+s1);        /*         * boolean isEmpry()         * 查看集合中是否不含有任何元素         * 就是是空的吗？         */        boolean e1 = c.isEmpty();        System.out.println(e1);        //增加元素        c.add("111");        c.add(123);        int s2 = c.size();        System.out.println("size:"+s2);        boolean e2 = c.isEmpty();        System.out.println(e2);        c.clear();        boolean e3 = c.isEmpty();        System.out.println(e3);    }

addAll、containsAll

一般也在集合中放同一类的元素

addALL方法

public static void main(String[] args) {        Collection conn1 = new ArrayList();        conn1.add("java");        conn1.add(".net");        conn1.add("c#");        conn1.add("php");        System.out.println(conn1);        Collection conn2 = new ArrayList();        conn2.add("android");        conn2.add("ios");        //addALL就是把另一个List中的元素放入这个List中        conn1.addAll(conn2);        System.out.println(conn1);    }

Collection conn3 = new ArrayList();        conn3.add("java");        conn3.add("ios");        //查看当前集合中是否保护给定集合中的所有元素，        //也是根据元素的equals来判断的。        boolean b = conn1.containsAll(conn3);        System.out.println("全包含:"+b);    }

删除 remove

传入参数： 要删除什么传入什么，然后比较用的是equals

boolean remove(object o)

从当前集合中删除给定元素
删除元素是根据元素的equals的结果判断

remove只删除第一个遇到的元素

使用迭代器遍历List中元素：

public class CollectionIterator {    public static void main(String[] args) {        Collection c = new ArrayList();        c.add("a");        c.add("b");        c.add("c");        c.add("d");        c.add("e");        /*         * Iteartor是一个接口         * java希望我们使用统一的方式遍历所有集合         * 使用迭代器遍历集合必须遵循以下过程         * 问，取，删（删除不是必须操作）         *          */        Iterator it =c.iterator();        /*         * boolean hashNext（）         * 询问迭代器，遍历的集合是否还有元素可以取出         * 用while循环判断，有就继续取出，在list中都认为是object，什么都能取出来         * 然后用object 接受 取出的，然后在给他强制转换为字符串         */        while (it.hasNext()){            Object obj = it.next();            String str = (String)obj;            System.out.println(str);//可以直接： String str = (String)it.next();        }    }

!!!
尽量使用字面量.equals(变量)
这样可以避免空指针异常的产生
如果在迭代器中 it.remove();要在前面it.next()才行，然后remove删除当前next出来的元素

。。。。。
另一种遍历集合的方法(java5.0后)
比迭代器更方便：

public static void main(String[] args) {        Collection c = new ArrayList();        c.add("one");        c.add("two");        c.add("three");        c.add("four");        //新循环        for(Object a:c){            String str = (String)a;            System.out.println(str);        }

当然也可以用新循环遍历数组

泛型机制：

在类后面加个尖括号 ，一般一个字母，这个类型叫T，也可以叫别的。声明了T这么一个类型。
于是可以 在定义属性时 返回值可以定义为 T这个类型
在用的时候给真实类型
如：
在写一个类，

public class TypeDemo<T>{    private int x;    public TypeDemo(int x){        this.x =x;    }    public String toString(){        return x+"";    }

然后在实例化时给到底是什么类型的

TypeDemo<String> t = new TypeDemo<String>(“qw”);

在类中的get，set方法中也要设置返回值为T

！！！！！
尖括号中只能写引用类型不能是基本类型也就是说要是用int就要：写 Integer
不能写基本类型，先不告诉他什么类型，后面用的时候告诉他

在集合中的泛型

public static void main(String[] args) {        //所有的集合都支持泛型，那么一般一个集合的类型一样的话，可以直接用泛型指定为什么类型        Collection<String> c = new ArrayList();        c.add("one");        c.add("two");        c.add("three");        c.add("four");        //因为泛型定义了是String，那么直接就可以赋值输出了        for(String o:c){            System.out.println(o);        }    }迭代器也可以用泛型Iterator<String>

List

分为：
ArrayList和LinkList

ArrayList 内部是数组实现的 适用查找
LinkList内部是用于链表实现的 适用增删

List除了继承Coleection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最长远的就是基于下标的get和set方法：
get(int index)
获取集合中指定下标对应的元素，下标从0开始
set(int index ,E element)
将给定的元素存入给定位置，并将原位置的元素返回。
相当于给替换了，然后把集合中的元素取出来。

        List<String> c = new ArrayList();        c.add("one");        c.add("two");        c.add("three");        c.add("four");    System.out.println(c.get(1));    System.out.println(c.set(1, "five"));    System.out.println(c.get(1));    }

List集合的插入和删除

插入指定位置

List<String> list = new ArrayList();        list.add("one");        list.add("two");        list.add("three");        /*         * void add(int index ,T t)         * 将给定的元素添加到给定的位置上         * 原位置以及后续的元素顺序向后移动         * 插入操作         */        System.out.println(list);        list.add(1,"123");        System.out.println(list);

同样，remove是删除指定下标的元素，然后返回值是删除的元素。

List获取子集的方法：

public class ListDemo3 {    public static void main(String[] args) {        List<Integer> list = new ArrayList();        for (int i=0;i<10;i++){            list.add(i);            }        System.out.println(list);        /*         * List subList(int start, int end)         * 获取当前集合的子集         */        List<Integer> list1 = list.subList(3, 8);        System.out.println(list1);    }

！！！！！！！
修改子集元素会影响原集合
！！！！！！

List转换为数组：

集合转成数组容易，但是数组只能转为List

public static void main(String[] args) {        Collection<String> c = new ArrayList<String>();        c.add("one");        c.add("two");        c.add("thiree");        //直接用toArray的话返回的是Object        //Object[] array =c.toArray();        //但是向方法里面传个数组就直接可以定义它的类型        String [] array=c.toArray(new String[c.size()]);        //如果传入的数组不够长，他会自己创建个同类型的数组        //长度够就用    }

数组转为List

public static void main(String[] args) {        String [] array = {"1","2","3","4","5"};        List<String> list = Arrays.asList(array);        //但是转换为List后，不能在增加了。是只读的    }

可以增加的话就在自己创建个List

public static void main(String[] args) {        String [] array = {"1","2","3","4","5"};        List<String> list = Arrays.asList(array);        //但是转换为List后，不能在增加了。是只读的’        //要想添加就要复制个,可以直接把另一个List在创建List时直接传入，就相当于复制了一哈        List<String> list2 = new ArrayList(list);        list2.add("6");        System.out.println(list2);    }

集合的排序：

public static void main(String[] args) {        List<Integer> c = new ArrayList();        Random random = new Random();        for(int i=0;i<10;i++){            c.add(random.nextInt(100));        }        System.out.println(c);        //通过Collections这个集合的工具类        //我们可以对List集合进行孜然排序        Collections.sort(c);        System.out.println(c);          }

如果List中的是对象的话，不能用Collections.sort排序，如果用的话要是可以排序的
使用Colletions的sort方法进行排序的集合，要求元素必须实现Comparable接口，只有实现了该接口才认为是可比较的元素

那么就可以让那个对象被实例的类实现接口 Comparable
即：

类 implements Comparable<类（就是这个类，说明和自己比）>{}

这个是比较大小的方法

返回值不关注具体的值，只关注取值范围返回值<0： 当前对象比给定的对象小返回值=0： 两个对象相等返回值>0： 当前对象比给定的对象大在下面就实现方法 compare(类 o){在这里可以自己定义比较规划，定义比较什么，规定什么大，什么小。return 两个值的差}

就是用泛型说明比较的就是自己这个类，然后下面传入的参数也就变成了这个类

实现了接口就可以比较对象的大小了~~~

对于字符串排序的话，按首字母排序，相同看第二个~~

对于汉字的排序的话，按照 Unicode排序的。

如果要让他按我想的排序，就是按字符串长短排序

不能重写~

比较器：

写个类，然后实现接口 Comparator{

public int compare(String o1, String o2){return o1.length()-o2.length()；}}

然后在比较之前创建一个比较器，实例化这个类

Comparator com = new 那个类();

然后把创建的比较器和list一起传入Collection，调用sort排序方法进行比较，就按自己定义的排序方式来比较
Collections.sort(list,com);

何时使用匿名内部类

当我们需要用到一个实例，而该实例所属的类需要实现一个接口或者继承一个类，并且该实例仅在这里用一次，不会再其他地方使用时，我们就应当选取使用匿名内部类的形式创建实例

例如：
使用比较器

Comparator com = new Comparator(){public int compare(Object o1,Object o2){return 0;}};

还是可以使用泛型

Comparator com = new Comparator<类名>(){public int compare(类名 o1,类名 o2){return o1.属性-o2.属性;}};然后Collections.sort(list,com);