Java集合总结
概述
Java集合类主要由两个接口派生而出:
-
Collection
-
Map
这两个是Java集合框架的根接口
Collection与Iterator接口
Collection是List、Set、Queue的父接口
来看看具体使用:
public class CollectionTest {
public static void main(String[] args) {
Collection c = new ArrayList();
// 添加元素
c.add("孙悟空");
// 虽然集合里不能放基本类型的值,但Java支持自动装箱
c.add(6);
System.out.println("c集合的元素个数为:" + c.size()); // 输出2
// 删除指定元素
c.remove(6);
System.out.println("c集合的元素个数为:" + c.size()); // 输出1
// 判断是否包含指定字符串
System.out.println("c集合的是否包含\"孙悟空\"字符串:"
+ c.contains("孙悟空")); // 输出true
c.add("Java");
System.out.println("c集合的元素:" + c);
Collection books = new HashSet();
books.add("Java");
books.add("Java9");
System.out.println("c集合是否完全包含books集合?"
+ c.containsAll(books)); // 输出false
// 用c集合减去books集合里的元素
c.removeAll(books);
System.out.println("c集合的元素:" + c);
// 删除c集合里所有元素
c.clear();
System.out.println("c集合的元素:" + c);
// 控制books集合里只剩下c集合里也包含的元素
books.retainAll(c);
System.out.println("books集合的元素:" + books);
}
}
Lambda表达式遍历集合
Java8为Iterable接口新增了一个forEach默认方法,该方法所需参数类型是一个函数式接口,而Iterable是Collection接口的父接口,所以Collection集合可以直接使用
public class CollectionEach {
public static void main(String[] args)
{
// 创建一个集合
Collection books = new HashSet();
books.add("Java");
books.add("Java9");
books.add("Android");
// 调用forEach()方法遍历集合
books.forEach(obj -> System.out.println("迭代集合元素:" + obj));
}
}
Iterator遍历集合元素
public class IteratorTest {
public static void main(String[] args)
{
// 创建集合、添加元素的代码与前一个程序相同
Collection books = new HashSet();
books.add("1");
books.add("2");
books.add("3");
// 获取books集合对应的迭代器
Iterator it = books.iterator();
while(it.hasNext())
{
// it.next()方法返回的数据类型是Object类型,因此需要强制类型转换
String book = (String)it.next();
System.out.println(book);
if (book.equals("2"))
{
// 从集合中删除上一次next方法返回的元素
it.remove();
}
// 对book变量赋值,不会改变集合元素本身
book = "测试字符串"; //①
}
System.out.println(books);
}
}
Iterator依附于Collection对象,若有一个Iterator对象,则必然有一个与之关联的Collection对象
当使用Iterator迭代访问元素时,Collection里面的元素不能被改变,只有通过Iterator的remove方法删除上一次next方法返回的集合元素才可以
public class IteratorErrorTest {
public static void main(String[] args) {
// 创建集合、添加元素的代码与前一个程序相同
Collection books = new HashSet();
books.add("1");
books.add("2");
books.add("3");
// 获取books集合对应的迭代器
Iterator it = books.iterator();
while(it.hasNext())
{
String book = (String)it.next();
System.out.println(book);
if (book.equals("2"))
{
// 使用Iterator迭代过程中,不可修改集合元素,下面代码引发异常
books.remove(book);
}
}
}
}
Lambda表达式遍历Iterator
Java8为Iterator新增了一个forEachRemaining方法
public class IteratorEach {
public static void main(String[] args) {
// 创建集合、添加元素的代码与前一个程序相同
Collection books = new HashSet();
books.add("1");
books.add("2");
books.add("3");
// 获取books集合对应的迭代器
Iterator it = books.iterator();
// 使用Lambda表达式(目标类型是Comsumer)来遍历集合元素
it.forEachRemaining(obj -> System.out.println("迭代集合元素:" + obj));
}
}
foreach循环遍历集合元素
public class ForeachTest {
public static void main(String[] args) {
// 创建集合、添加元素的代码与前一个程序相同
Collection books = new HashSet();
books.add(new String("1"));
books.add(new String("2"));
books.add(new String("3"));
for (Object obj : books)
{
// 此处的book变量也不是集合元素本身
String book = (String)obj;
System.out.println(book);
if (book.equals("3"))
{
// 下面代码会引发ConcurrentModificationException异常
books.remove(book); //①
}
}
System.out.println(books);
}
}
Java8新增的Predicate操作
Java8为Collection新增了removeIf(Predicate filter)方法,该方法将批量删除符合filter条件的所有元素
public class PredicateTest {
public static void main(String[] args) {
// 创建一个集合
Collection books = new HashSet();
books.add(new String("1"));
books.add(new String("2dnkjadjadjadhjka"));
books.add(new String("3"));
books.add(new String("4fflsjfksjdfksjfidsjfisj"));
books.add(new String("5"));
// 使用Lambda表达式(目标类型是Predicate)过滤集合
books.removeIf(ele -> ((String)ele).length() < 10);
System.out.println(books);
}
}
Set集合
Set最大的特点就是不允许包含重复元素
HashSet
特点:
-
不能保证元素的排列顺序
-
不是同步的
-
集合元素值允许是null
向HashSet添加元素时,会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据hashCode值决定该对象在HashSet中的存储位置
假设两个元素equals()返回true,hashCode()返回值不同,那么将会把它们存储在不同位置
HashSet判读两个元素相等的标准是两个对象通过equals()比较一样,并且hashCode()返回值也一样
下面三个类分别重写了equals(),hashCode()中的一个或者两个
// 类A的equals方法总是返回true,但没有重写其hashCode()方法
class A
{
public boolean equals(Object obj)
{
return true;
}
}
// 类B的hashCode()方法总是返回1,但没有重写其equals()方法
class B
{
public int hashCode()
{
return 1;
}
}
// 类C的hashCode()方法总是返回2,且重写其equals()方法总是返回true
class C
{
public int hashCode()
{
return 2;
}
public boolean equals(Object obj)
{
return true;
}
}
public class HashSetTest
{
public static void main(String[] args)
{
HashSet books = new HashSet();
// 分别向books集合中添加两个A对象,两个B对象,两个C对象
books.add(new A());
books.add(new A());
books.add(new B());
books.add(new B());
books.add(new C());
books.add(new C());
System.out.println(books);
}
}
HashSet把A的两个对象以及B的两个对象当成了两个对象
当把一个对象仿佛HashSet,如果要重写equals(),则对应的也应该重写hashCode()
规则:
如果两个对象通过equals()比较返回true,这两个对象的hashCode()也应该一样
如果向HashSet添加一个可变对象后,后面修改了该对象的实例变量,可能导致它与集合中的其他元素相同,导致HashSet中包含两个一样的对象
class R
{
int count;
public R(int count)
{
this.count = count;
}
public String toString()
{
return "R[count:" + count + "]";
}
public boolean equals(Object obj)
{
if(this == obj)
return true;
if (obj != null && obj.getClass() == R.class)
{
R r = (R)obj;
return this.count == r.count;
}
return false;
}
public int hashCode()
{
return this.count;
}
}
public class HashSetTest2
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new R(5));
hs.add(new R(-3));
hs.add(new R(9));
hs.add(new R(-2));
// 打印HashSet集合,集合元素没有重复
System.out.println(hs);
// 取出第一个元素
Iterator it = hs.iterator();
R first = (R)it.next();
// 为第一个元素的count实例变量赋值
first.count = -3; // ①
// 再次输出HashSet集合,集合元素有重复元素
System.out.println(hs);
// 删除count为-3的R对象
hs.remove(new R(-3)); // ②
// 可以看到被删除了一个R元素
System.out.println(hs);
System.out.println("hs是否包含count为-3的R对象?"
+ hs.contains(new R(-3))); // 输出false
System.out.println("hs是否包含count为-2的R对象?"
+ hs.contains(new R(-2))); // 输出false
}
}
可以看到,R类重写的equals()和hashCode()都是根据R对象的count这个实例变量来进行计算的
所以后面的程序对这个实例变量进行改变后会导致HashSet集合中出现重复的元素
LinkedHashSet
HashSet有一个子类LinkedHashSet,LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序
public class LinkedHashSetTest {
public static void main(String[] args) {
LinkedHashSet books = new LinkedHashSet();
books.add("1");
books.add("2");
System.out.println(books);
books.remove("1");
books.add("1");
System.out.println(books);
}
}
LinkedHashSet依然不允许集合元素重复
TreeSet
TreeSet是SortedSet接口的实现类,可以确保集合元素处于排序状态
public class TreeSetTest {
public static void main(String[] args)
{
TreeSet nums = new TreeSet();
// 向TreeSet中添加四个Integer对象
nums.add(5);
nums.add(2);
nums.add(10);
nums.add(-9);
// 输出集合元素,看到集合元素已经处于排序状态
System.out.println(nums);
// 输出集合里的第一个元素
System.out.println(nums.first()); // 输出-9
// 输出集合里的最后一个元素
System.out.println(nums.last()); // 输出10
// 返回小于4的子集,不包含4
System.out.println(nums.headSet(4)); // 输出[-9, 2]
// 返回大于5的子集,如果Set中包含5,子集中还包含5
System.out.println(nums.tailSet(5)); // 输出 [5, 10]
// 返回大于等于-3,小于4的子集。
System.out.println(nums.subSet(-3 , 4)); // 输出[2]
}
}
TreeSet并不是根据元素的插入顺序进行排序的,而是根据元素实际值的大小进行排序的
TreeSet支持两种排序方法:
-
自然排序
-
定制排序
自然排序
TreeSet会调用集合元素的compareTo(Object o)来比较元素之间的大小关系,然后将集合元素按照升序排序
如果试图把一个对象添加到TreeSet,则该对象必须实现了Comparable接口,否则会出错
class Err{}
public class TreeSetErrorTest {
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
// 向TreeSet集合中添加Err对象
// 自然排序时,Err没实现Comparable接口将会引发错误
// Exception in thread "main" java.lang.ClassCastException: C_2.c_2_1.Err cannot be cast to java.lang.Comparable
ts.add(new Err());
}
}
TreeSet集合,判断两个对象是否相等的唯一标准是:两个对象通过compareTo(Onject o)比较是否返回0—如果返回0,则认为相等,否则不相等
class Z implements Comparable
{
int age;
public Z(int age)
{
this.age = age;
}
// 重写equals()方法,总是返回true
public boolean equals(Object obj)
{
return true;
}
// 重写了compareTo(Object obj)方法,总是返回1
public int compareTo(Object obj)
{
return 1;
}
}
public class TreeSetTest2
{
public static void main(String[] args)
{
TreeSet set = new TreeSet();
Z z1 = new Z(6);
set.add(z1);
// 第二次添加同一个对象,输出true,表明添加成功
System.out.println(set.add(z1)); //①
// 下面输出set集合,将看到有两个元素
System.out.println(set);
// 修改set集合的第一个元素的age变量
((Z)(set.first())).age = 9;
// 输出set集合的最后一个元素的age变量,将看到也变成了9
System.out.println(((Z)(set.last())).age);
}
}
同样,如果两个对象通过equals()比较返回true,这两个对象通过compareTo比较应该返回0
如果向TreeSet添加一个可变对象,并且修改该对象的实例变量,将导致顺序发生改变
class R implements Comparable
{
int count;
public R(int count)
{
this.count = count;
}
public String toString()
{
return "R[count:" + count + "]";
}
// 重写equals方法,根据count来判断是否相等
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if(obj != null && obj.getClass() == R.class)
{
R r = (R)obj;
return r.count == this.count;
}
return false;
}
// 重写compareTo方法,根据count来比较大小
public int compareTo(Object obj)
{
R r = (R)obj;
return count > r.count ? 1 :
count < r.count ? -1 : 0;
}
}
public class TreeSetTest3
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new R(5));
ts.add(new R(-3));
ts.add(new R(9));
ts.add(new R(-2));
// 打印TreeSet集合,集合元素是有序排列的
System.out.println(ts); // ①
// 取出第一个元素
R first = (R)ts.first();
// 对第一个元素的count赋值
first.count = 20;
// 取出最后一个元素
R last = (R)ts.last();
// 对最后一个元素的count赋值,与第二个元素的count相同
last.count = -2;
// 再次输出将看到TreeSet里的元素处于无序状态,且有重复元素
System.out.println(ts); // ②
// 删除实例变量被改变的元素,删除失败
System.out.println(ts.remove(new R(-2))); // ③
System.out.println(ts);
// 删除实例变量没有被改变的元素,删除成功
System.out.println(ts.remove(new R(5))); // ④
System.out.println(ts);
}
}
定制排序
如果想实现定制排序,比如降序排序,可以通过Comparator接口实现
class M
{
int age;
public M(int age)
{
this.age = age;
}
public String toString()
{
return "M [age:" + age + "]";
}
}
public class TreeSetTest4
{
public static void main(String[] args)
{
// 此处Lambda表达式的目标类型是Comparator
TreeSet ts = new TreeSet((o1 , o2) ->
{
M m1 = (M)o1;
M m2 = (M)o2;
// 根据M对象的age属性来决定大小,age越大,M对象反而越小
return m1.age > m2.age ? -1
: m1.age < m2.age ? 1 : 0;
});
ts.add(new M(5));
ts.add(new M(-3));
ts.add(new M(9));
System.out.println(ts);
}
}
EnumSet类
EnumSet类是一个专门为枚举类设计的集合类,EnumSet中所有元素都必须是指定枚举类型的枚举值,EnumSet集合元素也是有序的,EnumSet以枚举值在Enum类的定义顺序来决定集合元素的顺序
enum Season
{
SPRING,SUMMER,FALL,WINTER
}
public class EnumSetTest
{
public static void main(String[] args)
{
// 创建一个EnumSet集合,集合元素就是Season枚举类的全部枚举值
EnumSet es1 = EnumSet.allOf(Season.class);
System.out.println(es1); // 输出[SPRING,SUMMER,FALL,WINTER]
System.out.println("___________________________________________________");
// 创建一个EnumSet空集合,指定其集合元素是Season类的枚举值。
EnumSet es2 = EnumSet.noneOf(Season.class);
System.out.println(es2); // 输出[]
System.out.println("___________________________________________________");
// 手动添加两个元素
es2.add(Season.WINTER);
es2.add(Season.SPRING);
System.out.println(es2); // 输出[SPRING,WINTER]
System.out.println("___________________________________________________");
// 以指定枚举值创建EnumSet集合
EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER);
System.out.println(es3); // 输出[SUMMER,WINTER]
System.out.println("___________________________________________________");
EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER);
System.out.println(es4); // 输出[SUMMER,FALL,WINTER]
System.out.println("___________________________________________________");
// 新创建的EnumSet集合的元素和es4集合的元素有相同类型,
// es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值
EnumSet es5 = EnumSet.complementOf(es4);
System.out.println(es5); // 输出[SPRING]
}
}
public class EnumSetTest2 {
public static void main(String[] args)
{
Collection c = new HashSet();
c.clear();
c.add(Season.FALL);
c.add(Season.SPRING);
// 复制Collection集合中所有元素来创建EnumSet集合
EnumSet enumSet = EnumSet.copyOf(c); // ①
System.out.println(enumSet); // 输出[SPRING,FALL]
c.add("Java");
c.add("C++");
// 下面代码出现异常:因为c集合里的元素不是全部都为枚举值
enumSet = EnumSet.copyOf(c); // ②
}
}
List集合
List接口和ListIterator接口
展示List集合常规操作
public class ListTest {
public static void main(String[] args) {
List books = new ArrayList();
// 向books集合中添加三个元素
books.add(new String("Java"));
books.add(new String("C++"));
books.add(new String("Android"));
System.out.println(books);
// 将新字符串对象插入在第二个位置
books.add(1 , new String("Ajax"));
for (int i = 0 ; i < books.size() ; i++ )
{
System.out.println(books.get(i));
}
// 删除第三个元素
books.remove(2);
System.out.println(books);
// 判断指定元素在List集合中位置:输出1,表明位于第二位
System.out.println(books.indexOf(new String("Ajax"))); //①
//将第二个元素替换成新的字符串对象
books.set(1, new String("Java"));
System.out.println(books);
//将books集合的第二个元素(包括)
//到第三个元素(不包括)截取成子集合
System.out.println(books.subList(1 , 2));
}
}
List判断两个对象相等通过equals()返回true即可
class A
{
public boolean equals(Object obj)
{
return true;
}
}
public class ListTest2
{
public static void main(String[] args)
{
List books = new ArrayList();
books.add(new String("Java"));
books.add(new String("C++"));
books.add(new String("Android"));
System.out.println(books);
// 删除集合中A对象,将导致第一个元素被删除
books.remove(new A()); // ①
System.out.println(books);
// 删除集合中A对象,再次删除集合中第一个元素
books.remove(new A()); // ②
System.out.println(books);
}
}
Java 8为List集合增加了sort()和replaAll()两个默认方法
public class ListTest3 {
public static void main(String[] args) {
List books = new ArrayList();
// 向books集合中添加4个元素
books.add(new String("Java"));
books.add(new String("C++"));
books.add(new String("Android"));
books.add(new String("iOS"));
// 使用目标类型为Comparator的Lambda表达式对List集合排序
books.sort((o1, o2)->((String)o1).length() - ((String)o2).length());
System.out.println(books);
// 使用目标类型为UnaryOperator的Lambda表达式来替换集合中所有元素
// 该Lambda表达式控制使用每个字符串的长度作为新的集合元素
books.replaceAll(ele->((String)ele).length());
System.out.println(books);
}
}
固定长度的List
操作数组的工具类:Arrays,提供了一个asList(Object…a)方法,该方法可以把一个数组或指定个数的对象转换成一个List集合
Arrays.ArrayList是一个固定长度的List集合,只能遍历,不能增加,删除
public class FixedSizeList {
public static void main(String[] args)
{
List fixedList = Arrays.asList("Java"
, "Java EE");
// 获取fixedList的实现类,将输出Arrays$ArrayList
System.out.println(fixedList.getClass());
// 使用方法引用遍历集合元素
fixedList.forEach(System.out::println);
// 试图增加、删除元素都会引发UnsupportedOperationException异常
fixedList.add("Android");
fixedList.remove("C++");
}
}
Queue集合
Queue用于模拟队列这种数据结构
Queue接口有一个PriorityQueue实现类,还有一个Deque接口,Deque代表一个“双端队列”,Java为Deque提供了ArrayDeque和LinkedList两个实现类
PriorityQueue
PriorityQueue保存队列元素的顺序不是按加入队列的顺序,而是按照队列元素的大小进行重新排序,所以用peek()或者poll()取元素,并不是取出最先进入队列的元素,而是最小元素
public class PriorityQueueTest {
public static void main(String[] args)
{
PriorityQueue pq = new PriorityQueue();
// 下面代码依次向pq中加入四个元素
pq.offer(6);
pq.offer(-3);
pq.offer(20);
pq.offer(18);
// 输出pq队列,并不是按元素的加入顺序排列
System.out.println(pq); // 输出[-3, 6, 20, 18]
// 访问队列第一个元素,其实就是队列中最小的元素:-3
System.out.println(pq.poll());
}
}
PriorityQueue不允许出现null值
Deque和ArrayDeque实现类
把ArrayDeque当成栈使用
public class ArrayDequeStack {
public static void main(String[] args) {
ArrayDeque stack = new ArrayDeque();
// 依次将三个元素push入"栈"
stack.push("Java");
stack.push("Java EE");
stack.push("Android");
System.out.println(stack);
System.out.println(stack.peek());
System.out.println(stack);
System.out.println(stack.pop());
System.out.println(stack);
}
}
ArrayDeque也可以用作队列使用
public class ArrayDequeQueue {
public static void main(String[] args) {
ArrayDeque queue = new ArrayDeque();
// 依次将三个元素加入队列
queue.offer("Java");
queue.offer("Java EE");
queue.offer("Android");
System.out.println(queue);
System.out.println(queue.peek());
System.out.println(queue);
System.out.println(queue.poll());
System.out.println(queue);
}
}
LinkedList
public class LinkedListTest {
public static void main(String[] args)
{
LinkedList books = new LinkedList();
// 将字符串元素加入队列的尾部
books.offer("Java");
// 将一个字符串元素加入栈的顶部
books.push("Java EE");
// 将字符串元素添加到队列的头部(相当于栈的顶部)
books.offerFirst("Android");
// 以List的方式(按索引访问的方式)来遍历集合元素
for (int i = 0; i < books.size() ; i++ )
{
System.out.println("遍历中:" + books.get(i));
}
System.out.println("___________________________________");
// 访问、并不删除栈顶的元素
System.out.println(books.peekFirst());
// 访问、并不删除队列的最后一个元素
System.out.println(books.peekLast());
// 将栈顶的元素弹出“栈”
System.out.println(books.pop());
// 下面输出将看到队列中第一个元素被删除
System.out.println(books);
// 访问、并删除队列的最后一个元素
System.out.println(books.pollLast());
System.out.println(books);
}
}
Map
Map用于保存具有映射关系的数据,Map的key不允许重复
public class MapTest {
public static void main(String[] args)
{
Map map = new HashMap();
// 成对放入多个key-value对
map.put("Java" , 109);
map.put("iOS" , 10);
map.put("Ajax" , 79);
// 多次放入的key-value对中value可以重复
map.put("Java EE" , 99);
// 放入重复的key时,新的value会覆盖原有的value
// 如果新的value覆盖了原有的value,该方法返回被覆盖的value
System.out.println(map.put("iOS" , 99)); // 输出10
System.out.println(map); // 输出的Map集合包含4个key-value对
// 判断是否包含指定key
System.out.println("是否包含值为 iOS key:"
+ map.containsKey("iOS")); // 输出true
// 判断是否包含指定value
System.out.println("是否包含值为 99 value:"
+ map.containsValue(99)); // 输出true
// 获取Map集合的所有key组成的集合,通过遍历key来实现遍历所有key-value对
for (Object key : map.keySet() )
{
// map.get(key)方法获取指定key对应的value
System.out.println(key + "-->" + map.get(key));
}
map.remove("Ajax"); // 根据key来删除key-value对。
System.out.println(map);
}
}
Java 8新增方法:
public class MapTest2 {
public static void main(String[] args)
{
Map map = new HashMap();
// 成对放入多个key-value对
map.put("Java" , 109);
map.put("iOS" , 99);
map.put("Ajax" , 79);
// 尝试替换key为"XML"的value,由于原Map中没有对应的key,
// 因此对Map没有改变,不会添加新的key-value对
map.replace("XML" , 66);
System.out.println(map);
// 使用原value与参数计算出来的结果覆盖原有的value
map.merge("iOS" , 10 ,
(oldVal , param) -> (Integer)oldVal + (Integer)param);
System.out.println(map);
// 当key为"Java"对应的value为null(或不存在时),使用计算的结果作为新value
map.computeIfAbsent("Java" , (key)->((String)key).length());
System.out.println(map); // map中添加了 Java=4 这组key-value对
// 当key为"Java"对应的value存在时,使用计算的结果作为新value
map.computeIfPresent("Java",
(key , value) -> (Integer)value * (Integer)value);
System.out.println(map);
}
}