java 集合Collection

1. java集合框架图

图片来源　　https://blog.csdn.net/u010887744/article/details/50575735

2. 迭代器

Iterator:迭代器，它是Java集合的顶层接口（不包括 map 系列的集合，Map接口 是 map 系列集合的顶层接口）

使用场景:只要实现了Iterable接口的类，就可以使用Iterator迭代器,注意：map系列集合不能够使用迭代器

迭代器函数：

Object next()：返回迭代器刚越过的元素的引用，返回值是 Object，

Iterator<Student> it = arr.iterator();　　// 这样使用时可以不强制类型转换

boolean hasNext()：判断容器内是否还有可供访问的元素

void remove()：删除迭代器刚越过的元素

3. 集合遍历的三种方法：

    public static void main(String[] args) {
        ArrayList<Student> arr = new ArrayList<Student>();
        Student s1 = new Student("linqinxia", 216);
        Student s2 = new Student("diaochan", 78);
        Student s3 = new Student("wnagjing", 78);
        Student s4 = new Student("wnagjun", 88);

        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        arr.add(s4);
        // 方法1：迭代器遍历
        Iterator<Student> it = arr.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
        // 方法2：增强for 遍历
        for (Student m : arr) {
            System.out.println(m.getName() + "----" + m.getAge());
        }
        // 方法3：使用for 循环遍历
        for (int x = 0; x < arr.size(); x++) {
            Student s = (Student) arr.get(x);
            System.out.println(s.getName() + "----" + s.getAge());
        }
    }

 

4. collection(接口，继承自Iterable，实现：AbstractCollection)：

    public static void main(String[] args) {
        Collection<Person> c1 = new ArrayList<Person>();
        Collection<Student> c2 = new ArrayList<Student>();
        Collection<Student> c3 = new ArrayList<Student>();
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = new Person();
        Student s1 = new Student("wangjing", 20);
        Student s2 = new Student("wangjun", 21);
        Student s3 = new Student("xiaoha", 19);
        Student s4 = new Student("wangjing", 20);
        c1.add(p1);                //1. add(#):添加一个元素                    
        c1.add(p2);
        c1.add(p3);
        c2.add(s1);
        c2.add(s2);
        c2.add(s3);
        c3.add(s4);
        c1.addAll(c2);            //2. addAll(Collection<? extends E>):添加另一个集合中所有的元素
        System.out.println(c1.size());
        c1.clear();                //3. clear():清除集合中所有的元素
        System.out.println(c1.size());
        System.out.println(c2.contains(s2));    //4. contains(Object):判断该元素是否在集合中
        System.out.println(c2.containsAll(c3));    //5. containsAll(Collection<? extends E>):判断输入集合所有元素是否在该集合中
        c3.add(s2);
        c3.add(s3);
        System.out.println(c2.equals(c3));        //6. equals(Object):判断两个集合中所有的元素是否相等,只需要判断c2中的每一个元素是否equals c3中的一个元素，equals可以重写
        System.out.println(c2.hashCode());        //7. hashCode():返回集合的hashCode编码
        Iterator<Student> it = c2.iterator();    //8. iterator():返回集合的迭代器
        while(it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + ":" + s.getAge());
        }
        System.out.println(c2.parallelStream());    //9. parallelStream():返回java.util.stream.ReferencePipeline$Head@5c647e05
        c2.remove(s2);                            //10. remove(Object):删除一个元素
        System.out.println(c2.size());
        c2.add(s2);
        c2.removeAll(c3);                    // 11. removeAll(Collection<?>) 
        System.out.println(c2.size());
        c2.size();                            //12. c2.size():返回集合的大小
        c2.add(s1);
        c2.add(s2);
        c2.add(s3);
        Student[] s = c2.toArray(new Student[0]);    //13 toArray[T[]] 将集合转换成数组    数组转集合的方法：List<String> mlist = Arrays.asList(array);
        System.out.println(s[1].getName());
        Object[] objs = c2.toArray();                //14 toArray[]，集合转数组
        System.out.println(Arrays.toString(objs));
        c3.clear();
        c3.add(s1);
        c3.add(s2);
        c2.retainAll(c3);            //15 retainAll(): c2中的元素全部使用c3中的元素代替
        Object[] obj = c2.toArray();                
        System.out.println(Arrays.toString(obj));
    }

 

5 List(接口，继承自Collection，实现：AbstractCollection，有序（存储顺序与取出顺序一致）可以重复)

    public static void main(String[] args) {
        List<String> s = new ArrayList<String>();
        s.add("wangjing");
        s.add("wangjun");
        s.add("wangjing");
        s.add("xiaoha");
        s.add("wangjing");
        System.out.println(s.indexOf("wangjing")); // indexOf(Object) 返回对象在集合中首次出现的索引
        System.out.println(s.lastIndexOf("wangjing")); // lastIndexOf(Object) 返回对象在集合中最后一次出现的索引
        ListIterator<String> lt = s.listIterator(); // listIterator 返回ListIterator接口的具体实现
        // ------------------------ListIterator---------------------------------
        System.out.println(lt.next()); // ListIterator:next() 返回下一个对象，注意，next()第一次使用后对应的索引是0
        System.out.println(lt.previous()); // ListIterator:previous() 返回上一个对象
        lt.next();
        lt.next();
        System.out.println(lt.nextIndex()); // ListIterator:nextIndex() 返回下一个next()对象的索引
        lt.add("lainglaing"); // ListIterator:add(E) 从当前索引所在的位置插入对象，next()指向第几个对象，从第几个对象的位置插入
        while (lt.hasNext()) { // ListIterator:Next() 判断是否有前一个对象
            lt.next();
        }
        while (lt.hasPrevious()) { // ListIterator:hasPrevious() 判断是否有前一个对象
            System.out.println(lt.previous());
        }
        System.out.println("--------");
        lt.remove(); // ListIterator:remove() 删除迭代器最后一次操作的元素，此次删除的是集合的第一个元素
        while (lt.hasNext()) { // ListIterator:Next() 判断是否有前一个对象
            System.out.println(lt.next());
        }
        lt.set("xiaohuang"); // ListIterator:set(E) 将迭代器最后一次返回的对象用E替代
        while (lt.hasPrevious()) { // ListIterator:hasPrevious() 判断是否有前一个对象
            lt.previous();
        }
        while (lt.hasNext()) { // ListIterator:Next() 判断是否有前一个对象
            System.out.println(lt.next());
        }
        System.out.println("*************************88");
        // ------------------------------------------------------------------------
        ListIterator<String> lm = s.listIterator(3); // listIterator(n) 取集合前n-1个元素转换成ListIterator
        while (lm.hasNext()) { // ListIterator:Next() 判断是否有前一个对象
            System.out.println(lm.next());
        }

        List<String> li = s.subList(0, 3);            //sublist(int, int) 截断操作，包左不包右
        for (int i = 0; i < li.size(); i++) {
            System.out.println(li.get(i));
        }
        System.out.println("--------------");
        s.set(1, "wangwangwang");                //set(int, E):修改第n个对象，使用E代替
        for (int i = 0; i < s.size(); i++) {
            System.out.println(s.get(i));
        }
    }

5.1 ArrayList

特点：底层数据结构是数组，查询快，增删慢

线程不安全，效率高

5.2 Vector

特点：底层数据结构是数组，查询快，增删慢

线程安全，效率低

5.3 LinkedList

特点：底层数据结构是链表，查询慢，增删快

线程不安全，效率高

6. Set(元素唯一性)

 6.1 HashSet

特点：基于哈希表：一个元素为链表的数组，综合了数组和链表的特点，无序

重要：唯一性依赖于底层的hashCode()和equals()

public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("hello");        //add(E): 底层依赖hashCode() 和 equals()
        set.add("java");        //String重写了hashCode() 和 equals()
        set.add("world");
        set.add("hello");
        set.add("java");
        set.add("world");
        for(String s:set) {
            System.out.println(s);        //java world hello
        }
        Set<Student> hs = new HashSet<Student>();
        Student s1 = new Student("wangjing", 20);
        Student s2 = new Student("wangjun", 20);
        Student s3 = new Student("wangjing", 20);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        System.out.println(hs);
    }

6.2 HashSet的子类LinkedHashSet

特点：具有可预知的迭代顺序的set接口的哈希表（唯一性）和链表（有序）实现

public static void main(String[] args) {
        LinkedHashSet<String> hs = new LinkedHashSet<String>();
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        System.out.println(hs);    // [hello, world, java]
    }

6.3 TreeSet(继承自AbstractSet)

特点：能够对元素按照某种规则排序

唯一性：根据比较返回是否是0来决定的

排序的两种方法：

A:自然排序

自然排序重要：真正的比较依赖于元素的compareTo()方法，这个方法是定义在Comparable里面的，如果想重写该方法，必须实现Comparable接口

TreeSet的底层是二叉树结构(红黑树：自平衡的二叉树，二叉检索树，对于二叉检索树的任意一个节点，设其值为K，则该节点左子树中的任意一个节点的值都小于K，该节点右子树中的任意一个节点的值都大于等于K，如果按照中序遍历将各个节点打印出来，就会得到从小到大排列的节点。)

compareTo方法写法：

学生类按照年龄排序：

@Override
    public int compareTo(Student o) {
        int num = this.age - o.age;
        int nu = num == 0 ? this.name.compareTo(o.name) : num;
        return nu;
        // 返回0，则不添加，返回数大于0，添加到二叉树右边，返回数小于0，添加到二叉树左边，实现了去重
    }

学生类按照姓名的长度排序

@Override
    public int compareTo(Student o) {
        int num = this.name.length();
        int nu = num == 0 ? this.name.compareTo(o.name) : num;
        int numu = nu == 0 ? this.age - o.age : nu;
        return numu;
        // 返回0，则不添加，返回数大于0，添加到右边，返回数小于0，添加到左边
    }

B:比较器排序

public TreeSet(Comparator<? super E> comparator)

第一种方法：使用外部类，比较麻烦

public class MyComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        int num1 = o1.getName().length() - o2.getName().length();
        int num2 = num1 == 0 ? o1.getName().compareTo(o2.getName()) : num1;
        int num3 = num2 == 0 ? o1.getAge() - o2.getAge() : num2;
        return num3;
    }
    
}


TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());    // 调用

第二种方法：匿名内部类实现(常用)

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                int num1 = o1.getName().length() - o2.getName().length();
                int num2 = num1 == 0 ? o1.getName().compareTo(o2.getName()) : num1;
                int num3 = num2 == 0 ? o1.getAge() - o2.getAge() : num2;
                return num3;
            }
        });

 7. Collections:工具类

collection与collections的区别：

1. collection:是单列集合的顶层接口，有子接口List和Set

2. Collection:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

public static <T> void sort(List<T> list):排序，默认自然排序

public static <T> int binarySearch(List<?> list, T key):二分查找

public static <T> t max(Collection<?> coll):最大值

pullic static void reverse(List<?> list)：反转

public static void shuffle(List<?> list):随机置换

public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(30);
        list.add(29);
        list.add(50);
        list.add(80);
        Collections.sort(list);
        System.out.println("list:" + list);
        System.out.println("binarySearch:" + Collections.binarySearch(list, 300));
        System.out.println("max:" + Collections.max(list));
        Collections.reverse(list);
        System.out.println("list:" + list);
        Collections.shuffle(list);        // 随机置换
        System.out.println("list:" + list);
    }

    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();
        
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("留意", 30);
        Student s4 = new Student("武松", 399);
        Student s5 = new Student("武松", 399);
        
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        
        Collections.sort(list);        // 相同的元素不可以去除
        System.out.println("list:" + list);
        Collections.sort(list, new Comparator<Student>(){

            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge() - o2.getAge();
                int num2 = num==0 ? o1.getName().compareTo(o2.getName()) : num;
                return num2;
            }
            
        });
    }