集合复习

1:集合的由来?

​ 答：数组的长度是固定的，当添加的元素超过了数组的长度时，需要对数组重新定义，比较麻烦，Java内部给我们提供了集合类，能储存任意对象，长度时可以改变的，随着元素的增加而增加，随着元素的减少而减少。
2:集合和数组的区别?

​ 答：①区别一：数组既可以储存基本数据类型，也可以储存引用数据类型，基本数据类型储存的是值，引用数据类型储存的是地址值； 集合只能储存引用数据类型(对象)，集合中也能储存基本数据类型，但储存时会自动装箱变成对象。

​ ②区别二：数组的长度时固定的，不能自动增长； 集合的长度是可变，恶意根据元素的增长而增长。

3:Collection集合的功能概述?

​ 答：Collection是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。

Collection常用功能：

​ ①：添加功能

​ boolean add(Object obj)：添加一个元素

​ boolean addAll(Collection c)：添加一个集合元素

​ ②：删除功能

​ void clear()：移除所有元素

​ boolean remove(Object o)：移除一个元素

​ boolean removeAll(Collection c)：移除一个集合的元素（只要有一个元素移除了就返回true）

​ ③：判断功能

​ boolean contanis(Object obj)：判断集合中是否包含指定的元素

​ boolean contanis(Collection c)：判断集合中是否包含指定的集合元素（只有包含指定集合中所有元素才叫包含）

​ boolean isEmpty()：判断集合是否为空（指集合的数据元素）

​ ④：获取功能

​ Iterator iterator()：迭代器，集合专有的遍历方式

​ ⑤：长度功能

​ int size()：元素的个数

​ ⑥：交集功能

​ boolean retainAll(Collrction c)：两个集合中都有的元素（假设有两个集合A、B，A对B做交集，最终的集合保存在集合A中，集合B不变，返回值表示的是集合A是否发生过改变）

​ ⑦：把集合转换为数组

​ Object[]toArray()：把集合转换成数组，可以实现集合的遍历。

​ ⑧：交集功能

​ boolean retainAll (Collection c)：两个集合的交集

Collection有两个子接口List和Set；

​ (1)：List集合

​ List集合的特：有序（指存储和取出元素的顺序一致）、存储元素可重复

​ List集合特有功能：

​ ①：添加功能

​ void add(int index,Object element)：在指定位置添加元素

​ ②：获取功能

​ Object get(int index)：获取指定位置的元素

​ ③：列表迭代器

​ ListIterator listIterator()：迭代所有的元素

​ ④：删除功能

​ Object remove(int index)：根据索引删除元素，返回被删除的元素

​ ⑤：修改功能

​ Object set(int index,Object emement)：根据索引修改元素，返回被修改的元素

​ List集合有ArrayList、Vector和LinkedList三个常用子类。

​ (2)List集合的子类

​ List集合的子类特点

​ ArrayList的底层数据结构是数组，查询快、增删慢、线程不安全、效率高

​ Vector的底层数据结构是数组，查询快、增删慢、线程安全，效率低

​ LinkedList的底层数据结构是链表，查询慢、增删快、线程不安全，效率高

​ Vector的特有功能：

​ ①：添加功能

​ public void addFirst(Object obj)

​ public void addLast(Object obj)

​ ②：获取功能

​ public Object getFirst()

​ public Object getLast()

​ ③：删除功能

​ public Object removeFirst()

​ public Object removeLast()

​ (3):Set集合

​ Set集合的特点：无序（指元素的存储和取出顺序不一致），储存元素唯一

​ Set集合有HashSet和TreeSet两个常用子类

​ (4):Set集合的子类

​ ①：HashSet类的特点

​ HashSet类不保证Set的迭代顺序，特别是它不保证该顺序永久不变

​ HashSet类的底层数据结构是哈希表。而哈希表保证元素的唯一性依赖于两个方法：int hashCode()和boolean equals(Object obj)

​ 用HashSet储存元素的执行顺序：

​ 首先比较HashCode()是否相同，

​ 是：继续执行equals()，看其返回值

​ 是true：说明元素重复，不添加

​ 是false：直接添加到集合

​ 否：直接添加到集合

​ HashSet有一个子类LinkedHashSet，LinedHashSet存储元素的特点是有序、唯一；

​ LinkedHashSet的底层数据结构由，链表和哈希表组成，由链表保证元素有序，由哈希表保证元素唯一。

​ ②：TreeSet的特点

​ TreeSet类底层数据结构是红黑树（是一种自平衡的二叉树）。

​ TreeSet类根据比较的返回值是否是0来决定元素的唯一性

​ TreeSet排序方式：

​ ①：自然排序（元素具备比较性）

​ 让元素所属的类来实现Comparable接口

​ ②：比较器排训（集合具备比较性）

​ 让集合接收一个Comparable的实现类对象

4:Collection集合存储字符串并遍历?(迭代器)

~~~java
package com.haha.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
* 储存字符串并遍历
* Created by 搁浅 on 2017/7/20.
*/
public class Demo1 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//创建字符串对象
//把字符串对象添加到集合中
c.add(“a”);
c.add(“b”);
c.add(“c”);
c.add(“d”);
//集合遍历
//通过集合对象获取迭代器对象
Iterator it = c.iterator();
while (it.hasNext()){
//通过迭代器对象的next()获取元素并移动到下一个位置
String s = (String) it.next();
System.out.println(s);
}
}
}
~~~

5:Collection集合存储自定义对象并遍历?(迭代器)

~~~java
实体类：
package com.haha.bean;

/**
* Created by 搁浅 on 2017/7/20.
*/
public class Student {
private String name;
private int age;

public Student() {    super();}public Student(String name, int age) {    this.name = name;    this.age = age;}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;}@Overridepublic String toString() {    return "Student{" +            "name='" + name + '\'' +            ", age=" + age +            '}';}

}
——————————————————————————————————————————————————————————————————————————————————————————
package com.haha.collection;

import com.haha.bean.Student;

import java.util.ArrayList;
import java.util.List;

/**
* Created by 搁浅 on 2017/7/20.
*/
public class Demo2 {
public static void main(String[] args) {
//创建集合对象
Collection list = new ArrayList();
//创建自定义对象
//把自定义对象添加到集合中
list.add(new Student(“张三1”, 231));
list.add(new Student(“张三2”, 232));
list.add(new Student(“张三3”, 233));
list.add(new Student(“张三4”, 234));
list.add(new Student(“张三5”, 235));
Iterator iterator = list.iterator();//获取迭代器
while(iterator.hasNext()){
Student s = (Student) iterator.next();
System.out.println(s.getName() + “…” + s.getAge());
}
}
}
~~~

9:并发修改异常出现的原因?解决方案?

~~~java
package com.haha.collection;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo3 {
/**
* ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这中修改时，抛出异常；
* 产生的原因：迭代器依赖于集合而存在的，在判断成功后，集合的元素中中添加了新元素，而迭代器却不知道，所以就报错了，
* 简单描述就是：迭代器遍历元素的时候，通过元素是不能改变元素的。
* @param args
*/
public static void main(String[] args) {
ArrayList array = new ArrayList();
array.add(“a”);
array.add(“b”);
array.add(“c”);
array.add(“d”);
Iterator it = array.iterator();
while(it.hasNext()){
String s = (String) it.next();
if (“a”.equals(s)) {
array.add(“e”);
}
}
}

}

package com.haha.collection;

import java.util.ArrayList;
import java.util.ListIterator;

/**
* Created with IntelliJ IDEA.
* User: 搁浅
* Date: 2017/7/21
* Time: 下午 02:59
* 解决并发修改异常一：
* 迭代器遍历元素，迭代器修改元素
* ListIterator it = list.listIterator();
*/
public class Demo4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(“a”);
list.add(“b”);
list.add(“c”);
list.add(“d”);
//迭代器遍历元素，迭代器修改元素
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {
if(listIterator.next().equals(“b”)) {
listIterator.add(“e”);
}
}
System.out.println(list);
}

}

package com.haha.collection;

import java.util.ArrayList;

/**
* Created with IntelliJ IDEA.
* User: 搁浅
* Date: 2017/7/21
* Time: 下午 03:17
* 解决并发修改异常之二：
* 集合遍历元素，集合修改元素
*/
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(“a”);
list.add(“b”);
list.add(“c”);
//集合遍历元素，集合修改元素 for
for (int i = 0; i < list.size(); i++) {
String s = (String) list.get(i);
if (“b”.equals(s)) {
list.add(“e”);
}
}
System.out.println(list);
}
}
~~~