集合(Collection集合)由来_集合由来-CSDN博客

一、集合(Collection集合)
(1)集合的由来?
我们学习的是Java – 面向对象 – 操作很多对象 – 存储 – 容器(数组和StringBuffer) – 数组
而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别?
A:长度区别
数组固定
集合可变
B:内容区别
数组可以是基本类型，也可以是引用类型
集合只能是引用类型
C:元素内容
数组只能存储同一种类型
集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构?
由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

(4)Collection的功能概述
A:添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素
B:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
C:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
boolean isEmpty()：判断集合是否为空
D:获取功能
Iterator iterator()(重点)
E:长度功能
int size():元素的个数
F:交集(了解)
boolean retainAll(Collection c) 返回值表示的是调用者集合是否发生过改变
G:把集合转数组(了解)
Object[] toArray():把集合转成数组，可以实现集合的遍历
(5)Collection集合的遍历
A:把集合转数组(了解)
B:迭代器(集合专用方式)
C;代码演示
[java] view plaincopyprint?
public class Test {

public static void main(String[] args) {  

    // 创建集合对象  
    Collection c = new ArrayList();  

    //添加元素  
    c.add("hello");  
    c.add("world");  
    c.add("java");  

    //遍历第一种方法  
    //把集合转为数组  
    Object[] array = c.toArray();  

    //遍历数组  
    for (int i = 0; i < array.length; i++) {  
        Object object = array[i];  
        System.out.println(object);  

    }  

    System.out.println("-----------------");  
    //遍历第二种方法  
    //用迭代器方法  
    Iterator  i = c.iterator();  //获取迭代器  
    while(i.hasNext()){  
        String s = (String)i.next();  
        System.out.println(s);  
    }  
}

}
(7)Collection集合的遍历步骤
集合的操作步骤：
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
D:遍历集合

二、集合(List集合)
(1)List是Collection的子接口
特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List的特有功能：
A:添加功能
void add(int index,Object element):在指定位置添加元素
B:删除功能
Object remove(int index)：根据索引删除元素,返回被删除的元素
C:获取功能
Object get(int index):获取指定位置的元素
D:迭代器功能
ListIterator listIterator()：List集合特有的迭代器
E:修改功能
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
(3)List集合的特有遍历功能
A:由size()和get()结合。
B:代码演示
[java] view plaincopyprint?
public class Test {

public static void main(String[] args) {  
    // 创建集合对象  
    List list = new ArrayList();  

    // 添加元素  
    list.add("hello");  
    list.add("world");  
    list.add("java");  

    //循环遍历  
    for (int x = 0; x < list.size(); x++) {  
        String s = (String) list.get(x);  
        System.out.println(s);  
    }  
}

}
(4)列表迭代器的特有功能；(了解)
可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5)并发修改异常
A:出现的现象
迭代器遍历集合，集合修改集合元素
[java] view plaincopyprint?
// 创建List集合对象
List list = new ArrayList();
// 添加元素
list.add(“hello”);
list.add(“world”);
list.add(“java”);

// 迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
if (“world”.equals(s)) {
list.add(“javaee”); //添加不了会出现并发修改异常
}
}
B:原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
C:解决方案
a:迭代器遍历，迭代器修改(ListIterator)
[java] view plaincopyprint?
// 方式1：迭代器迭代元素，迭代器修改元素
// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
ListIterator lit = list.listIterator();
while (lit.hasNext()) {
String s = (String) lit.next();
if (“world”.equals(s)) {
lit.add(“javaee”);
}
}
b:集合遍历，集合修改(size()和get())
[java] view plaincopyprint?
// 方式2：集合遍历元素，集合修改元素(普通for)
for (int x = 0; x < list.size(); x++) {
String s = (String) list.get(x);
if (“world”.equals(s)) {
list.add(“javaee”);
}
}
(6)常见数据结构
A:栈：先进后出
B:队列：先进先出
C:数组：查询快，增删慢
D:链表：查询慢，增删快
(7)List的子类特点(面试题)
ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
到底使用谁呢?看需求?
分析：
要安全吗?
要：Vector(即使要，也不使用这个，后面再说)
不要：ArrayList或者LinkedList
查询多；ArrayList
增删多：LinkedList
什么都不知道，就用ArrayList。

三、集合(List的子类)
(1)ArratList
A:有没特有功能需要学习
(2)Vector
A:特有功能
a：添加
public void addElement(Object obj)
b:获取
public Object elementAt(int index)
public Enumeration elements()
boolean hasMoreElements()
Object nextElement()
(3)LinkedList
A:特有功能
a:添加
public void addFirst(Object e)
public void addLast(Object e)
b:删除
public Object removeFirst()
public Object removeLast()
c:获取
public Object getFirst()
public Obejct getLast()
(4)案列
A：去除集合中的多个字符串的重复元素，如果字符串的内容相同，即为重复元素
[java] view plaincopyprint?
/*
* ArrayList去除集合中字符串的重复值(字符串的内容相同)
*
* 分析：
* A:创建集合对象
* B:添加多个字符串元素(包含内容相同的)
* C:创建新集合
* D:遍历旧集合,获取得到每一个元素
* E:拿这个元素到新集合去找，看有没有
* 有：不搭理它
* 没有：就添加到新集合
* F:遍历新集合
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();

    // 添加多个字符串元素(包含内容相同的)  
    array.add("hello");  
    array.add("world");  
    array.add("java");  
    array.add("world");  
    array.add("java");  
    array.add("world");  
    array.add("world");  
    array.add("world");  
    array.add("world");  
    array.add("java");  
    array.add("world");  

    // 创建新集合  
    ArrayList newArray = new ArrayList();  

    // 遍历旧集合,获取得到每一个元素  
    Iterator it = array.iterator();  
    while (it.hasNext()) {  
        String s = (String) it.next();  

        // 拿这个元素到新集合去找，看有没有  
        if (!newArray.contains(s)) {  
            newArray.add(s);  
        }  
    }  

    // 遍历新集合  
    for (int x = 0; x < newArray.size(); x++) {  
        String s = (String) newArray.get(x);  
        System.out.println(s);  
    }  
}

}
[java] view plaincopyprint?
/*
* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 要求：不能创建新的集合，就在以前的集合上做。
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();

    // 添加多个字符串元素(包含内容相同的)  
    array.add("hello");  
    array.add("world");  
    array.add("java");  
    array.add("world");  
    array.add("java");  
    array.add("world");  
    array.add("world");  
    array.add("world");  
    array.add("world");  
    array.add("java");  
    array.add("world");  

    // 由选择排序思想引入，我们就可以通过这种思想做这个题目  
    // 拿0索引的依次和后面的比较，有就把后的干掉  
    // 同理，拿1索引...  
    for (int x = 0; x < array.size() - 1; x++) {  
        for (int y = x + 1; y < array.size(); y++) {  
            if (array.get(x).equals(array.get(y))) {  
                array.remove(y);  
                y--;  
            }  
        }  
    }  

    // 遍历集合  
    Iterator it = array.iterator();  
    while (it.hasNext()) {  
        String s = (String) it.next();  
        System.out.println(s);  
    }  
}

}
B：去除集合中的多个自定义对象的重复元素
分析：比如自定义一个学生类，contains()方法的底层依赖的是equals()方法。
而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法；
Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同；
按照我们自己的需求，比较成员变量的值，重写equals()即可。其他代码就很简单了
C：用LinkedList模拟一个栈数据结构的集合类，并测试
分析：题目的意思是定义一个类用LinkedList实现栈数据结果
栈的特点是先进后出，可以用LinkedList的特有功能addFirst()和removeFirst()来实现
[java] view plaincopyprint?
/**
* 自定义的栈集合
*
*/
public class MyStack {
private LinkedList link;

public MyStack() {  
    link = new LinkedList();  
}  

public void add(Object obj) {  
    link.addFirst(obj);  
}  

public Object get() {  
    // return link.getFirst();  
    return link.removeFirst();  
}  

public boolean isEmpty() {  
    return link.isEmpty();  
}

}
[java] view plaincopyprint?
/*
* MyStack的测试
*/
public class MyStackDemo {
public static void main(String[] args) {
// 创建集合对象
MyStack ms = new MyStack();

    // 添加元素  
    ms.add("hello");  
    ms.add("world");  
    ms.add("java");  

    while(!ms.isEmpty()){  
        System.out.println(ms.get());  
    }  
}

}
D：获取10个1-20之间的随机数，要求不能重复
[java] view plaincopyprint?
/*
* 获取10个1-20之间的随机数，要求不能重复
*
* 用数组实现，但是数组的长度是固定的，长度不好确定。
* 所以我们使用集合实现。
*
* 分析：
* A:创建产生随机数的对象
* B:创建一个存储随机数的集合。
* C:定义一个统计变量。从0开始。
* D:判断统计遍历是否小于10
* 是:先产生一个随机数，判断该随机数在集合中是否存在。
* 如果不存在:就添加，统计变量++。
* 如果存在:就不搭理它。
* 否：不搭理它
* E:遍历集合
*/
public class RandomDemo {
public static void main(String[] args) {
// 创建产生随机数的对象
Random r = new Random();

    // 创建一个存储随机数的集合。  
    ArrayList<Integer> array = new ArrayList<Integer>();  

    // 定义一个统计变量。从0开始。  
    int count = 0;  

    // 判断统计遍历是否小于10  
    while (count < 10) {  
        //先产生一个随机数  
        int number = r.nextInt(20) + 1;  

        //判断该随机数在集合中是否存在。  
        if(!array.contains(number)){  
            //如果不存在:就添加，统计变量++。  
            array.add(number);  
            count++;  
        }  
    }  

    //遍历集合  
    for(Integer i : array){  
        System.out.println(i);  
    }  
}

}

四、集合(Set集合)
(1)Set集合的特点
无序，唯一
(2)HashSet集合
A:底层数据结构是哈希表(是一个元素为链表的数组)
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的
(3)TreeSet集合
A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式
a:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
代码：
[java] view plaincopyprint?
/*
* 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
*/
public class Student implements Comparable {
private String name;
private int age;

public Student() {  
    super();  
}  

public Student(String name, int age) {  
    super();  
    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;  
}  

@Override  
public int compareTo(Student s) {  
    // return 0;  
    // return 1;  
    // return -1;  

    // 这里返回什么，其实应该根据我的排序规则来做  
    // 按照年龄排序,主要条件  
    int num = this.age - s.age;  
    // 次要条件  
    // 年龄相同的时候，还得去看姓名是否也相同  
    // 如果年龄和姓名都相同，才是同一个元素  
    int num2 = num == 0 ? this.name.compareTo(s.name) : num;  
    return num2;  
}

}
b:比较器排序(集合具备比较性)
让集合构造方法接收Comparator的实现类对象
代码：用内部匿名类实现
[java] view plaincopyprint?
// 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
// 而匿名内部类就可以实现这个东西
TreeSet ts = new TreeSet(new Comparator() {
@Override
public int compare(Student s1, Student s2) {
// 姓名长度
int num = s1.getName().length() - s2.getName().length();
// 姓名内容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
: num;
// 年龄
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return num3;
}
});
(4)案例
A:获取无重复的随机数
[java] view plaincopyprint?
/*
* 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
*
* 分析：
* A:创建随机数对象
* B:创建一个HashSet集合
* C:判断集合的长度是不是小于10
* 是：就创建一个随机数添加
* 否：不搭理它
* D:遍历HashSet集合
*/
public class HashSetDemo {
public static void main(String[] args) {
// 创建随机数对象
Random r = new Random();

    // 创建一个Set集合  
    HashSet<Integer> ts = new HashSet<Integer>();  

    // 判断集合的长度是不是小于10  
    while (ts.size() < 10) {  
        int num = r.nextInt(20) + 1;  
        ts.add(num);  
    }  

    // 遍历Set集合  
    for (Integer i : ts) {  
        System.out.println(i);  
    }  
}

}

六、集合(Map集合)
(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值
(2)Map和Collection的区别?
A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
(3)Map接口功能概述
A:添加功能
V put(K key,V value):添加元素
B:删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
C:判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
D:获取功能
Set