Java 面向对象（十一）
常用类之集合
集合：就是用来存放数据的一个容器。
数组和集合的区别
（1）数组能存基本数据类型和引用类型；集合当中只能存放引用数据类型，直接放基本数据类型，也会自动帮你装箱（把基本数据类型转成对象），集合当中只能存放对象。
（2）数组长度是固定，不能再去增长；集合长度是可以改变，根据元素的增长而增加。
什么时候使用数组，什么时候使用集合类。
如果元素个数是固定，推荐使用数组；如果元素不是固定，推荐使用集合。
集合体系
这里介绍集合体系的一部分。
Collection 接口
常用方法
/*
* 向 collection 中添加指定的元素，
* 如果添加成功返回 true，没有添加返回 false。
* 确保此 collection 包含指定的元素。
*/
boolean add(E e)
/*
* 将指定 collection 中的所有元素都添加到此 collection 中
* 如果此 collection 由于调用而发生更改，则返回 true。 否则返回 false。
*/
boolean addAll(Collection<? extends E> c)
// 移除此 collection 中的所有元素
void clear()
// 如果此 collection 包含指定的元素，则返回 true。否则返回 false。
boolean contains(Object o)
// 如果此 collection 包含指定 collection 中的所有元素，则返回 true。否则返回 false。
boolean containsAll(Collection<?> c)
/*
* 比较此 collection 与指定对象是否相等。
* 如果所定义的两个列表以相同的顺序包含相同的元素，则返回 true。
*/
boolean equals(Object o)
// 如果此 collection 不包含元素，则返回 true。
boolean isEmpty()
// 返回在此 collection 的元素上进行迭代的迭代器。
Iterator<E> iterator()
// 从此 collection 中移除指定元素的单个实例，如果存在的话，移除成功，则返回 true。
boolean remove(Object o)
/*
* 移除此 collection 中，此 collection和指定 collection的交集
* 如果此 collection 由于调用而发生更改，则返回 true
*/
boolean removeAll(Collection<?> c)
/*
* 把此 collection和指定 collection的交集赋值给调用者
* 如果此 collection 由于调用而发生更改，则返回 true
*/
boolean retainAll(Collection<?> c)
// 返回此 collection 中的元素数。
int size()
// 返回包含此 collection 中所有元素的数组
Object[] toArray()
// 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
<T> T[] toArray(T[] a)
管理集合元素：
增：add(E e)
删：remove(Object o)
改：Collection中没有定义
清空：clear()
查：
个数：size()
判包含：contains(Object o)
判空：isEmpty()
查找定位某个元素：Collection中没有定义
e.g.
public static void main(String[] args) {
Collection c = new ArrayList();
// 会自动帮你装箱（把基本数据类型转成对象）
c.add(10);
c.add(true);
}
反编译后：
public static void main(String args[])
{
Collection c = new ArrayList();
c.add(Integer.valueOf(10));
c.add(Boolean.valueOf(true));
}
e.g. Collection 遍历
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Student("zs"));
c.add(new Student("ls"));
c.add(new Student("ww"));
// （1）转成数组，通过数组遍历
Object[] array = c.toArray(); // 自动把数组当中所有元素向上转型
for (int i = 0; i < array.length; i++) {
if (array[i] instanceof Student) { // 向下转型有风险
Student s = (Student) array[i]; // 向下转型(转回原来存放的类型)
System.out.println(s.name);
}
}
System.out.println("-----分割线------");
// （2）迭代器遍历（推荐）
Iterator it = c.iterator(); // 放到Iterator内容会自动类型提升为 Object
// 1.判断有没有元素可以迭代，如果仍有，则返回 true。
while (it.hasNext()) {
// 2. 返回游标的下一个元素，游标后移一位
Object next = it.next();
if (next instanceof Student) {
Student s = (Student) next;
System.out.println(s.name);
}
}
}
List 接口
常用方法
由 Collection 接口继承来的不再说明，见Collection 接口的常用方法
// 在列表的指定位置插入指定元素
void add(int index, E element)
/*
* 将指定 collection 中的所有元素都插入到列表中的指定位置
* 如果此 collection 由于调用而发生更改，则返回 true。 否则返回 false。
*/
boolean addAll(int index, Collection<? extends E> c)
// 移除列表中指定位置的元素，返回从列表中移除的元素
E remove(int index)
// 返回列表中指定位置的元素
E get(int index)
// 用指定元素替换列表中指定位置的元素，返回被替换的元素
E set(int index, E element)
// 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1
int indexOf(Object o)
// 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1
int lastIndexOf(Object o)
// 返回此列表元素的列表迭代器（按适当顺序）
ListIterator<E> listIterator()
// 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始
ListIterator<E> listIterator(int index)
// 返回列表中指定的 [fromIndex, toIndex) 之间的部分视图。
List<E> subList(int fromIndex, int toIndex)
// 使用随附的 Comparator排序此列表来比较元素。
default void sort(Comparator<? super E> c)
管理集合元素：
增：add(E e) ; add(int index, E element)
删：remove(Object o) ; remove(int index)
改：set(int index, E element)
清空：clear()
排序：sort(Comparator<? super E> c)
子集合：subList(int fromIndex, int toIndex)
查：
个数：size()
判包含：contains(Object o)
判空：isEmpty()
查找定位某个元素：indexOf(Object o) ; lastIndexOf(Object o) ; get(int index)
e.g.
现在有个需求，遍历集合，如果集合中的元素等于某个值，删除这个元素。
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
// 遍历集合
Iterator it = list.iterator();
while(it.hasNext()) {
// 取出对应的元素
String str = (String)it.next();
// 判断该 元素是否等于 2
if(str.equals("2")) {
// 等于 2 就把2给集合当中删除
list.remove("2");
}
}
System.out.println(list);
以上代码会报 java.util.ConcurrentModificationException 并发修改异常
在迭代集合的过程当中，是不允许直接修改集合结构。
看下源码：
修改后：
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
Iterator it = list.iterator();
while(it.hasNext()) {
String str = (String)it.next();
if(str.equals("2")) {
it.remove(); // 删除当前正在迭代集合的元素（正在遍历的元素 next的结果）
}
}
System.out.println(list);
原理：
e.g. List特有的迭代器
现在换了一个需求，遍历集合，如果集合中的元素等于某个值，在这个元素后添加一个元素。
在迭代器中，只有remove方法，没有add方法。但是在List中有自己特有的迭代器 listIterator
private class ListItr extends Itr implements ListIterator<E>
ListItr 继承了 Itr，所以 Itr 有的方法都能用。
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
// 在list当中有自己特有的迭代器
ListIterator it = list.listIterator();
while (it.hasNext()) {
String str = (String) it.next();
if (str.equals("2")) {
// list.add("myxq"); //会发生并发修改异常
it.add("myxq");
}
}
System.out.println(list);
ArrayList
数据结构分析
数组的大小是固定的，ArrayList 数组扩容的实现：
查询和修改比较快，通过索引就能找到对应值。
添加和删除比较慢
这也就实现了当我们不指定初始化大小的时候，添加第一个元素的时候，数组会扩容为 10.
添加和删除图示：
ArrayList 去除集合中重复的元素
public static ArrayList removeDuplicates(ArrayList list) {
// 1.创建一个空的集合
ArrayList newList = new ArrayList();
// 2.依次取出每一个元素
ListIterator it = list.listIterator();
while (it.hasNext()) {
// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素
Object obj = it.next();
// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中
if (!newList.contains(obj)) {
newList.add(obj);
}
}
return newList;
}
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("d");
System.out.println(list);
ArrayList newList = removeDuplicates(list);
System.out.println(newList);
}
ArrayList 去除集合中重复的自定义对象元素
class Student {
String name;
int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public class Test {
public static ArrayList removeDuplicates(ArrayList list) {
// 1.创建一个空的集合
ArrayList newList = new ArrayList();
// 2.依次取出每一个元素
ListIterator it = list.listIterator();
while (it.hasNext()) {
// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素
Object obj = it.next();
// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中
if (!newList.contains(obj)) {
newList.add(obj);
}
}
return newList;
}
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Student("张三", 20));
list.add(new Student("张三", 20));
list.add(new Student("李四", 21));
System.out.println(list);
ArrayList newList = removeDuplicates(list);
System.out.println(newList);
}
}
以上代码发现并没有去重。
原因是 contains 是用equals（如果没有重写，默认是Object的equals，比较的是地址）判断有没有相同的元素。
修改后
class Student {
String name;
int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) 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;
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public class Test {
public static ArrayList removeDuplicates(ArrayList list) {
// 1.创建一个空的集合
ArrayList newList = new ArrayList();
// 2.依次取出每一个元素
ListIterator it = list.listIterator();
while (it.hasNext()) {
// 3.每取出一个元素，要先判断新集合当中 ，是否已经包含了该元素
Object obj = it.next();
// 4.如果已经包含该元素，就不把该元素添加到新集合当中，不包含时才添加到新集合当中
if (!newList.contains(obj)) {
newList.add(obj);
}
}
return newList;
}
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Student("张三", 20));
list.add(new Student("张三", 20));
list.add(new Student("李四", 21));
System.out.println(list);
ArrayList newList = removeDuplicates(list);
System.out.println(newList);
}
}
LinkedList
数据结构分析
添加和删除比较快，查询和修改比较慢。
LinkedList 特有的方法
// 将指定元素插入此列表的开头。
void addFirst(E e)
// 将指定元素添加到此列表的结尾。
void addLast(E e)
// 获取但不移除此列表的头（第一个元素）。
E element()
// 返回此列表的第一个元素。
E getFirst()
// 返回此列表的最后一个元素。
E getLast()
// 获取并移除此列表的头（第一个元素）。
E remove()
// 移除并返回此列表的第一个元素。
E removeFirst()
// 移除并返回此列表的最后一个元素。
E removeLast()
// 将指定元素添加到此列表的末尾（最后一个元素）。
boolean offer(E e) // 类似 add(E e)
// 在此列表的开头插入指定的元素。
boolean offerFirst(E e) // 类似 addFirst(E e)
// 在此列表末尾插入指定的元素。
boolean offerLast(E e) // 类似 addLast(E e)
// 获取但不移除此列表的头（第一个元素）。
E peek() // 类似 element()
// 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekFirst() // 类似 getFirst()
// 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E peekLast() // 类似 getLast()
// 获取并移除此列表的头（第一个元素）
E poll() // 类似 remove()
// 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollFirst() // 类似 removeFirst()
// 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollLast() // 类似 removeLast()
// 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
boolean removeFirstOccurrence(Object o)
// 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
boolean removeLastOccurrence(Object o)
// 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。
Iterator<E> descendingIterator()
栈：先进后出
// 出栈：从此列表所表示的堆栈处弹出一个元素。
E pop() // 底层调用 removeFirst(e);
// 入栈：将元素推入此列表所表示的堆栈。
void push(E e) // 底层调用 addFirst(e);
Vector
Vector使用很少，一般都使用ArrayList 从1.2开始并到List
特有的方法
// 将指定的组件添加到此向量的末尾，将其大小增加 1。
void addElement(E obj)
// 返回此向量的组件的枚举。
Enumeration<E> elements()
e.g. 特有的遍历元素
Vector vc = new Vector();
vc.add("a");
vc.add("b");
vc.add("c");
// 获取所有元素
Enumeration e = vc.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
与ArrayList对比
（1）都是使用数组来实现的
（2）Vector是线程安全的，内部加了锁；ArrayList当中方法没有加锁
集合的嵌套
class Student {
String name;
Student(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
/**
* 学科 学科当中是有很多班级
* 班级当中又有很多学生
*/
Student stu1 = new Student("zs1");
Student stu2 = new Student("ls1");
// 班级1
List<Student> c1 = new ArrayList<>();
c1.add(stu1);
c1.add(stu2);
Student stu3 = new Student("zs2");
Student stu4 = new Student("ls2");
// 班级2
List<Student> c2 = new ArrayList<>();
c2.add(stu3);
c2.add(stu4);
// 学科 (集合当中又存储集合)
List<List<Student>> x = new ArrayList<>();
x.add(c1);
x.add(c2);
// 把所有班级当中 的学生姓名打印出来
for (List<Student> g : x) {
// 取出每一个班级
for (Student per : g) {
System.out.println(per.name);
}
}
}
}
