Java-集合

# 1 集合：
* 1、用于存储对象的容器
* 2、集合的长度是可变的 (数组的大小是固定的)
* 3、集合中不可以存储基本数据类型

Collection中常用的方法
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):

2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。

public static void collection(){

        Collection col1 = new ArrayList();
        Collection col2 = new ArrayList();

        col1.add("1");
        col2.add("2");
        col2.add("3");
        System.out.println(col1);
        col1.addAll(col2);
        System.out.println(col1);

//        col1.remove("1");
//        System.out.println(col1);
//        col1.removeAll(col2);
//        System.out.println(col1);

        boolean contain = col1.contains("5");
        System.out.println(contain);

        boolean containsAll = col1.containsAll(col2);
        System.out.println(containsAll);

        boolean empty = col1.isEmpty();
        System.out.println(empty);

        int size = col1.size();
        System.out.println(size);

        Iterator iterator = col1.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            if (next instanceof String && next.equals("1")) {
                iterator.remove();
            } else {
                System.out.println(next);
            }
        }
    }
    

Collection
|-- List 有序可重复
|-- Set 无序不重复

# 2 、List

List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。 addFirst等方法

/**
     * List ：常见方法
     1，添加
     void add(index,element);
     void add(index,collection);

     2，删除；
     Object remove(index):

     3，修改：
     Object set(index,element);

     4，获取：
     Object get(index);
     int indexOf(object);获取指定元素的索引
     int lastIndexOf(object);
     List subList(from,to);
     *
     */
      
        public static void list(){

        List list = new ArrayList();

        list.add("11");
        list.add("22");
        list.add("33");

        list.add(1,"111");
        System.out.println(list);

        list.remove(1);
        System.out.println(list);

        list.set(1,"222");

        Object o = list.get(1);
        System.out.println(o);


        int i = list.indexOf("33");
        System.out.println(i);

        int i1 = list.lastIndexOf("11");
        System.out.println(i1);

        List list1 = list.subList(0, 1);
        System.out.println(list1);

        // List的遍历方式以及使用，使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常,
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object o1 = listIterator.next();
            if (o1.equals("11")) {
                // 集合和迭代器同时对元素进行修改，就会产生异常，所以这里不能使用list.add(obj)等方法;
                listIterator.add("44");
//                listIterator.set("111212");
//                listIterator.remove();
            }
        }
        System.out.println(list);

    }

# 3、Set

/**
     * Set
     *  Set接口中的方法和Collection一致。
     * |-- HashSet
     * |-- TreeSet 自然排序，如果存放的是自定义对象，使用TreeSet，必须实现Comparable接口，覆盖里面的compareTo方法，添加元素的时候进行比较；如果添加的是字符串
     就不需要覆盖compareTo方法，因为字符串有自己的compareTo方法 , 自定义对象在TreeSet存储时候，如果不覆盖，就会报 java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable异常
     */
    /**
     * HashSet
     * 内部数据结构是哈希表 ，是不同步的。
     *
     如何保证该集合的元素唯一性呢？
     是通过对象的hashCode和equals方法来完成对象唯一性的。
     如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
     如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
     如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
     记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
     一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
     建立对象判断是否相同的依据。

     如果HashSet不覆盖equal和hashCode方法的话，默认的是使用Object中的equal和hashCode方法
     Object中的equal方法比较地址的，而不是比较内容，如果添加重复的对象，地址不同，就会认为没有重复的对象
     所以比较对象是否相同，必须覆盖equal和hashCode方法
     */
    
    
    public static void hashSet(){
        HashSet set = new HashSet();
        set.add(new Person("pp",21));
        set.add(new Person("zz",22));
        set.add(new Person("tt",23));
        set.add(new Person("pp",21));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Person person = (Person)iterator.next();
            System.out.println(person.getName() + "---------" + person.getAge());
        }


    }
    
    
    public class Person {

    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println("调用了equals方法---------------");
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Person)) {
            throw new ClassCastException("类型转化错误");
        }
        Person person = (Person) obj;
        return this.name.equals(person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() { // 判断人的hash值是否相同
        System.out.println("调用了hashCode方法---------------");
        return this.name.hashCode() + age;
    }
  }

# 4、 Map

*
* 可以使用键来查找对象，类似于数组下标。Map.put(key,value)插入数据，Map.get(key)查找数据。键要求唯一。存储方式不是顺序存储，速度快。不必指定Map的尺寸，因为它自己会自动的调整。
*
（1）HashMap使用最快的查找技术，存储无顺序。

（2）TreeMap按照比较结果升序保存。

（3）LinkedHashMap按照插入顺序保存键，同时保留HashMap的查询速度

常用方法：
1，添加。
value put(key,value):返回前一个和key关联的值，如果没有返回null.

2，删除。
void clear():清空map集合。
value remove(key):根据指定的key翻出这个键值对。

3，判断。
boolean containsKey(key):
boolean containsValue(value):
boolean isEmpty();

4，获取。
value get(key):通过键获取值，如果没有该键返回null。
当然可以通过返回null，来判断是否包含指定键。
int size(): 获取键值对的个数。

5.特殊方法： Collection<V> values() 包含的值的 Collection 视图。

 private static void method1(Map<Integer, String> map) {
        map.put(1, "zhang");
        map.put(2, "wang");
        map.put(3, "li");
        System.out.println(map);

        if (!map.isEmpty()) {
            if (map.containsKey(2)) {
                map.remove(2);
            }
        }

        System.out.println(map);
        System.out.println("size : " + map.size());
        System.out.println(map.get(3));

        Collection values = map.values();
        Iterator iterator = values.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

/**
     * 第一种遍历的方法
     * Set<K> keySet()：返回键的set集合
     * 取出map中的所有元素。
     * 原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
             在对每一个键通过map集合的get方法获取其对应的值即可。

     */
    private static void method2(Map<Integer, String> map) {
        map.put(8,"zhaoliu");
        map.put(2,"zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");

        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iterator = keySet.iterator();

        while (iterator.hasNext()) {
            Integer key = iterator.next();
            String value = map.get(key);
            System.out.println(value);
        }
    }

/**
     *
     * Set<Map.Entry<K,V>> entrySet()方法：返回一个set集合，里面装的是Map.Entry接口类型的键值对象
     *
     * 第二种遍历map的方式：通过看API:Set<Map.Entry<K,V>> entrySet()：Map.Entry<K,V>接口类型，
     * 里面有K getKey() 返回与此项对应的键。 V getValue()  返回与此项对应的值。

     * 思路：通过把map转化为set，进行迭代
     * 通过使用entrySet方法吧键和值的映射关系作为对象，存储到set集合中，这个映射关系的类型为Map.Entry类型
     *
     *
     */
    private static void method3(Map<Integer, String> map) {
        map.put(8,"zhaoliu");
        map.put(2,"zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");

        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println("key : " + entry.getKey());
            System.out.println("value : " + entry.getValue());
        }

    }