java集合详解（入门篇）
文章目录
- 简介
- Collection
-
- List
-
- ArrayList
- LinkedList
- Vector
- Set
-
- HashSet
- LinkedHashSet
- TreeSet
- Map
-
- HashMap
- LinkedHashMap
- TreeMap
简介
Java中的集合框架大类可分为Collection和Map；两者的区别如下：
-
Collection是单列集合；Map是双列集合
-
Collection中只有Set系列要求元素唯一；Map中键需要唯一，值可以重复
-
Collection的数据结构是针对元素的；Map的数据结构是针对键的
Collection
collection包括两大体系，
List和Set
List的特点：
-
List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引。
-
List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。
-
List 默认按元素的添加顺序设置元素的索引。
-
List 集合里添加了一些根据索引来操作集合元素的方法
Set的特点：存取无序，元素不可以重复
List
下面有ArrayList，LinkedList，Vector(已过时)
集合的的最大目的就是为了存取；List集合的特点就是存取有序，可以存储重复的元素，可以用下标进行元素的操作。
ArrayList
底层是使用数组实现，所以查询速度快，增删速度慢
public static void main(String[] args) {
// 使用ArrayList进行添加和遍历
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
// 第一种遍历方式,使用迭代器
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.out.println(str);
}
}
LinkedList
是基于链表结构实现的，所以查询速度慢，增删速度快，提供了特殊的方法，对头尾的元素操作（进行增删查）。
使用LinkedList来实现栈和队列；栈是先进后出，而队列是先进先出
package org.example.test;
import java.util.LinkedList;
/**
* 利用LinkedList来模拟栈
* 栈的特点：先进后出
*/
public class Test12 {
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();
}
}
class Test13 {
public static void main(String[] args) {
// 测试栈
Test12 test12 = new Test12();
test12.push("我是第1个进去的");
test12.push("我是第2个进去的");
test12.push("我是第3个进去的");
test12.push("我是第4个进去的");
test12.push("我是第5个进去的");
// 取出
while (!test12.isEmpty()){
String pop = test12.pop();
System.out.println(pop);
}
// 打印结果
/*我是第5个进去的
我是第4个进去的
我是第3个进去的
我是第2个进去的
我是第1个进去的*/
}
}
LinkedList实现Queue:
package org.example.test;
import java.util.LinkedList;
/**
* 利用linkedList来实现队列
* 队列: 先进先出
*/
public class Test12 {
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();
}
}
class Test13 {
public static void main(String[] args) {
// 测试队列
Test12 queue = new Test12();
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()。
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("a");
vector.add("v");
vector.add("d");
Enumeration<String> elements = vector.elements();
while (elements.hasMoreElements())
{
String nextElement = elements.nextElement();
System.out.println(nextElement);
}
}
还有一些基本操作：
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("b");//第一个，索引下标0
list.add("d");//索引下标1
list.add("c");//索引下标2
list.add("a");//索引下标3
list.add("d");//允许使用重复元素
System.out.println(list);//结果：[b, d, c, a, d]
System.out.println(list.get(2));//通过索引来访问指定位置的集合元素.结果：c
list.add(1,"f");//在指定索引下标的位置插入数据
System.out.println(list);//结果：[b, f, d, c, a, d]
List<String> m = new ArrayList<String>();
m.add("123");
m.add("456");
list.addAll(2, m);//在指定索引下标的位置插入集合
System.out.println(list);//结果：[b, f, 123, 456, d, c, a, d]
System.out.println(list.indexOf("d"));//获取指定元素在集合中第一次出现的索引下标.结果：4
System.out.println(list.lastIndexOf("d"));//获取指定元素在集合中最后一次出现的索引下标.结果：7
list.remove(2);//根据指定的索引下标移除元素
System.out.println(list);//结果：[b, f, 456, d, c, a, d]
list.set(1, "ff");//根据指定的索引下标修改元素
System.out.println(list);//结果：[b, ff, 456, d, c, a, d]
//根据索引下标的起始位置截取一段元素形参一个新的集合，截取的时候，包含开始的索引不包含结束时的索引
List<String> sublist = list.subList(2, 4);//取索引下标在大于等于2,小于4的元素
System.out.println(sublist);//结果：[456, d]
System.out.println(list.size());//集合的长度.结果：7
}
Set
Set集合下面有：HashSet，LinkedHashSet，TreeSet
Set集合的特点：元素不重复，存取无序，无下标
HashSet
public static void main(String[] args) {
// 利用HashSet来存取
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("b");
set.add("c");
// 遍历 第一种方式 迭代器
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);
}
// 打印结果，重复的已经去掉了
/* a
b
c
--------------
a
b
c*/
}
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。HashSet 具有以下特点：
- 不能保证元素的排列顺序
- 不可重复（hashcode不相同）
- HashSet 不是线程安全的
- 集合元素可以使 null
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置，存在set集合哪个位置由这个值的hashcode决定，而不是按先来后到。如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
演示HashSet来存储自定义对象：
package org.example.test;
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;
}
}
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
是基于链表和哈希表共同实现的，所以具有存取有序，元素唯一
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]*/
}
TreeSet
-
TreeSet 是 SortedSet 接口的实现类
-
TreeSet 特点：存取无序，元素唯一，可以进行排序（排序是在添加的时候进行排序）
-
TreeSet 支持两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序
TreeSet集合存储String对象
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<String>();
treeSet.add("a");
treeSet.add("c");
treeSet.add("d");
treeSet.add("b");
for (String str : treeSet){
System.out.println(str);
}
// 结果：取出来的结果是经过排序的
/*
a
b
c
d*/
}
TreeSet保证元素的唯一性是有两种方式：
1、自定义对象实现Comparable接口，重写comparaTo方法，该方法返回0表示相等，小于0表示准备存入的元素比被比较的元素小，否则大于0；
2、在创建TreeSet的时候向构造器中传入比较器Comparator接口实现类对象，实现Comparator接口重写compara方法。
如果向TreeSet存入自定义对象时，自定义类没有实现Comparable接口，或者没有传入Comparator比较器时，会出现ClassCastException异常。
下面就是演示用两种方式来存储自定义对象
package org.example.test;
import java.util.TreeSet;
public class Person implements Comparable<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;
}
@Override
public int compareTo(Person o) {
int result = this.age - o.age;
if (result == 0) {
return this.name.compareTo(o.name);
}
return result;
}
public static void main(String[] args) {
// 利用TreeSet来存储自定义类Person对象
TreeSet<Person> treeSet = new TreeSet<Person>();
// Person类实现了Comparable接口，并且重写comparaTo方法
// 比较规则是先按照 年龄排序，年龄相等的情况按照姓名排序
treeSet.add(new Person("张山1", 20));
treeSet.add(new Person("张山2", 16));
treeSet.add(new Person("张山3", 13));
treeSet.add(new Person("张山4", 17));
treeSet.add(new Person("张山5", 20));
for (Person p : treeSet) {
System.out.println(p);
}
// 结果：按照comparaTo方法内的逻辑来排序的
/*
Person [name=张山3, age=13]
Person [name=张山2, age=16]
Person [name=张山4, age=17]
Person [name=张山1, age=20]
Person [name=张山5, age=20]
*/
}
}
另一种方式：使用比较器Comparator
package org.example.test;
import java.util.Comparator;
import java.util.TreeSet;
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;
}
public static void main(String[] args) {
// 利用TreeSet来存储自定义类Person对象
// 创建TreeSet对象的时候传入Comparator比较器，使用匿名内部类的方式
// 比较规则是先按照 年龄排序，年龄相等的情况按照姓名排序
TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
if (o1 == o2){
return 0;
}
int result = o1.getAge() - o2.getAge();
if (result == 0){
return o1.getName().compareTo(o2.getName());
}
return result;
}
});
treeSet.add(new Person("张山1", 20));
treeSet.add(new Person("张山2", 16));
treeSet.add(new Person("张山3", 13));
treeSet.add(new Person("张山4", 17));
treeSet.add(new Person("张山5", 20));
for (Person p : treeSet){
System.out.println(p);
}
// 结果：按照compara方法内的逻辑来排序的
/*
Person [name=张山3, age=13]
Person [name=张山2, age=16]
Person [name=张山4, age=17]
Person [name=张山1, age=20]
Person [name=张山5, age=20]
*/
}
}
Map
map集合下面有
HashMap，LinkedHashMap和TreeMap
-
Map 用于保存两组具有映射关系的数据，一组值用于保存 Map 里的 Key，另外一组用于保存 Map 里的 Value
-
Map 中的 key 和 value 都可以是任何引用类型的数据
-
Map 中的 Key 不允许重复，即同一个 Map 对象的任何两个 Key 通过 equals 方法比较中返回 false
-
Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value。
HashMap
是基于哈希表结构实现的，所以存储自定义对象作为键时，必须重写hasCode和equals方法，存取无序的。
下面演示HashMap以自定义对象作为键：
public static void main(String[] args) {
// 利用HashMap存储，自定义对象Person作为键
// 为了保证键的唯一性，必须重写hashCode和equals方法
HashMap<Person,String> map = new HashMap<Person,String>();
map.put(new Person("张三", 12), "JAVA");
map.put(new Person("李四", 13), "IOS");
map.put(new Person("小花", 22), "JS");
map.put(new Person("小黑", 32), "PHP");
map.put(new Person("张三", 12), "C++");
Set<Entry<Person, String>> entrySet = map.entrySet();
Iterator<Entry<Person, String>> it = entrySet.iterator();
while (it.hasNext()){
Entry<Person, String> entry = it.next();
System.out.println(entry.getKey() + "---" + entry.getValue());
}
// 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
/*
Person [name=李四, age=13]---IOS
Person [name=张三, age=12]---C++
Person [name=小黑, age=32]---PHP
Person [name=小花, age=22]---JS
*/
}
LinkedHashMap
用法跟HashMap基本一致，它是基于链表和哈希表结构的所以具有存取有序，键不重复的特性。
下面演示利用LinkedHashMap存储，注意存的顺序和遍历出来的顺序是一致的:
public static void main(String[] args) {
// 利用LinkedHashMap存储，自定义对象Person作为键
// 为了保证键的唯一性，必须重写hashCode和equals方法
LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>();
map.put(new Person("张三", 12), "JAVA");
map.put(new Person("李四", 13), "IOS");
map.put(new Person("小花", 22), "JS");
map.put(new Person("小黑", 32), "PHP");
map.put(new Person("张三", 12), "C++");
// foreach遍历
for (Entry<Person,String> entry : map.entrySet()){
System.out.println(entry.getKey()+"==="+entry.getValue());
}
// 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
// 注意：LinkedHashMap的特点就是存取有序，取出来的顺序就是和存入的顺序保持一致
/*
Person [name=张三, age=12]===C++
Person [name=李四, age=13]===IOS
Person [name=小花, age=22]===JS
Person [name=小黑, age=32]===PHP
*/
}
TreeMap
给TreeMap集合中保存自定义对象，自定义对象作为TreeMap集合的key值。由于TreeMap底层使用的二叉树，其中存放进去的所有数据都需要排序，要排序，就要求对象具备比较功能。对象所属的类需要实现Comparable接口。或者给TreeMap集合传递一个Comparator接口对象。
利用TreeMap存入自定义对象作为键：
public static void main(String[] args) {
// 利用TreeMap存储，自定义对象Person作为键
// 自定义对象实现Comparable接口或者传入Comparator比较器
TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
if (o1 == o2){
return 0;
}
int result = o1.getAge() - o2.getAge();
if (result == 0){
return o1.getName().compareTo(o2.getName());
}
return result;
}
});
map.put(new Person("张三", 12), "JAVA");
map.put(new Person("李四", 50), "IOS");
map.put(new Person("小花", 32), "JS");
map.put(new Person("小黑", 32), "PHP");
map.put(new Person("张三", 12), "C++");
// foreach遍历
for (Entry<Person,String> entry : map.entrySet()){
System.out.println(entry.getKey()+"==="+entry.getValue());
}
// 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
// 注意：TreeMap 取出来的顺序是经过排序的，是根据compara方法排序的
/*
Person [name=张三, age=12]===C++
Person [name=小花, age=32]===JS
Person [name=小黑, age=32]===PHP
Person [name=李四, age=50]===IOS
*/
}