Java 集合枚举泛型（一）

作者: 天一方蓝 | 来源:发表于2018-06-04 10:58 被阅读107次

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

一丶概述

雏鹰飞翔计划三四周（07/04/18）内容：集合枚举泛型

结合Android开发经验先说说印象

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

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

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

（回头看，在边工作边学习的情况下2周搞定集合是不可能的，只能大概了解集合框架，大概数据结构和常见的一些API）

新增源码阅读：https://github.com/JinBoy23520/JavaSource（持续更新）

二丶正文

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）

图标概述

image

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

image

简版

image

入门到放弃版

image

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

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

Tree型功能对比图：

image

集合小案例分享

/**
 * <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);
            }
        }
    }
}

运行结果：

image

上述根据操作显示

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

写在最后

如果文章对你有帮助，欢迎点赞支持

代码下载：https://github.com/JinBoy23520/CoderToDeveloperByTCLer

不懂得地方，微信扫二维码提问

image

Java 集合枚举泛型（一）

一丶概述

二丶正文

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

图标概述

集合小案例分享

三丶面试题（加强理解）：

写在最后

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android开发

Android开发经验谈

Android开发

Java入门基础

2016 TCL雏鹰飞翔计划·Android篇