Java中的集合框架大类可分为Collection和Map；两者的区别：
1、Collection是单列集合；Map是双列集合
2、Collection中只有Set系列要求元素唯一；Map中键需要唯一，值可以重复
3、Collection的数据结构是针对元素的；Map的数据结构是针对键的。
泛型：
在说两大集合体系之前先说说泛型，因为在后面的集合中都会用到；
所谓的泛型就是：类型的参数化
泛型是类型的一部分，类名+泛型是一个整体
如果有泛型，不使用时，参数的类型会自动提升成Object类型，如果再取出来的话就需要向下强转，就可能发生类型转化异常(ClassCaseException)；不加泛型就不能在编译期限定向集合中添加元素的类型，导致后期的处理麻烦。
下面就来对比加了泛型和不加泛型的区别：
package com.xiaoshit_zongjie;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { public static void main(String[] args) { // 不加泛型，添加和遍历
List list = new ArrayList<>();
list.add(1);
list.add("123");
list.add("hello");
Iterator it = list.iterator(); while(it.hasNext()){ // 没有添加泛型，这里只能使用Object接收
Object obj = it.next();
System.out.println(obj);
}
}
}package com.xiaoshit_zongjie;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { public static void main(String[] args) { // 加泛型，添加和遍历
List<String> list = new ArrayList<String>();
list.add("123");
list.add("hello");
Iterator<String> it = list.iterator(); while(it.hasNext()){ // 因为添加了泛型，就说明集合中装的全部都是String类型的数据 // 所以这里用String类型接收，就不会发生异常，并且可以使用String的方法
String str = it.next();
System.out.println(str.length());
}
}
}
自定义带泛型的类:
package com.xiaoshit_zongjie;public class Test { // 自定义一个带有一个参数的泛型类,可以向传入什么类型就传入什么类型
public static void main(String[] args) { // 进行测试, 传入一个String对象
Person<String> perStr = new Person<String>();
perStr.setT("我是字符串");
String str = perStr.getT();
System.out.println(str);
// 进行测试，传入一个Integer对象
Person<Integer> perInt = new Person<Integer>();
perInt.setT(100);
Integer intVal = perInt.getT();
System.out.println(intVal);
}
}//自定义一个带有一个参数的泛型类class Person<T>{ private T t;
void setT(T t){ this.t = t;
}
T getT(){ return t;
}
}
实现带有泛型的接口类型：
实现接口的同时, 指定了接口中的泛型类型. (定义类时确定)；
public class GenericImpl1 implements GenericInter<String> {}
实现接口时, 没有指定接口中的泛型类型.此时, 需要将该接口的实现类定义为泛型类.接口的类型需要在创建实现类对象时才能真正确定其类型. (始终不确定类型, 直到创建对象时确定类型);
public class GenericImpl2<T> implements GenericInter<T> {}
泛型的通配符(?)：
上限限定：比如定义方法的时候出现，public void getFunc(List<? extends Animal> an)，
那么表示这里的参数可以传入Animal，或者 Animal的子类
下限限定: 比如定义方法的时候出现，public void getFunc(Set<? super Animal> an ),
那么表示这里的参数可以传入Animal，或者Animal的父类
使用泛型的注意点:
1、泛型不支持基本数据类型
2、泛型不支持继承，必须保持前后一致（比如这样是错误的：List<Object> list = new ArrayList<String>();
Collection体系：
ollection包括两大体系，List和Set
List的特点：
存取有序，有索引，可以根据索引来进行取值，元素可以重复
Set的特点：
存取无序，元素不可以重复
List:
下面有ArrayList，LinkedList，Vector(已过时)
集合的的最大目的就是为了存取；List集合的特点就是存取有序，可以存储重复的元素，可以用下标进行元素的操作
ArrayList: 底层是使用数组实现，所以查询速度快，增删速度慢
package com.xiaoshit_zongjie;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { // 使用ArrayList进行添加和遍历
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("接口1");
list.add("接口2");
list.add("接口3");
// 第一种遍历方式,使用迭代器
Iterator<String> it = list.iterator(); while(it.hasNext()){
String next = it.next();
System.out.println(next);
}
System.out.println("-------------------"); // 第二种遍历方式，使用foreach
for (String str : list){
System.err.println(str);
}
}
}
LinkedList:是基于链表结构实现的，所以查询速度慢，增删速度快，提供了特殊的方法，对头尾的元素操作（进行增删查）。
使用LinkedList来实现栈和队列；栈是先进后出，而队列是先进先出
package com.xiaoshitou.classtest;import java.util.LinkedList;/**
* 利用LinkedList来模拟栈
* 栈的特点：先进后出
* @author Beck
* */public class MyStack { private LinkedList<String> linkList = new LinkedList<String>();
// 压栈
public void push(String str){
linkList.addFirst(str);
}
// 出栈
public String pop(){ return linkList.removeFirst();
}
// 查看
public String peek(){ return linkList.peek();
}
// 判断是否为空
public boolean isEmpty(){ return linkList.isEmpty();
}
}package com.xiaoshit_zongjie;public class Test { public static void main(String[] args) { // 测试栈
StackTest stack = new StackTest();
stack.push("我是第1个进去的");
stack.push("我是第2个进去的");
stack.push("我是第3个进去的");
stack.push("我是第4个进去的");
stack.push("我是第5个进去的"); // 取出
while (!stack.isEmpty()){
String pop = stack.pop();
System.out.println(pop);
} // 打印结果
/*我是第5个进去的
我是第4个进去的
我是第3个进去的
我是第2个进去的
我是第1个进去的*/
}
}
LinkedList实现Queue:
package com.xiaoshit_zongjie;import java.util.LinkedList;/**
* 利用linkedList来实现队列
* 队列: 先进先出
* @author Beck
* */public class QueueTest { private LinkedList<String> link = new LinkedList<String>();
// 放入
public void put(String str){
link.addFirst(str);
}
// 获取
public String get(){ return link.removeLast();
}
// 判断是否为空
public boolean isEmpty(){ return link.isEmpty();
}
}package com.xiaoshit_zongjie;public class Test { public static void main(String[] args) { // 测试队列
QueueTest queue = new QueueTest();
queue.put("我是第1个进入队列的");
queue.put("我是第2个进入队列的");
queue.put("我是第3个进入队列的");
queue.put("我是第4个进入队列的");
// 遍历队列
while (!queue.isEmpty()){
String str = queue.get();
System.out.println(str);
} // 打印结果
/*我是第1个进入队列的
我是第2个进入队列的
我是第3个进入队列的
我是第4个进入队列的*/
}
}
Vector:因为已经过时，被ArrayList取代了；它还有一种迭代器通过vector.elements()获取，判断是否有元素和取元素的方法为：hasMoreElements()，nextElement()。
package com.xiaoshit_zongjie;import java.util.Enumeration;import java.util.Vector;public class Test { public static void main(String[] args) {
Vector<String> vector = new Vector<String>();
vector.add("搜索");
vector.add("vector");
vector.add("list");
Enumeration<String> elements = vector.elements(); while (elements.hasMoreElements()){
String nextElement = elements.nextElement();
System.out.println(nextElement);
}
}
}
List集合总结：
Set:
Set集合的特点：元素不重复，存取无序，无下标
Set集合下面有：HashSet，LinkedHashSet，TreeSet
HashSet存储字符串:
package com.xiaoshit_zongjie;import java.util.HashSet;import java.util.Iterator;import java.util.Set;public class Test { public static void main(String[] args) { // 利用HashSet来存取
Set<String> set = new HashSet<String>();
set.add("我的天");
set.add("我是重复的");
set.add("我是重复的");
set.add("welcome");
// 遍历 第一种方式 迭代器
Iterator<String> it = set.iterator(); while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
System.out.println("--------------"); for (String str : set){
System.out.println(str);
} // 打印结果，重复的已经去掉了
/*我的天
welcome
我是重复的
--------------
我的天
welcome
我是重复的*/
}
那哈希表是怎么来保证元素的唯一性的呢，哈希表是通过hashCode和equals方法来共同保证的。
哈希表的存储数据过程（哈希表底层也维护了一个数组）：
根据存储的元素计算出hashCode值，然后根据计算得出的hashCode值和数组的长度进行计算出存储的下标；如果下标的位置无元素，那么直接存储；如果有元素，那么使用要存入的元素和该元素进行equals方法，如果结果为真，则已经有相同的元素了，所以直接不存；如果结果假，那么进行存储，以链表的形式存储。
演示HashSet来存储自定义对象：
package com.xiaoshit_zongjie;public class Person { // 属性
private String name; private int age;
// 构造方法
public Person() { super();
} public Person(String name, int age) { super(); this.name = name; this.age = age;
}
// 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法 @Override public int hashCode() { final int prime = 31; int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode()); return result;
}
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false;
Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false;
} else if (!name.equals(other.name)) return false; return true;
}
@Override public String toString() { return "Person [name=" + name + ", age=" + age + "]";
} // getter & setter
public String getName() { return name;
} public void setName(String name) { this.name = name;
} public int getAge() { return age;
} public void setAge(int age) { this.age = age;
}
}package com.xiaoshit_zongjie;import java.util.HashSet;import java.util.Set;public class Test { public static void main(String[] args) { // 利用HashSet来存取自定义对象 Person
Set<Person> set = new HashSet<Person>();
set.add(new Person("张三", 12));
set.add(new Person("李四", 13));
set.add(new Person("王五", 22));
set.add(new Person("张三", 12));
// 遍历
for (Person p : set){
System.out.println(p);
} // 结果：向集合中存储两个张三对象，但是集合中就成功存储了一个
/*Person [name=王五, age=22]
Person [name=李四, age=13]
Person [name=张三, age=12]*/
}
}
所以在向HashSet集合中存储自定义对象时，为了保证set集合的唯一性，那么必须重写hashCode和equals方法。
LinkedHashSet:
是基于链表和哈希表共同实现的，所以具有存取有序，元素唯一
http://www.cnblogs.com/xiaoshitoutest/p/6963798.html
网友评论
更多精彩分享
http://www.cnblogs.com/willian/p/6963886.html
更多精彩分享
- 2018 年最值得关注的 JavaScript 趋势 2018-01-22 09:45:27.09
- web前端工程师----JavaScript语言 2018-01-05 09:43:28.023
- 【Jquery系列】之Jquery 选择器 2017-07-26 16:22:06.82
- CSS3学习系列之动画 2017-07-26 16:07:22.66
- RxSwift 系列(九) -- 那些难以理解的概念 前言 2017-07-26 15:50:59.93
- nopCommerce 3.9 大波浪系列 之 事件机制（生产者、消费者） 2017-07-26 15:49:39.443
- MS MDS系列之初识MS Master Data Service(微软主数据服务) 背景介绍： 2017-07-26 14:32:21.87
- ReactiveSwift源码解析(九) SignalProducerProtocol延展中的Start、Lift系列方法的代码实现 2017-07-26 12:00:35.793
- .Net Core 系列：2、ADO.Net 基础 2017-07-26 11:54:44.893
- Javascript 判断变量类型的陷阱 与 正确的处理方式 2017-07-25 16:35:20.433
web前端工程师----JavaScript语言