集合框架

迭代器(Iterable)

实现Iterable接口的类都可以用for-each来遍历。

Iterator iterator = list.iterator();// 迭代器

---

ArrayList底层用数组储存，遍历元素和随机访问元素效率高，添加元素删除元素效率低。
例：

import java.util.ArrayList;
import java.util.List;

import javax.swing.SpringLayout.Constraints;

public class TestModify {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        print(list);
        System.out.println("=============");

        /**
         * 替换指定位置的元素
         */
        // list.set(1, "2");
        // print(list);

        /**
         * 删除所有元素
         */
        // list.clear();
        // print(list);

        /**
         * 查找集合中是否存在指定元素
         */
        boolean contains = list.contains("aaa");
        System.out.println(contains);

    }

    private static void print(List list) {
        // TODO Auto-generated method stub
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }
        if (list.size() == 0) {
            System.out.println("meile");
        }

    }

}

---

删除元素，例：

import java.util.ArrayList;
import java.util.List;

import javax.swing.SpringLayout.Constraints;

public class TestModify {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        print(list);
        System.out.println("=============");

        /**
         * 替换指定位置的元素
         */
        // list.set(1, "2");
        // print(list);

        /**
         * 删除所有元素
         */
        // list.clear();
        // print(list);

        /**
         * 查找集合中是否存在指定元素
         */
        boolean contains = list.contains("aaa");
        System.out.println(contains);

    }

    private static void print(List list) {
        // TODO Auto-generated method stub
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));

        }
        if (list.size() == 0) {
            System.out.println("meile");
        }

    }

}

---

LinkedList底层用链表储存，插入和删除元素效率高，遍历和随机访问效率低。
例：

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class TestLinked {
    public static void main(String[] args) {
        List list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        print(list);
        System.out.println("================");

        List temp = new LinkedList<>();
        temp.add("ddd");
        temp.add("aaa");
        print(temp);
        System.out.println("================");
        /**
         * 删除两个集合相同的地方
         */
        list.removeAll(temp);
        print(list);

    }

    /**
     * 加强for遍历
     */
    private static void print(List list) {
        // TODO Auto-generated method stub
        for (Object o : list) {
            System.out.println(o);
        }

    }

}

List添加顺序和访问顺序是一致的，能添加重复元素。

---

HashSet底层用数组+链表，添加速度快，删除速度快，查询速度快，无序。
例：

import java.util.HashSet;
import java.util.Set;

public class TestHash {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("aaa");
        /**
         * 添加是否成功
         */
        // boolean is = set.add("aaa");
        // System.out.println(is);
        set.add("bbb");
        set.add("ccc");
        print(set);
        /**
         * 查看集合中是否存在元素
         */
        boolean contains = set.contains("ccc");
        System.out.println(contains);
    }

    private static void print(Set set) {
        // TODO Auto-generated method stub
        for (Object o : set) {
            System.out.println(o);
        }
    }

}

---

重写Hashcode方法和equals方法
去重
例：

public class Student {
    private String name;
    public Student(String name) {
        this.name=name;
    }
    @Override
    public String toString() {
        return "姓名:"+name;
    }
    @Override
    public int hashCode() {
        // 相同的字符串肯定具有相同的hashcode
        return name.hashCode();
    }
    @Override
    public boolean equals(Object obj) {

        return true;
    }


}

import java.util.HashSet;
import java.util.Set;

public class TestStudent {
    public static void main(String[] args) {
        Set set = new HashSet<>();
        set.add(new Student("张三"));
        set.add(new Student("李四"));
        set.add(new Student("王五"));
        set.add(new Student("李四"));
        set.add(new Student("李四"));
        set.add(new Student("李四"));
        print(set);
    }

    private static void print(Set set) {
        // TODO Auto-generated method stub
        for(Object o:set){
            System.out.println(o);
        }

    }

}

---

TreeSet 底层采用二叉树粗存结构，有序，查询比List快，没有HashSet快；需要实现Comparable。

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private boolean sex;

    public Student(String name, int age, boolean sex) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isSex() {
        return sex;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名" + name + "年龄" + age + "性别" + sex;
    }

    @Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        return 0;
    }

}

TreeSet使用CompareTo去重，还能排序。
本例中写的排序方式是：按年龄排序、年龄相同按姓名排、姓名相同按性别排。

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class Tree {
    public static void main(String[] args) {
        Set set = new TreeSet<>(new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                int c = o1.getAge() - o2.getAge();
                if (c != 0) {
                    return c;
                }
                c = o1.getName().compareTo(o2.getName());
                if (c != 0) {
                    return c;
                }
                return new Boolean(o1.isSex()).compareTo(o2.isSex());
            }
        });
        set.add(new Student("张三", 10, true));
        set.add(new Student("李四", 10, false));
        set.add(new Student("张三", 11, true));
        set.add(new Student("张三", 10, false));
        set.add(new Student("李四", 10, false));
        print(set);
    }

    private static void print(Set set) {
        // TODO Auto-generated method stub
        for (Object o : set) {
            System.out.println(o);
        }

    }

}

---

MAP（映射）

返回一对键值对，通过键获得值，键不允许重复，重复就覆盖，但是值允许重复
HashMap允许使用null键null值
TreeMap Key必须实现Comparable
例：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap {
    public static void main(String[] args) { 
        Map map = new HashMap<>();
        map.put("a", "abc");
        map.put("b", "bcd");
        map.put("c", "cde");
        print(map);
    }

    private static void print(Map map) {
        // TODO Auto-generated method stub
        Set keySet = map.keySet();
        for(Object key:keySet){
            System.out.println(key+"--->"+map.get(key));
        }
    }

}

public class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名"+name+"，年龄"+age;
    }

}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("f", "fgh");
        map.put("a", "abc");
        map.put("v", "vbn");
        map.put("b", "bcd");
        map.put("z", "zxc");
        map.put("c", "cde");
        print(map);
    }

    private static void print(Map map) {
        // TODO Auto-generated method stub
        Set keySet = map.keySet();
        for (Object key : keySet) {
            System.out.println(key + "--->" + map.get(key));
        }
    }

}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap1 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put(new Student("张三", 1), new Student("张三", 10));
        map.put(new Student("李四", 1), new Student("李四", 9));
        map.put(new Student("王五", 1), new Student("zhangsan", 2));
        print(map);
    }

    private static void print(Map map) {
        // TODO Auto-generated method stub
        Set keySet = map.keySet();
        for(Object key:keySet){
            System.out.println(key+"==="+map.get(key));
        }
    }
}

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TestTreeMap {
    public static void main(String[] args) {
        Map map = new TreeMap<>();
        map.put(new Student("张三", 1), new Student("张三", 10));
        map.put(new Student("李四", 1), new Student("李四", 9));
        map.put(new Student("王五", 1), new Student("zhangsan", 2));
        print(map);
    }

    private static void print(Map map) {
        // TODO Auto-generated method stub
        Set keySet = map.keySet();
        for (Object key : keySet) {
            System.out.println(key + "====" + map.get(key));
        }

    }

}

---

泛型

解决数据类型操作不同意产生的异常。

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名"+name+"年龄"+age;
    }

}

import java.util.ArrayList;
import java.util.List;

public class TestGenray {
    public static void main(String[] args) {
        List<String> list= new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        print(list);
        List<Student> list1 = new ArrayList<>();
        list1.add(new Student("张三", 10));
        list1.add(new Student("李四", 20));
        print1(list1);


    }

    private static void print1(List<Student> list1) {
        // TODO Auto-generated method stub
        for(Student s:list1){
            System.out.println(s);
        }

    }

    private static void print(List<String> list) {
        // TODO Auto-generated method stub
        for(String s:list){
            System.out.println(s);
        }
    }

}

---