Java 集合枚举泛型（一）
2018-06-04 本文已影响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 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。
位集合（BitSet）：实现了一组可以单独设置和清除的位或标志。
该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。
向量（Vector）：和传统数组非常相似，但是Vector的大小能根据需要动态的变化。
和数组一样，Vector对象的元素也能通过索引访问。
使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。
栈（Stack）：实现了一个后进先出（LIFO）的数据结构。
你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。
当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。
字典（Dictionary）：是一个抽象类，它定义了键映射到值的数据结构。
当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。
由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。
哈希表（Hashtable）：提供了一种在用户定义键结构的基础上来组织数据的手段。
例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。
哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。
属性（Properties）：继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。
图标概述
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
不懂得地方，微信扫二维码提问
