Java学习之路(六)：集合

集合的由来

数组的长度是固定的，当添加的元素超过了数组的长度，就需要对数组重新定义
java内部给我们提供的集合类，能存储任意对象，长度是可以改变的。随着元素的增加而增加，随着元素的减少而减少

数组和集合的区别

数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值
集合只能存储引用数据类型（对象Object），集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象 eg：int==>Integer
数组长度是固定的，不能自动增长
集合的长度是可变的，可以根据元素的增加而增长

如果元素的个数是固定的，我们使用数组

如果元素的个数不固定，我们使用集合

集合Collection类：

list：有序集合，有索引。存与取的顺序一样，可以重复
- ArrayList（数组实现）
- LinkedList（链表实现）
- Vector（数组实现）
Set：无序集合，无索引。存与取的顺序不一样，不可以重复
- HashSet （哈希算法）
- TreeSet（二叉树算法）

ArrayList集合中部分数组实现的原理

　　eg：有个容量为10的初始化数组，当它不够用的时候，就会自动生成一个1.5倍大的数组，将值重新赋值后，把以前的那个小的数组垃圾回收了

Collection的几个基本方法

boolean add（E e）添加一个元素
boolean remove（object o）移除某一个元素
void clear（）清空这个集合
boolean contains（Object o）
boolean isEmpty（）判断这个集合是否为空
int size（）大小
toArray（）将集合转化为数组
boolean addAll(Collection c1) 将c1添加进来
boolean removeAll(Collection c1) 移除this中还有的c1中的所有元素
boolean containsAll(Collection c1) 判断this是否包含有c1中的所有元素
boolean retainAll(Collection c1) 求并集

遍历一个集合，我们使用迭代器

迭代器是用来遍历集合中的每一个元素的

方法：hasNext()和next()

package lesson3;

//这是一个小例子

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class null03 {

    public static void main(String[] args) {

        Collection c1 = new ArrayList();//这不就是多态？

        c1.add("A");

        c1.add("B");

        c1.add("C");

        Iterator iterator = c1.iterator();

        while(iterator.hasNext()){

            Object o = iterator.next();

            System.out.println(o);

        }

    }

}

List集合

void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element)

List可以通过size()和get()方法结合来遍历List集合

package day19_null;

import java.util.ArrayList;

import java.util.List;

public class null01List {

    public static void main(String[] args) {

        List li = new ArrayList();

        li.add("A");

        li.add("B");

        li.add("C");

        li.add("D");

        li.add(0,"E");

        for(int i=0;i<li.size();i++){

            System.out.println(li.get(i));

        }

    }

}

结果：

E

A

B

C

D

这里我们提出一道问题

有一个集合，判断里面有没有“B”这个元素，如果有，就添加一个“b”元素。

当我们使用iterator来遍历的时候，是不能一边遍历一遍添加值的

package day19_null;

//错误的写法

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class null01List {

    public static void main(String[] args) {

        List li = new ArrayList();

        li.add("A");

        li.add("B");

        li.add("C");

        li.add("D");

        li.add(0,"E");

        Iterator iterator = li.iterator();

        while(iterator.hasNext()){

            //System.out.println(iterator.next());

            Object o = iterator.next();

            String o_str = (String)o;

            if(o_str.equals("B")){

                li.add("b");

            }

        }

    }

}

错误的写法

所以呢，我们就要使用ListIterator这个了

boolean hasNext() 是否有下一个
boolean hasPrevious() 是否有前一个
Object next() 下一个元素
Object previous() 上一个元素

对比一下：

package day19_null;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

public class null01List {

    public static void main(String[] args) {

        List li = new ArrayList();

        li.add("A");

        li.add("B");

        li.add("C");

        li.add("D");

        li.add(0,"E");

        ListIterator iterator = li.listIterator();

        while(iterator.hasNext()){

            Object o = iterator.next();

            String o_str = (String)o;

            if(o_str=="B"){

                iterator.add("b");

            }

        }

        while(iterator.hasPrevious()){

            System.out.println(iterator.previous());

        }

    }

}

Vector的使用

vector在JDK1.0版本就已经有了，从v1.2开始，此类改进为可以实现List接口，使他成为Java Collections Framework成员

Vector是同步的，也就是线程是有锁的，是安全的，当然也是效率低的

Vector的特有功能：

public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()0

package day19_null;

import java.util.Enumeration;

import java.util.Vector;

public class null02_vector {

    public static void main(String[] args) {

        //创建一个vector对象

        Vector vec = new Vector();

        vec.addElement("A");

        vec.addElement("B");

        vec.addElement("C");

        vec.addElement("D");

        vec.addElement("E");

        System.out.println(vec.elementAt(0));

        Enumeration enumeration = vec.elements();

        while(enumeration.hasMoreElements()){

            System.out.println(enumeration.nextElement());

        }

    }

}

List的三个子类的特点

ArrayList：

底层数据结构是数组，查询比较块，增删比较慢
线程不安全，所以块

Vector：

底层数据结构是数组，查询比较块，增删比较慢
线程安全，效率较低（相对于ArrayList）

LinkedList：

底层的数据结构是链表，查询慢，增删快
线程不安全，所以快

例子：去除ArrayList中重复的对象

思路：创建一个新的ArrayList，然后借由新创建的ArrayList来进行判断

package day20_nullnull;

import java.util.ArrayList;

import java.util.List;

public class null01_removeSame {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        //TheUsualWayToGetRidOfWeight();

        TheUsualWayToGetRidOfWeightObject();

    }

    /**

     * 如果ArrayList中存在Object

     */

    private static void TheUsualWayToGetRidOfWeightObject() {

        List li = new ArrayList();

        li.add(new Student("null1",1));

        li.add(new Student("null2",2));

        li.add(new Student("null3",3));

        li.add(new Student("null4",4));

        li.add(new Student("null1",1));

        List li2 = new ArrayList();

        for(int i=0;i<li.size();i++){

//            System.out.println(li.get(i));

            if(!li2.contains(li.get(i))){

                li2.add(li.get(i));

            }

        }

        for(int i=0;i<li2.size();i++){

            System.out.println(li2.get(i));

        }

    }

    /**

     * 如果ArrayList中都是String

     */

    private static void TheUsualWayToGetRidOfWeight() {

        //创建一个数组

        List li = new ArrayList();

        li.add("A");

        li.add("B");

        li.add("C");

        li.add("D");

        li.add("A");

        List li2 = new ArrayList();

        for(int i=0;i<li.size();i++){

//            System.out.println(li.get(i));

            if(!li2.contains(li.get(i))){

                li2.add(li.get(i));

            }

        }

        for(int i=0;i<li2.size();i++){

            System.out.println(li2.get(i));

        }

    }

}

class Student{

    String name;

    int age;

    public Student() {

        super();

    }

    public Student(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Student [name=" + name + ", age=" + age + "]";

    }

}

注意：我们会很神奇的发现，当ArrayList中存在Object的时候，居然不行？！！

补充：

　　我们是使用contains来进行判断新的列表是否存在的。但是在contains的内部调用的其实还是equals方法。

　　在String中因为重写了equals方法，所以他是根据String的内容进行判断的

　　但是，在Object判断的却是内存地址。

　　所以，我们要重写class的equals方法。

package day20_nullnull;

import java.util.ArrayList;

import java.util.List;

public class null02 {

    public static void main(String[] args) {

        List li1 = new ArrayList();

        li1.add(new Student2("null1",1));

        li1.add(new Student2("null2",2));

        li1.add(new Student2("null3",3));

        li1.add(new Student2("null4",4));

        li1.add(new Student2("null1",1));

        List li2 = new ArrayList();

        for(int i=0;i<li1.size();i++){

            if(!li2.contains(li1.get(i))){

                li2.add(li1.get(i));

            }

        }

        for(int i=0;i<li2.size();i++){

            System.out.println(li2.get(i));

        }

    }

}

class Student2{

    String name;

    int age;

    public Student2() {

        super();

    }

    public Student2(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Student2 [name=" + name + ", age=" + age + "]";

    }

    @Override

    public boolean equals(Object obj){

        Student2 other = (Student2) obj;

        return this.name.equals(other.name)&&this.age==other.age;

    }

}

OK，没有问题

注意：contains内部调用的还是equals方法

LinkedList的使用

我们现在学了集合中list的两个ArrayList和Vector两个，这两个的底层都是Array数组

接下来的LinkedList的底层是链表

方法：

public void addFirst（E e）以及addLast（E e）
public E getFirst（）以及getLast（）
public E reoveFirst（）以及removeLast（）
public E get（）

使用LinkedList实现栈和队列

栈：先进后出
队列：先进先出

package lesson2;

//栈的模拟

import java.util.LinkedList;

public class null01 {

    public static void main(String[] args) {

        Stack stack = new Stack();

        //进栈

        stack.in("A");

        stack.in("B");

        stack.in("C");

        stack.in("D");

        stack.in("E");

        //出栈

        Object o = stack.out();

        System.out.println(o);

        System.out.println(stack.list);

    }

}

class Stack{

    //栈：先进后出

    LinkedList list = new LinkedList();

    //进栈的方法

    public void in(Object o){

        list.addFirst(o);

    }

    //出栈的方法

    public Object out(){

        return list.removeFirst();

    }

}

队列的模拟和其类似，只不过是相反而已，队列是先进先出的

当然，其实不用写，在LinkedList的内部就已经实现了栈的一系列方法

package lesson2;

import java.util.LinkedList;

public class null02 {

    public static void main(String[] args) {

        //创建一个栈对象

        LinkedList stack = new LinkedList();

        //进栈的方法

        stack.push("A");

        stack.push("B");

        stack.push("C");

        stack.push("D");

        //出栈的方法

        Object o1 = stack.pop();

        System.out.println(o1);

        Object o2 = stack.pop();

        System.out.println(o2);

        Object o3 = stack.pop();

        System.out.println(o3);

        Object o4 = stack.pop();

        System.out.println(o4);

        stack.pop();  //没有了还要弹，就报错了

/**        Exception in thread "main" java.util.NoSuchElementException

            at java.util.LinkedList.removeFirst(Unknown Source)

            at java.util.LinkedList.pop(Unknown Source)

            at lesson2.null02.main(null02.java:26)*/

    }

}

泛性的概述和简单使用

作用：把类型明确的工作推前到创建对象或者调用方法的时候

泛型是一种参数化类型，把类型当做参数一样传递来明确集合的元素类型

好处：

提高安全性
省去了强转的麻烦

基本使用：

声明集合泛型的格式：List<String> list = new ArrayList<String>();
<>中放的必须是引用数据类型