作为一个Developer，Java集合类是我们在工作中运用最多的、最频繁的类。相比于数组(Array)来说，集合类的长度可变，更加适合于现代开发需求；
Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象。在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java.util包中。
Java集合主要由2大体系构成，分别是Collection体系和Map体系，其中Collection和Map分别是2大体系中的顶层接口。
今天主要讲：Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复；
List中主要有ArrayList、LinkedList两个实现类；Set中则是有HashSet实现类；而Queue是在JDK1.5后才出现的新集合，主要以数组和链表两种形式存在。
继承关系图：
常用集合：ArrayList （数组）
特点
- 容量不固定，随着容量的增加而动态扩容（阈值基本不会达到）
- 有序集合（插入的顺序==输出的顺序）
- 插入的元素可以为null
- 效率更高（相对于LinkedList来说）
- 线程不安全
list 常用方法
import java.util.ArrayList;
import java.util.List; public class var {
public static void main(String[] args){
List<String> list = new ArrayList();
List<String> list1 = new ArrayList(); //list添加数据
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
System.out.println("add:"+list); //list的长度
System.out.println("size:"+list.size()); //集合转数组
Object[] arr = list.toArray();
System.out.println("toArray:"+arr); //判断集合是否为空
if(!list.isEmpty()){
System.out.println("集合list 不为空。");
} //判断集合中是否包含某个元素
if(list.contains("张三")){
System.out.println("list包含张三。");
}
if(list.contains("李三")){
//
}else{
System.out.println("list不包含李三。");
} //复制list
list1.addAll(list);
System.out.println("addAll:"+list1); //list 删除数据
list.remove(0); //按照角标删除
list.remove("王五"); //按照内容删除。
System.out.println("remove:"+list); //获取第2个数据数据
System.out.println("get:"+list.get(1)); //清空元素
list.clear();
System.out.println("clear:"+list); //判断集合是否为空
if(list.isEmpty()){
System.out.println("集合list 为空。");
}
}
}
运行结果：
list 中还有其他方法，见JDK的API。
常用集合：LinkedList（链表）
特点：插入，删除快。
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List; public class var {
public static void main(String[] agrs){
List<String> linkedList = new LinkedList<String>();
System.out.println("LinkedList初始容量："+linkedList.size()); //添加功能：
linkedList.add("my");
linkedList.add("name");
linkedList.add("is");
linkedList.add("jiaboyan");
System.out.println("LinkedList当前容量："+ linkedList.size()); //修改功能:
linkedList.set(0,"hello");
linkedList.set(1,"world");
System.out.println("LinkedList当前内容："+ linkedList.toString()); //获取功能：
String element = linkedList.get(0);
System.out.println(element); //遍历集合：(LinkedList实际的跌倒器是ListItr对象)
Iterator<String> iterator = linkedList.iterator();
while(iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
//for循环迭代集合：
for(String str:linkedList){
System.out.println(str);
} //判断功能：
boolean isEmpty = linkedList.isEmpty();
boolean isContains = linkedList.contains("jiaboyan"); //长度功能：
int size = linkedList.size(); //删除功能：
linkedList.remove(0);
linkedList.remove("jiaboyan");
linkedList.clear();
System.out.println("LinkedList当前容量：" + linkedList.size());
}
}
运行结果：
ArrayList 和 LinkedList 对比
1. 插入数据：LinkedList 效率高。
2. 查询数据：ArrayList 效率非常高。
3. 空间利用率 ：LinkedList 高。
不常用集合：Vector（队列）
特点：线程安全
import java.util.Arrays;
import java.util.Vector; public class var {
public static void main(String[] agrs){
Vector vector = new Vector(); //向该集合中添加元素
vector.add("A");
vector.add("B");
vector.add("C");
System.out.println(vector); //向指定的位置添加元素
vector.add(1,"F");
vector.add(3,"H");
System.out.println(vector); //删除元素
vector.remove("H");
vector.remove(1);
System.out.println(vector); //修改元素
vector.set(1,"G");
System.out.println(vector); //查询元素
System.out.println("get: "+vector.get(1)); //判断当前集合是否为空
boolean b = vector.isEmpty();
System.out.println(b); //返回集合vector中元素的个数
int i = vector.size();
System.out.println("size: "+i); //将集合对象转为Object的数组
Object[] array = vector.toArray();
System.out.println(Arrays.toString(array));
}
}
运行结果：
因为vector 线程安全，导致效率低，所以使用较少。
不常用集合：Stack (堆栈)
特点：先进后出
import java.util.Stack;
public class var {
public static void main(String[] agrs){
Stack stack = new Stack();
//提供了push,写入元素
stack.push("A");
stack.push("B");
stack.push("C");
//提供了push,写入一个元素
stack.push("D");
System.out.println(stack);
//pop 拉取一个元素，并移除
System.out.println(stack.pop());
System.out.println(stack);
//拉取一个元素，不移除
System.out.println(stack.peek());
System.out.println(stack);
// 查找search
System.out.println(stack.search("B"));
}
}
运行结果：
常用集合：HashSet（哈希）
特点：元素不会重复。
import java.util.HashSet;
import java.util.Set; public class var {
public static void main(String[] agrs){
Set set= new HashSet();
set.add("1");
set.add("1");
set.add("2");
set.add("3");
set.add("4");
set.add("5");
set.add("5");
System.out.println(set);
}
}
运行结果：
常用集合：TreeSet（二叉树）
特点：TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
public class Person {
public String name; //姓名
public Integer age; //年龄
public Person(String name,Integer age) {
this.name=name;
this.age=age;
}
}
import demo.design.strategy.imp.Person;
import java.util.TreeSet; public class var {
public static void main(String[] agrs){
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("张三", 23));
ts.add(new Person("李四", 13));
ts.add(new Person("周七", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
System.out.println(ts);
}
}
运行结果：
因为TreeSet需要排序，所以需要指定类的排序逻辑
public class Person implements Comparable<Person>{
public String name; //姓名
public Integer age; //年龄
public Person(String name,Integer age) {
this.name=name;
this.age=age;
}
/**
* 加上比较方法，让TreeSet 可以根据这个排序
* @param o
* @return
*/
public int compareTo(Person o){
if(o.age > this.age){
return 1;
}else if(o.age > this.age){
return -1;
}else {
return 0;
}
}
}
import java.util.Iterator;
import java.util.TreeSet; public class var {
public static void main(String[] agrs){
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("张三", 23));
ts.add(new Person("李四", 13));
ts.add(new Person("周七", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33)); //使用迭代方式获取元素
Iterator<Person> it = ts.iterator();
while (it.hasNext()){
Person person= it.next();
System.out.println("姓名："+person.name+"年龄："+person.age);
}
}
}
运行结果：
能够熟料掌握以上集合，在今后的工作中已经够用，需要继续了解，可以阅读JDK API文档。
参考：https://www.jianshu.com/p/63b01b6379fb