java学习笔记 集合

一，集合
1.集合和数组的区别
数组长度是固定的，集合长度是可变的；数组中可以窜出基本数据类型，集合只能存储对象；数组中存储数据类型是单一的，集合中可以存储任意类型的对象。
2.集合框架体系

List：有序存储，可重复
——ArrayList：数组实现，查找块，增删慢
——LinkedList：链表实现，增删块，查找慢
——Vector：和ArrayList原理相同，但线程安全，效率略低
Set：无存储顺序，不可重复
——HashSet：按Hash算法存储集合中的元素，有很好的存取和查找性能，不同步
——LinkedHashSet：根据元素的hashCode决定元素存储位置，同时使用链表维护元素的次序，按照元素添加顺序访问集合元素
——TreeSet：采用红黑树的数据结构存储集合元素，根据元素实际值的大小进行排序
——EnumSet：以枚举值在Enum类内的定义顺序决定集合元素的顺序，在内部以位向量的形式存储
3.总结，什么时候该使用什么样的集合
List：我们需要存储顺序，并且保留重复元素；如果查询较多，使用ArrayList；如果存取较多，使用LinkedList；如果需要线程安全，使用Vector
Set：不需要保留存储顺序，并且需要去掉重复元素；如果需要将元素排序，使用TreeSet；如果不需要排序，使用HashSet，HashSet比TreeSet效率高；如果需要保留存储顺序，又要过滤重复元素，使用LinkedHashSet

二，集合类
1.Collection接口共性方法

package Collection;
import java.util.*;

public class CollectionTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//      增加，输出
//      [Spring, Summer, Autumn]
//      [Winter, Spring, Summer, Autumn, January]   
        Collection list=new ArrayList();
        list.add("Spring");
        list.add("Summer");
        list.add("Autumn");
        System.out.println(list);

        Collection list2=new ArrayList();
        list2.add("Winter");
        list2.addAll(list);
        list2.add("January");
        System.out.println(list2);

//      删除，输出
//      true
//      [Winter, Spring, Summer, Autumn]
//      true
//      [Winter]
        boolean remove=list2.remove("January");
        System.out.println(remove);
        System.out.println(list2);

        boolean removeAll=list2.removeAll(list);
        System.out.println(removeAll);
        System.out.println(list2);

//      修改
//      [Winter, Spring, Summer, Autumn, January]
//      []
        System.out.println(list2);
        list2.clear();
        System.out.println(list2);

//      判断
//      false
//      true
        boolean empty=list.isEmpty();
        System.out.println(empty);
        Boolean contains=list2.contains("January");
        System.out.println(contains);

//      获取长度
        System.out.println(list2.size());

    }

}

注意：以上代码时对增加、删除、修改、判断和获取等方法的示例，实际运行时需要注释掉部分代码。

2.List
判断两个对象相等，只要通过equals方法比较返回true即可
如下代码，仅以增加作为示例

package Collection;
import java.util.*;
/*
 * list集合特有的方法
 * 1.增加：void add(int index,E element)指定位置添加元素
 *       boolean addAll(int index,Collection c)指定位置添加集合
 * 2.删除：E remove(int index)删除至东京位置元素
 * 3.修改：E set(int index,E element)返回的是要替换的集合中的元素
 * 4.查找：E get(int index)
 *      int indexOf(Object o) 找不到返回-1
 *      lastIndexOf(Object o)
 * 5.求子集合：List<E> subList(int fromIndex, int toIndex)不包含toIndex
 */
public class ListTest {
    public static void main(String [] args){
        List list=new ArrayList();
        list.add("Spring");
        list.add("Summer");
        list.add("Autumn");

        System.out.println(list);//[Spring, Summer, Autumn]

        list.add(0,"Winter");
        System.out.println(list);//[Winter, Spring, Summer, Autumn]

        List list2=new ArrayList();
        list2.add("January");
        list2.add("February");
        list2.add("March");
        System.out.println(list2);//[January, February, March]
        boolean addAll=list2.addAll(1,list);
        System.out.println(addAll);//true
//      [January, Winter, Spring, Summer, Autumn, February, March]
        System.out.println(list2);
    }

}

3.ArrayList：数组实现，查找快，增删慢
数组的内存空间地址是连续的，ArrayList底层维护了一个Object[]用于存储对象，默认数组长度是10，可以通过new ArrayList(20)显式指定用于存储对象的数组的长度。数组可以直接按索引查找，所以较快；在增删时会牵扯到数组增容以及拷贝元素，所以慢。
Eg：去除ArrayList集合中重复元素
注意：自定义对象要进行复写toString和equals方法，因为Object是Person的父类，Object中toString返回的是哈希值，equals比较的是对象的地址值
原理：循环遍历该集合，每取出一个放置在行的集合中，放置之前先判断新集合是否已经包含了新的元素

package Collection;
import java.util.*;

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode() + age * 37;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;

        return this.name.equals(p.name) && this.age == p.age;
    }

    @Override
    public String toString() {
        return "Person@name:" + this.name + " age:" + this.age;
    }

}

public class ArrayListTest {
    public static void main(String [] args){
        ArrayList arr = new ArrayList();
        Person p1 = new Person("jack", 20);
        Person p2 = new Person("rose", 18);
        Person p3 = new Person("rose", 18);
        arr.add(p1);
        arr.add(p2);
        arr.add(p3);
        System.out.println(arr);

        ArrayList arr2 = new ArrayList();
        for(int i=0;i<arr.size();i++){
            Object obj=arr.get(i);
            Person p=(Person)obj;
            if(!(arr2.contains(p))){
                arr2.add(p);
            }
        }
        System.out.println(arr2);

    }

}

4.LinkedList：链表实现，增删块，查找慢

package Collection;
import java.util.*;
/*
 * 特有的方法
 * addFirst(E e) addLast(E e) getFirst() getLast() 
 * removeFirst() removeLast() 
 * 如果集合中没有元素，获取或者删除元素会抛出异常NoSuchElementException
 * 数据结构
 * 栈：先进后出push() pop()
 * 队列：先进先出offer() poll()
 * descendingIterator()   返回逆序的迭代器对象
 */
public class LinkedListTest {
    public static void main(String [] args){
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        list.addFirst("史记");
        list.addLast("呐喊");
        // list.addFirst(null);
        // list.addLast(null);
        System.out.println(list);
        // 获取指定位置处的元素。
        String str = (String) list.get(0);
        System.out.println(str);
        // 返回此列表的第一个元素。
        String str2 = (String) list.getFirst();
        System.out.println(str2);
        System.out.println(str.equals(str2));

        // 获取指定位置处的元素。
        String str3 = (String) list.get(list.size() - 1);
        // 返回此列表的最后一个元素。
        String str4 = (String) list.getLast();
        System.out.println(str3.equals(str4));

        // 获取但不移除此列表的头（第一个元素）。
        Object element = list.element();
        System.out.println(element);

        int size = list.size();
        System.out.println(size);

    }
}
/*
[史记, 西游记, 三国演义, 石头记, 水浒传, 全球通史, 呐喊]
史记
史记
true
true
史记
7
*/

练习：使用集合模拟队列（先进先出）或者堆栈（后进先出）数据结构，以堆栈为例

package Collection;
import java.util.*;

public class ZhanTest {
    public static void main(String [] args){
        LinkedList list = new LinkedList();
        // 压栈，先进后出
        list.push("西游记");
        list.push("三国演义");
        list.push("石头记");
        list.push("水浒传");
        System.out.println(list);
        // 弹栈
        String str1 = (String) list.pop();
        System.out.println(str1);
        String str2 = (String) list.pop();
        System.out.println(str2);
        String str3 = (String) list.pop();
        System.out.println(str3);
        String str4 = (String) list.pop();
        System.out.println(str4);
        System.out.println(list.size());// 0
        System.out.println(list); //[]

    }
}
/*
[水浒传, 石头记, 三国演义, 西游记]
水浒传
石头记
三国演义
西游记
0
[]
*/

5.Vector：描述的是一个线程安全的ArrayList

package Collection;
import java.util.*;

public class VectorTest {
    public static void main(String [] args){
        Vector v = new Vector();
        v.addElement("aaa");
        v.addElement("bbb");
        v.addElement("ccc");
        System.out.println( v );
        System.out.println( v.elementAt(2) );   // ccc
        // 遍历Vector遍历
        Enumeration ens = v.elements();
        while ( ens.hasMoreElements() )
        {
            System.out.println( ens.nextElement() );
        }   

    }
}
/*
[aaa, bbb, ccc]
ccc
aaa
bbb
ccc
 */

6.Set：用于存储无序（存入和取出的顺序不一定相同）元素，值不能重复
如果想要两个不同的Person对象视为相等的，必须覆盖Object继承下来的hashCode方法和equals方法。
判断两个元素相等的标准是，两个对象通过equals方法比较相等且hashCode返回值也相等。

7.HashSet：Set接口的典型实现，不能保证元素的排列顺序，不是同步的，线程不安全，存取速度快
HashSet存储元素的顺序并不是按照存入时的顺序，是按照哈希值来存的，所以取数据也是按照哈希值取的。

HashSet不能存入重复元素，那么HashSet如何检查重复？
当你试图把对象加入HashSet时，HashSet会使用对象的hashCode来判断对象加入的位置。同时也会与其他已经加入的对象的hashCode进行比较，如果没有相等的hashCode，HashSet就会假设对象没有重复出现。简单一句话，如果对象的hashCode值是不同的，那么HashSet会认为对象是不可能相等的。因此我们自定义类的时候需要重写hashCode，来确保对象具有相同的hashCode值。如果元素(对象)的hashCode值相同,是不是就无法存入HashSet中了? 当然不是,会继续使用equals 进行比较.如果 equals为true 那么HashSet认为新加入的对象重复了,所以加入失败。如果equals 为false那么HashSet 认为新加入的对象没有重复.新元素可以存入.

总结概括起来就是：元素的哈希值是通过元素的hashcode方法 来获取的, HashSet首先判断两个元素的哈希值，如果哈希值一样，接着会比较equals方法 如果 equls结果为true ，HashSet就视为同一个元素。如果equals 为false就不是同一个元素。

8.LinkedHashSet
HashSet的一个子类，根据元素的hashCode来决定元素的存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里的元素时，LinkedHashSet会按元素的添加顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能，因为它以链表来维护内部顺序。

package Collection;
import java.util.*;

public class LinkedHashSetTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedHashSet books = new LinkedHashSet();
books.add("疯狂Java讲义");
books.add("Spring实战");
System.out.println(books);
// 删除 疯狂Java讲义
books.remove("疯狂Java讲义");
// 重新添加 疯狂Java讲义
books.add("疯狂Java讲义");
System.out.println(books);
}
}
/*
[疯狂Java讲义, Spring实战]
[Spring实战, 疯狂Java讲义]
 */

9.TreeSet:采用红黑树的数据结构存储集合元素，根据元素实际值的大小进行排序

package Collection;
import java.util.*;

public class TreeSetTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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]
    }
}
/*
[-9, 2, 5, 10]
-9
10
[-9, 2]
[5, 10]
[2]
 */

TreeSet支持两种排序方法：自然排序和定制排序，默认情况下，采用自然排序。
（1）自然排序，元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法，集合元素按照升序排序。这也就是为什么TreeSet存入字符串时，字符串默认输出是按升序排列的，因为字符串实现了Comparable接口并重写了compareTo方法，所以String对象具备了比较性。

package test;
import java.util.*;

class Person implements Comparable{
    private String name;
    private int age;
    private String gender;

    public Person() {
    }

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int hashCode() {
        return name.hashCode() + age * 37;
    }

    public boolean equals(Object obj) {
        System.err.println(this + "equals :" + obj);
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;
        return this.name.equals(p.name) && this.age == p.age;

    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", gender=" + gender
                + "]";
    }

    public int compareTo(Object obj) {

        Person p = (Person) obj;
        System.out.println(this+" compareTo:"+p);
        if (this.age > p.age) {
            return 1;
        }
        if (this.age < p.age) {
            return -1;
        }
        return this.name.compareTo(p.name);
    }
}
public class TreeSetTest{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeSet ts = new TreeSet();
        ts.add(new Person("aa", 20, "男"));
        ts.add(new Person("bb", 18, "女"));
        ts.add(new Person("cc", 17, "男"));
        ts.add(new Person("dd", 17, "女"));
        ts.add(new Person("dd", 15, "女"));
        ts.add(new Person("dd", 15, "女"));


        System.out.println(ts);
        System.out.println(ts.size()); // 5
    }

}

（2）定制排序，当元素自身不具备比较性，或者元素吱声比较性不是所需的时候，使用定制排序。定义一个类实现Comparator接口，覆盖compare方法，并将该接口的子类对象作为参数传递给TreeSet集合的构造函数。由于Comparator是一个函数式接口，因此可以用Lambda表达式代替Comparator对象。

package Collection;
import java.util.*;

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);
    }
}
/*
[M[age:9], M[age:5], M[age:-3]]
*/

小练习：将字符串中的数值进行排序，可以使用TreeSet完成，因为TreeSet自身具备排序功能。

package Collection;
import java.util.*;

public class TreeSetEx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "8 10 15 5 2 7";
        String[] strs = str.split(" ");
        TreeSet ts = new TreeSet();
        for (int x = 0; x < strs.length; x++) {
            int y = Integer.parseInt(strs[x]);
            ts.add(y);
        }
        System.out.println(ts);
    }

}
/*
[2, 5, 7, 8, 10, 15]
*/

三，迭代器
为了方便处理集合中的元素，Java中出现了一个对象，该对象提供了一些方法专门处理集合中的元素，例如删除和获取集合中的元素，该对象就叫做迭代器（Iterator）。
1.Iterable
jdk1.5之后添加的新接口，Collection的父接口，实现了Iterable的类就是可迭代的，并支持增强for循环。该接口只有一个方法即获取迭代器的方法iterable()，可以获取每个容器自身的迭代器Iterator。
2.Iterator
Iterator主要用于遍历（即迭代访问）Collection集合中的元素，该接口隐藏了各种Collection实现类的底层细节，向应用程序提供了遍历Collection集合元素的同一编程接口，Iterator接口定义了如下4个方法：
boolean hasNext(): 如果被迭代的集合元素还没有被遍历完，返回true
Object next(): 返回集合里的下一个元素
void remove(): 删除集合里上一次next方法返回的元素
void forEachRemaining(Consumer action): java8为Iterator新增的默认方法，该方法可使用Lambda表达式遍历集合元素
3.迭代器遍历的几个例子

while循环遍历集合

package Collection;
import java.util.*;
/*
 * while循环
 */
public class IteratorWhile {
    public static void main(String []args){
        ArrayList list=new ArrayList();

        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        Iterator it=list.iterator();
        while(it.hasNext()){
            String next=(String)it.next();
            System.out.println(next);
        }
    }
}
/*
[计算机网络, 现代操作系统, java编程思想, java核心技术, java语言程序设计]
计算机网络
现代操作系统
java编程思想
java核心技术
java语言程序设计
 */

利用for循环遍历集合

package Collection;
import java.util.*;
/*
 * for循环
 * 需要去除全部元素时，可以通过循环，java建议使用for循环，因为可以对内存进行一下优化
 */
public class IteratorWhile {
    public static void main(String []args){
        ArrayList list=new ArrayList();

        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        for(Iterator it=list.iterator();it.hasNext();){
            String next=(String)it.next();
            System.out.println(next);
        }
    }
}
/*
[计算机网络, 现代操作系统, java编程思想, java核心技术, java语言程序设计]
计算机网络
现代操作系统
java编程思想
java核心技术
java语言程序设计
 */

使用迭代器清空集合，注意两个细节：
（1）如果迭代器的指针已经指向了集合的末尾，那么如果再调用next()会返回NoSuchElementException异常
（2）如果调用remove之前没有调用next是不合法的，会抛出IllegalStateException异常，remove方法会返回上次调用next方法时返回的元素，如果想要删除指定位置上的元素，需要越过这个元素，例如，下面是如何删除字符串集合中第一个元素的方法

Iterator<String> it=c.iterator();
it.next();
it.remove();

如果想要删除两个相邻的元素，不能直接这样

it.remove();
it.remove();//Error!

相反的，必须先调用next越过将要删除的元素

it.remove();
it.next();
it.remove();

使用一张图可能会更好地理解

package Collection;
import java.util.*;

public class IteratorTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList list=new ArrayList();
        list.add("Spring");
        list.add("Summer");
        list.add("Autumn");
        list.add("Winter");
        System.out.println(list);

        Iterator it=list.iterator();
        while(it.hasNext()){
            it.next();
            it.remove();
        }
        System.out.println(list);

//      String next=(String)it.next();
//      System.out.println(next);

//      while(it.hasNext()){
//          String next2=(String)it.next();
//          System.out.println(next2);
//      }
    }

}

4.List特有的迭代器ListIterator
如果是List集合，想要在迭代中操作元素可以使用List集合特有的迭代器ListIterator，该迭代器支持在迭代过程中，添加元素和修改元素。

package Collection;
import java.util.*;
/*
 * 特有的方法
 * add 将制定的元素插入列表，该元素直接插入到next返回的下一个元素的前面
 * set 用制定元素替换next或previous返回的最后一个元素
 * hasPrevious 逆向遍历列表
 * previous 返回列表的前一个元素
 */
public class LinkedListTest {
    public static void main(String [] args){
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");

        System.out.println(list);

        ListIterator lit=list.listIterator();
        while(lit.hasNext()){
            String next=(String)lit.next();
            System.out.println(next);
        }

        while(lit.hasPrevious()){//倒序遍历
            String previous=(String)lit.previous();
            System.out.println(previous);
        }

        System.out.println(list);
        lit.next();
        lit.next();
        System.out.println(lit.next());
        lit.add("平凡的世界");
        //add方法将指定元素插入 列表，该元素直接插入到next返回的元素后面
        System.out.println(list);
    }
}
/*
[西游记, 三国演义, 石头记, 水浒传]
西游记
三国演义
石头记
水浒传
水浒传
石头记
三国演义
西游记
[西游记, 三国演义, 石头记, 水浒传]
石头记
[西游记, 三国演义, 石头记, 平凡的世界, 水浒传]
*/

集合未完……