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{
    private int x;
    public TypeDemo(int x){
        this.x =x;
    }
    public String toString(){

        return x+"";
    }

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

TypeDemo t = new TypeDemo(“qw”);

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

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

在集合中的泛型

public static void main(String[] args) {
        //所有的集合都支持泛型，那么一般一个集合的类型一样的话，可以直接用泛型指定为什么类型
        Collection 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

List

分为：
ArrayList和LinkList

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

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

        List 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 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 list = new ArrayList();
        for (int i=0;i<10;i++){
            list.add(i);    
        }
        System.out.println(list);
        /*
         * List subList(int start, int end)
         * 获取当前集合的子集
         */
        List list1 = list.subList(3, 8);
        System.out.println(list1);
    }

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

List转换为数组：

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

public static void main(String[] args) {
        Collection c = new ArrayList();
        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 list = Arrays.asList(array);
        //但是转换为List后，不能在增加了。是只读的
    }

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

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

集合的排序：

public static void main(String[] args) {
        List 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);