java应用中的集合

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

Collection

类结构

Collection

Set
    HashSet
    TreeSet

List
    ArrayList
    LinkedList

Map            

常用操作
    1.add(E e) 添加元素
            2. addAll(Collection<? extends E>) 添加另外一个集合
            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<String> list = new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("王八");
        list.add("招六");
//      for (String string : list) {
//          System.out.println(string);
//      }

        // 使用迭代器
        Iterator<String> 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<String> 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<User> 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<String, String> 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<Entry<String, String>> mIterator = map.entrySet().iterator();
        while(mIterator.hasNext()){
            //获取到键值对
            Entry<String, String> mEntry = mIterator.next();
            //通过键值对 获取到key 跟value
            System.out.println("===="+mEntry.getKey() + " "+ mEntry.getValue());
        }
    }
}