java应用中的集合

java中的集合有很多种，大多都是为了实现上面的这几种。

Collection

类结构

Collection

Set
    HashSet
    TreeSet

List
    ArrayList
    LinkedList

Map            

常用操作
    1.add(E e) 添加元素
            2. addAll(Collection) 添加另外一个集合
            3. remove(E e) 删除元素 遍历的同时不允许操作remove
            4. size() 获取集合的元素长度
            5. iterator() 获取迭代器
            6. clear() 删除所有元素    

迭代器
        1. hasNext 是否包含下一个元素
        2. next 将指针下移，同时获取数据。一次遍历中千万不要调用多次
        3. remove 集合删除元素，必须使用迭代器的remove  

List

有序可以重复

1. add(index,E e); 在指定位置添加元素 防止越界
2. E e = remove(index); 删除指定位置的元素，同时返回删除的对象
3. get(index) 返回指定的位置的元素
4. set(index,E e) 修改指定位置的元素   

//List的几种应用
List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        // 插入到指定位置
        list.add(0, 4);
        list.add(0, 4);
        list.add(0, 4);
        //list.add(100,5);
        System.out.println(list.toString());
        // List独有的删除
        //int i = list.remove(4);
        //list.remove(list.remove(0));
        System.out.println(list.toString());
        // get方法返回当前的对象
        list.get(1);
        // set方法对当前位置的对象赋值
        list.set(1, 5);

ArrayList

实现了List接口和Collection接口中所有的方法  

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("张三");
        list.add("李四");
        list.add("王八");
        list.add("招六");
//      for (String string : list) {
//          System.out.println(string);
//      }

        // 使用迭代器
        Iterator it = list.iterator();
        // 判断是否还有下一项
        while (it.hasNext()) {
            // 获取元素
            // next在一次遍历中，只允许调用一次
            String str = it.next();
            if(str.equals("王八"))
                it.remove();
//          if (it.next().equals("张三")) {
//              System.out.println(it.next());
//          }
        }
        System.out.println(list.toString());
    }

LinkedList

如果需要做数据结构，那么才使用他
1. addFirst(E e) 添加到头部
2. addLast(E e) 添加到尾部
3. getFirst(E e) 获取第一个
4. getLast(E e) 获取最后一个
5. removeFirst(E e) 删除第一个
6. removeLast(E e) 删除最后一个   

    // 只能给定类名,基础数据类型都需要包装
        LinkedList<String> list = new LinkedList<String>();
        list.addFirst("java");
        list.addFirst("java");
        list.addFirst("java");
        list.addFirst("sql");
        // list.forEach(System.out::println);
        list.removeLast();
        list.removeFirst();
        System.out.println(list);
        System.out.println(list.getFirst());

Set

    无序 不能重复

HashSet

一般用来作为去重复。
1. add(E e);
2. remove(E e);
3. size();
4. iterator();
5. clear();  

去重复的一种操作

Set<String> set = new HashSet<>();
        // 不允许元素重复
        set.add("java");
        set.add("java1");
        set.add("java2");
        set.add("java3");
        set.add("java5");
        set.add("java6");
        set.add("java7");
        System.out.println(set);
        // 转换
         ArrayList<String> list = new ArrayList<String>(set);//把set中的元素全部添加到list中
         list.add("java");
         list.add("java7");
         Set<String> set2 = new HashSet<String>(list);//把list中的元素添加到set2中并去除重复
         System.out.println(set2);

TreeSet

有序，默认自然升序
接口Comparable重写排序方法
返回 负数 0 正数 代表小，一样，大

public static void main(String[] args) {
        // TreeSet set = new TreeSet<>();
        // set.add("java1");
        // set.add("java2");
        // set.add("android");
        // set.add("ios");
        // set.add("c++");
        // set.add("sql");
        // System.out.println(set);
        // 如果需要使用其他类型，那么必须实现comparator接口
        TreeSet users = new TreeSet<>();
        users.add(new User("zhangsan", "123456", 5));
        users.add(new User("lisi", "d5413ba", 10));
        users.add(new User("wangwu", "86asd", 3));
        users.add(new User("zhaoliu", "1234", 9));
        users.add(new User("tianqi", "abasd", 7));
        System.out.println(users);
    }

    static class User implements Comparable<User> {
        // 一个对象的是写在本类中的
        // 两个对象的是写在外面的
        String name;
        String pwd;
        int id;

        public User(String name, String pwd, int id) {
            super();
            this.name = name;
            this.pwd = pwd;
            this.id = id;
        }

        @Override
        public String toString() {
            return "User [name=" + name + ", pwd=" + pwd + "id=" + id + "]";
        }

        @Override
        public int compareTo(User o) {
            // 该类按照name去排序，升序, 倒叙加-
            // 如果按照int值排序
            return -(id - o.id);//倒序
        }
    }
}

Map

请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含
相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被
当作一组key集合，一组value集合，或者一组key-value映射。

HashMap

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null
键。（除了不同步和允许使用 null 之外，HashMap类与Hashtable大致相同。）此类不保证
映射的顺序，特别是它不保证该顺序恒久不变。

public static void main(String[] args) {
        //hashmap 通过键值对 存储数据

        //key-String value-String 
        //key -- 一般都是 string类型的。
        HashMap map = new HashMap<>();
        //哈希函数  需要参数key  -- 决定 key value 放在什么位置

        //添加元素
        map.put("NO1", "tianzhang dashen");
        map.put("NO2", "xuhaogan");
        map.put("NO3", "aibing");
        //将MAP的元素打印出来
        System.out.println(map);

        //修改元素，如果KEY是一样的，哈希函数算出来的位置是一样的
        //保存进去 就把之前的就覆盖了。
        map.put("NO3", "AK");
        //将MAP的元素打印出来
        System.out.println(map);

        //删除元素  --- 几乎不会用到的
        System.out.println(map.remove("NO3", "AK"));
        //将MAP的元素打印出来
        System.out.println(map);
//==========================================================        
        //遍历hashmap。。。迭代器获取到的是键值对 -- entryset
        Iterator> mIterator = map.entrySet().iterator();
        while(mIterator.hasNext()){
            //获取到键值对
            Entry mEntry = mIterator.next();
            //通过键值对 获取到key 跟value
            System.out.println("===="+mEntry.getKey() + " "+ mEntry.getValue());
        }
    }
}