Java 集合枚举泛型（一）

本文出自：http://blog.csdn.net/dt235201314/article/details/70210256

一丶概述

雏鹰飞翔计划三四周类容：集合 枚举 泛型

结合开发经验先说说印象

集合：常见用途，装数据，装对象。后台json数据常嵌套list，map；

枚举：在时间控件见过，限制参数（year month day）；

泛型：在Android网络框架封装callback<T>接口有用过，接受传递不同的实体类。也是java反射机制的一种体现。

二丶正文

java数据结构（集合枚举相关）

在Java中的数据结构主要包括以下几种接口和类：
枚举（Enumeration）：虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。
例如，枚举定义了一个叫nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。

请参见枚举（Enumeration）
位集合（BitSet）：实现了一组可以单独设置和清除的位或标志。
该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。

请参见位集合（BitSet）
向量（Vector）：和传统数组非常相似，但是Vector的大小能根据需要动态的变化。
和数组一样，Vector对象的元素也能通过索引访问。
使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。
请参见向量(Vector)
栈（Stack）：实现了一个后进先出（LIFO）的数据结构。
你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。
当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

请参见栈（Stack）

字典（Dictionary）：是一个抽象类，它定义了键映射到值的数据结构。
当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。
由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

请参见字典（ Dictionary）
哈希表（Hashtable）：提供了一种在用户定义键结构的基础上来组织数据的手段。
例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。
哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

请参见哈希表（HashTable）
属性（Properties）：继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

请参见属性（Properties）

框架-集合框架(Collection)：java2中引入

集合框架(Collection)

集合框架体系如图所示（入门版）

简版

入门到放弃版

1.集合框架的出现为提供了预先包装的数据结构和算法，更方便使用

2.接口及相关类容参考菜鸟教程：Java 集合框架http://www.runoob.com/java/java-collections.html

Tree型功能对比图：

4.集合小案例分享

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/16 *     desc   :实现雇员管理添加·删除·修改功能 *     version: 1.0 * </pre> */public class ArrayListDemo {    public static void main(String[] args) throws Exception {        // TODO Auto-generated method stub        //创建一个EmpManage对象        EmpManage em = new EmpManage();        //做出一个简单的菜单        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));        while (true) {            System.out.println("请选择一个操作:");            System.out.println("1:表示添加一个雇员");            System.out.println("2：雇员查找一个:");            System.out.println("3:修改一个雇员");            System.out.println("4：删除一个雇员");            System.out.println("5：退出");            String operType = br.readLine();            if (operType.equals("1")) {                System.out.println("请输入编号");                String empNo = br.readLine();                System.out.println("请输入名字");                String name = br.readLine();                System.out.println("请输入工资");                float sal = Float.parseFloat(br.readLine());                Emp emp = new Emp(empNo, name, sal);                em.addEmp(emp);            } else if (operType.equals("2")) {                System.out.println("请输入编号");                String empNo = br.readLine();                em.showInfo(empNo);            } else if (operType.equals("3")) {                System.out.println("请输入编号");                String empNo = br.readLine();                System.out.println("请输入修改后工资");                float sal = Float.parseFloat(br.readLine());                em.updateSal(empNo, sal);            } else if (operType.equals("4")) {                System.out.println("请输入编号");                String empNo = br.readLine();                em.delEmp(empNo);            } else if (operType.equals("5")) {                //退出                System.exit(0);            }        }    }}

Emp.Java

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/16 *     desc   :雇员类 *     version: 1.0 * </pre> */public class Emp {    //学号    private String empNo;    private String name;    private float sal;    //构造函数    public Emp(String empNo, String name, float sal) {        this.empNo = empNo;        this.name = name;        this.sal = sal;    }    public String getEmpNo() {        return empNo;    }    public void setEmpNo(String empNo) {        this.empNo = empNo;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public float getSal() {        return sal;    }    public void setSal(float sal) {        this.sal = sal;    }}

EmpManage.Java

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/16 *     desc   :雇员管理员类 *     version: 1.0 * </pre> */public class EmpManage {    private ArrayList al = null;    public EmpManage() {        al = new ArrayList();    }    //加入员工    public void addEmp(Emp emp) {        al.add(emp);    }    //显示员工的相关信息    public void showInfo(String empNo) {        //遍历整个ArrayList()        for (int i = 0; i < al.size(); i++) {            //去除Emp对象            Emp emp = (Emp) al.get(i);            //比较编号            if (emp.getEmpNo().equals(empNo)) {                System.out.println("找到员工，他的信息是：");                System.out.println("编号是" + empNo);                System.out.println("名字是" + emp.getName());                System.out.println("工资是" + emp.getSal());            } else {                System.out.println("没有该员工");            }        }    }    //修改工资    public void updateSal(String empNo, float newSal) {        for (int i = 0; i < al.size(); i++) {            Emp emp = (Emp) al.get(i);            if (emp.getEmpNo().equals(empNo)) {                emp.setSal(newSal);            }        }    }    public void delEmp(String empNo) {        for (int i = 0; i < al.size(); i++) {            Emp emp = (Emp) al.get(i);            if (emp.getEmpNo().equals(empNo)) {                al.remove(i);            }        }    }}

运行结果：

上述根据操作显示

LinkedLisDemo.Java

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/18 *     desc   : LinkedList演示 *     总结 ： *     1.LinkedList方法上比ArrayList多了对头部尾部的索引添加删除方法（LinkedList基于链表的数据结构） *     2.Java中ArrayList和LinkedList区别:http://pengcqu.iteye.com/blog/502676 *     3.空间复杂度：ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间， *     而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间 *     4.时间复杂度：LinkedList不支持高效的随机元素访问 *     version: 1.0 * </pre> */public class LinkedListDemo {    private static void pringLinkedList(LinkedList<String> linkedList){        System.out.println("当前元素的集合：");        for(int i=0;i<linkedList.size();i++){            System.out.print(linkedList.get(i)+" ");        }        System.out.println();    }    public static void main(String[] args) {        LinkedList<String> linkedList=new LinkedList<String>();//        linkedList.addFirst("张三");        linkedList.add("张三");        linkedList.add("李四");        linkedList.add("王五");        linkedList.add("李四");        linkedList.add("赵六");        pringLinkedList(linkedList);        // indexOf 寻找位置        System.out.println(linkedList.indexOf("李四"));        pringLinkedList(linkedList);        // peekFirst 获取第一个元素        System.out.println(linkedList.peekFirst());        pringLinkedList(linkedList);        // peekLast 获取最后一个元素        System.out.println(linkedList.peekLast());        pringLinkedList(linkedList);        // pollFirst 摘取第一个元素        System.out.println(linkedList.pollFirst());        pringLinkedList(linkedList);        // pollLast 榨取最后一个元素        System.out.println(linkedList.pollLast());        pringLinkedList(linkedList);    }}/**运行结果当前元素的集合：        张三 李四 王五 李四 赵六        1        当前元素的集合：        张三 李四 王五 李四 赵六        张三        当前元素的集合：        张三 李四 王五 李四 赵六        赵六        当前元素的集合：        张三 李四 王五 李四 赵六        张三        当前元素的集合：        李四 王五 李四 赵六        赵六        当前元素的集合：        李四 王五 李四 */

Java中ArrayList和LinkedList区别（时间空间复杂度分析）:http://pengcqu.iteye.com/blog/502676

MapDemo.Java

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/16 *     desc   : map演示 *     总结   ： *     1.HashMap 是一个散列表，是存放一对值的最大接口，即接口中的每一个元素都是一对，以key->value键值对的形式保存 *     2.四种遍历 *     3.TreeMap 延伸阅读 http://blog.csdn.net/chenssy/article/details/26668941 *     version: 1.0 * </pre> */public class MapDemo {    public static void main(String[] args) {      // TODO Auto-generated method stub       //LinkList//    LinkedList ll=new LinkedList();//    Emp emp1=new Emp("sa01","aa", 1.2f);//    Emp emp2=new Emp("sa01","bb", 1.2f);//    //表示把emp1加在链表的最前面//    ll.addLast(emp1);//    ll.addFirst(emp2);//    for(int i=0; i<ll.size(); i++)//    {//       System.out.println(((Emp)ll.get(i)).getName());//    }        // Vector的用法//    Vector vv=new Vector();//    Emp emp1=new Emp("sa01","aa", 1.2f);//    vv.add(emp1);//    for(int i=0; i<vv.size(); i++)//    {//       Emp emp=(Emp)vv.get(i);//    }        // Stack stack=new Stack();        // stack.      //创建一个HashMap 对象      HashMap hm=new HashMap();      Emp emp1=new Emp("s001","aaa", 3.5f);      Emp emp2=new Emp("s002","老桑", 3.5f);      Emp emp3=new Emp("s003","老王", 3.5f);      //将emp放到hm中      hm.put("s001", emp1);      hm.put("s002", emp2);      hm.put("s003", emp3);   // 注意键值不能重复 这时候s002表示老王了          if(hm.containsKey("s002"))      {         System.out.println("有该员工");         //如何去除键值         Emp emp=(Emp)hm.get("s002");         System.out.println("名字："+emp.getName());      }      else      {         System.out.println("没有该员工");      }      //遍历HashMap中所有的key和value   去除的值没有顺序 Iterator迭代器用于遍历      Iterator it=hm.keySet().iterator();      // hasNext返回一个boolean      while(it.hasNext())      {         String key=it.next().toString();         //通过key去除vale         Emp emp=(Emp)hm.get(key);         System.out.println("名字"+emp.getName());         System.out.println("薪水："+emp.getSal());      }      Map<String, String> map = new HashMap<String, String>();      map.put("1", "value1");      map.put("2", "value2");      map.put("3", "value3");      System.out.println("通过Map.keySet遍历key和value：");      for (String key : map.keySet()) {         System.out.println("key= "+ key + " and value= " + map.get(key));      }      //第二种      System.out.println("通过Map.entrySet使用iterator遍历key和value：");      Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();      while (it.hasNext()) {         Map.Entry<String, String> entry = iterator.next();         System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());      }      //第三种：推荐，尤其是容量大时      System.out.println("通过Map.entrySet遍历key和value");      for (Map.Entry<String, String> entry : map.entrySet()) {         System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());      }      //第四种      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");      for (String v : map.values()) {         System.out.println("value= " + v);      }   }        //演示HashTable//        Hashtable ht=new Hashtable();    }    /**    运行结果    有该员工    名字：老桑    名字老王    薪水：3.5    名字老桑    薪水：3.5    名字aaa    薪水：3.5    通过Map.keySet遍历key和value：    key= 1 and value= value1    key= 2 and value= value2    key= 3 and value= value3    通过Map.entrySet使用iterator遍历key和value：    通过Map.entrySet遍历key和value    key= 1 and value= value1    key= 2 and value= value2    key= 3 and value= value3    通过Map.values()遍历所有的value，但不能遍历key    value= value1    value= value2    value= value3**/

SetDemo.Java

/** * <pre> *     author : JinBiao *     CSDN : http://my.csdn.net/DT235201314 *     time   : 2017/04/18 *     desc   :Set演示  运用较少 *     version: 1.0 * </pre> */public class SetDemo {    public static void main(String[] args) {        /**         * 1，HashSet是无序         * 2，不循序有重复的值         */        HashSet<String> hs=new HashSet<String>();        hs.add("21221");//        hs.add("21221");        hs.add("112");        hs.add("312");        hs.add("421");        hs.add("312");        /**         * 用迭代器Iterator遍历集合         */        Iterator<String> it=hs.iterator();        while(it.hasNext()){            String s=it.next();            System.out.println(s +" ");        }    }}    /**     运行结果：     112     421     312     21221 **/

面试题（加强理解）：

40个常见java集合面试题：http://www.importnew.com/15980.html

Java中的集合类解析和一些有深入的面试题：http://blog.csdn.net/he90227/article/details/38061087

例：ArrayList、LinkedList、Vector以及Stack的区别:

1. ArrayList:
ArrayList实现了可变大小的数组，它容许所有的元素，包含null。  ArrayList没有实现同步。
size, isEmpty, get, set方法运行时间为常数o(1)， 而add方法时间开销为o(n).
每个ArrayList都有一个容量，即用于存储元素的数组的大小。
当须要插入多量元素时，在插入前可以调用ensureCapacity办法来增长ArrayList的容量以进步插入效力。
2. LinkedList
LinkedList实现了List接口，容许null元素。此外LinkedList供给额外的get，remove方法操纵LinkedList的首部或尾部。
这些操纵使得LinkedList可被用作栈（stack）、队列（queue）或双向队列（deque）；
!!!LinkedList没有实现同步， 若是多个线程同时操作一个list，则list本身必须实现同步，一种办法是在创建list时实现一个同步的list：
List list = Collections.synchronizedList(new LinkedList(...));
3. Vector
Vector类似ArrayList，而Vector实现了同步。由Vector创建的Iterator和ArrayList创建的是同一接口，
因为Vectory是同步的，当一个Iterator被创建并且被应用，另一个线程改变Vector的状况时，会抛出ConcurrentModificationException异常，
所以必须捕获该异常。
4. Stack（栈）
Stack继承自Vector，实现一个先进后出的栈。 Stack提供五个额外的方法，使得Vector可以被当做栈应用，入栈和出栈的push和pop方法，
还有peek方法获得栈顶元素，empty方法判断栈是否为空，search方法检测一个元素在栈中的位置。
Stack刚创建后是空栈。


查询：ArrayList快（底层数据结构是数组）
增删：LinkedList快（底层数据结构式链表）
遍历：LinkedList快（底层是链表，每个节点是一个对象，对象与对象间用引用连接，遍历时只需next = next.next实现引用的向后移动。
而Java里ArrayList存的是对象数组，遍历时要使引用向后移动，就不是简单把引用的值加一就能实现了，可能要算出下一个对象的引用然后再赋给当前引用。
所以集合的遍历还是LinkedList快。如果是遍历基本类型的数组，应该是数组快）

总结：1.集合框架体现Java将不同数据结构整合在一起提取一些方法特性，不同数据结构用于不同的场景。

    2.针对不同功能需求选取不同集合