一、集合框架特性比较
二、总结
Java中的集合框架大类可分为Collection和Map（两个接口）；两者的区别：
1、Collection是单列集合；Map是双列集合
2、Collection中只有Set系列要求元素唯一；Map中键需要唯一，值可以重复
3、Collection的数据结构是针对元素的；Map的数据结构是针对键的。
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个进去的*/
}
}
Vector:因为已经过时，被ArrayList取代了；它还有一种迭代器通过vector.elements()获取，判断是否有元素和取元素的方法为：hasMoreElements()，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:
是基于链表和哈希表共同实现的，所以具有存取有序，元素唯一
package com.xiaoshit_zongjie;
import java.util.LinkedHashSet;
public class Test {
public static void main(String[] args) {
// 利用LinkedHashSet来存取自定义对象 Person
LinkedHashSet<Person> set = new LinkedHashSet<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=12]
Person [name=李四, age=13]
Person [name=王五, age=22]*/
}
}
未完待续：
参考地址:https://www.cnblogs.com/xiaoshitoutest/p/6963798.html