Java 集合

集合概述

集合的由来

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

数组和集合的区别

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

数组和集合什么时候用

如果元素个数是固定的推荐用数组
如果元素个数是不固定的推荐用集合

集合的继承体系图

集合的功能

基本功能

boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
案例演示
add方法如果是List集合一直都返回true，因为List集合中是可以存储重复元素的；如果是Set集合当存储重复元素的时候，就会返回false。
ArrayList的父类的父类重写toString方法，所以在打印对象的引用的时候，输出的结果不是Object类中的toString的结果。

public class test {
    public static void main(String[] args) {
        Collection c=new ArrayList();   //父类引用指向子类对象
        
        boolean b1=c.add("abc");
        boolean b2=c.add(true);    //自动装箱 new boolean（true）
        boolean b3=c.add(100);
        boolean b4=c.add('a');
        boolean b5=c.add("Lily");
        
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        
        System.out.println(c.toString());
        
    }
    
}
输出：
true
true
true
true
true
[abc, true, 100, a, Lily]

import java.util.ArrayList;
import java.util.Collection;
public class test {
    public static void main(String[] args) {
        Collection c=new ArrayList();   //父类引用指向子类对象
        
        c.add("abc");
        c.add(true);    //自动装箱 new boolean（true）
        c.add(100);
        c.add('a');
        c.add("Lily");
        
        System.out.println(c.toString());
        
        Boolean b=c.contains("Lily");  //判断是否包含指定元素
        System.out.println(b);  
        
        int size=c.size();
        System.out.println(size);
        
        c.remove(100);     //删除指定元素
        System.out.println(c.toString());
        
        c.clear();    //清空集合
        System.out.println(c.toString());
        
    }
    
}
输出：
[abc, true, 100, a, Lily]
true
5
[abc, true, a, Lily]
[]

带All的功能

boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

import java.util.ArrayList;
import java.util.Collection;
public class test {
    public static void main(String[] args) {
        Collection c1=new ArrayList();   //父类引用指向子类对象
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2=new ArrayList();
        c2.add("e");
        c2.add("c");
        
        c1.addAll(c2);     //将c2中的每一个元素添加到c1中
        System.out.println(c1);
        
        c1.add(c2);       //将c2看成一个对象添加到c1中
        System.out.println(c1);   
        
        boolean b1=c1.contains(c2);  //判断调用的集合是否包含传入的集合
        System.out.println(b1);
        
        boolean b2=c1.retainAll(c2);   //取交集   如果调用集合改变就返回true，否则返回false
        System.out.println(b2);
        System.out.println(c1);
        
        boolean b3=c1.removeAll(c2);     //删除的是交集
        System.out.println(b3);
        System.out.println(c1);
    }    
}
    
输出：
[a, b, c, d, e, c]
[a, b, c, d, e, c, [e, c]]
true
true
[c, e, c]
true
[]

集合遍历

其实就是依次获取集合中的每一个元素。

集合转换为数组

import java.util.ArrayList;
import java.util.Collection;
public class test {
    public static void main(String[] args) {
        Collection c=new ArrayList();   //父类引用指向子类对象
        
        c.add("a");
        c.add("b");    //自动装箱 new boolean（true）
        c.add("c");
        c.add("d");
        c.add("e");
        
        Object[] arr=c.toArray();  //集合转换为数组
        for(int i=0;i<arr.length;i++)
            System.out.println(arr[i]);
    }
    
}
输出：
a
b
c
d
e

package com.heima.nean;
public class Student {
    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 String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
    
}


package com.heima.collection;
import java.util.ArrayList;
import java.util.Collection;
import com.heima.nean.Student;
public class test {
    public static void main(String[] args) {
        Collection c=new ArrayList();   //父类引用指向子类对象
        
        c.add(new Student("张三",23));
        c.add(new Student("李四",24));
        c.add(new Student("王五",25));
        c.add(new Student("赵六",26));
        
        Object[] arr=c.toArray();  //集合转换为数组
        for(int i=0;i<arr.length;i++){
            Student s=(Student)arr[i];
            System.out.println(s.getName()+"..."+s.getAge());
        }
            
    }    
}
    
输出：
张三...23
李四...24
王五...25
赵六...26

迭代器遍历

1.迭代器概述
集合是用来存储元素的，存储的元素需要查看，那么就需要迭代（遍历）。
2.迭代器原理
迭代器对集合进行遍历，而每一个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样的，那么就需要在每一个类中定义hasNext()和next()方法，这样做是可以的，但是会让整个集合体系过于臃肿，迭代器是将这样的方法向上抽取出接口，然后在这个类的内部，定义自己的迭代方法，这样做的好处有二：第一规定了整个集合体系的遍历方式都是hasNext()和next()方法；第二，代码有底层内部实现，使用者不用管怎么实现的，会用即可。
2.案例演示

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class test {
    public static void main(String[] args) {
        Collection c1=new ArrayList();   //父类引用指向子类对象
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Iterator it=c1.iterator();    //获取迭代器的引用
        while(it.hasNext())            //集合中的迭代方法（遍历）
            System.out.println(it.next());
        
    }    
}
输出：
a
b
c
d

package com.heima.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import com.heima.nean.Student;
public class test {
    public static void main(String[] args) {
        Collection c=new ArrayList();   //父类引用指向子类对象
        
        c.add(new Student("张三",23));
        c.add(new Student("李四",24));
        c.add(new Student("王五",25));
        c.add(new Student("赵六",26));
        
        Iterator i=c.iterator();
        while(i.hasNext()){
            Student s=(Student)i.next();    //向下转型
            System.out.println(s.getName()+"..."+s.getAge());
        }
            
    }    
}
输出：
张三...23
李四...24
王五...25
赵六...26

List集合的特有功能概述和测试

List集合的特有功能概述

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

import java.util.ArrayList;
import java.util.List;
public class test {
    public static void main(String[] args) {
       List list=new ArrayList();
       list.add("a");
       list.add("b");
       list.add("c");
       list.add("d");
       
       list.add(4,"e");    //在索引4处添加元素e
       System.out.println(list);
       
       Object obj1=list.remove(1);    //通过索引删除元素，将被删除的元素返回
       System.out.println(obj1);
       System.out.println(list);
       
       Object obj2=list.get(2);   //获取对应索引的元素
       System.out.println(obj2);
       
       list.set(2, "z");      // 设置对应索引的元素
       System.out.println(list);
    }    
}
输出：
[a, b, c, d, e]
b
[a, c, d, e]
d
[a, c, z, e]

list集合存储学生对象并遍历

通过size()和get()方法结合使用遍历

import java.util.ArrayList;
import java.util.List;
import com.heima.nean.Student;
public class test {
    public static void main(String[] args) {
       List list=new ArrayList();
       
       list.add(new Student("张三",23));  //Object obj=new Student("张三)，23
       list.add(new Student("李四",24));
       list.add(new Student("王五",25));
       list.add(new Student("赵六",26));
       
       for(int i=0;i<list.size();i++){
           Student s=(Student)list.get(i);     //向下转型
           System.out.println(s.getName()+"..."+s.getAge());
       }
    }    
}
输出：
张三...23
李四...24
王五...25
赵六...26

并发修改异常

迭代器遍历，集合修改集合

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class test {
    public static void main(String[] args) {
       List list=new ArrayList();
       
       list.add("a");   //Object obj=new String()
       list.add("b");
       list.add("world");
       list.add("d");
       
       Iterator i=list.iterator();  //获取迭代器
       while(i.hasNext()){             //判断集合中是否有元素
           String  str= (String)i.next();   //向下转型
           if(str=="world")
               list.add("Javaee");   //遍历的同时在增加元素，并发修改ConcurrentModificationException
       }
       System.out.println(list);
    }    
}

解决方案
1.迭代器迭代元素，迭代器修改元素（ListIterator的特有功能add）
2.集合遍历元素，集合修改元素

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class test {
    public static void main(String[] args) {
       List list=new ArrayList();
       
       list.add("a");   //Object obj=new String()
       list.add("b");
       list.add("world");
       list.add("d");
       
       ListIterator lit=list.listIterator();  //获取迭代器（List集合特有的）
       while(lit.hasNext()){             //判断集合中是否有元素
           String  str= (String)lit.next();   //向下转型
           if(str=="world")
               lit.add("Javaee");   //遍历的同时在增加元素，可以用ListIterator中的add方法
       }
       System.out.println(list);
    }    
}
输出：
[a, b, world, Javaee, d]

ListIterator中的方法

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

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class test {
    public static void main(String[] args) {
       List list=new ArrayList();
       
       list.add("a");   //Object obj=new String()
       list.add("b");
       list.add("world");
       list.add("d");
       
       ListIterator lit=list.listIterator();  //获取迭代器（List集合特有的）
       while(lit.hasNext()){             //判断集合中是否有元素
          System.out.println(lit.next());
       }
       System.out.println("--------------------------");
       while(lit.hasPrevious())
           System.out.println(lit.previous());
       
    }    
}
输出：
a
b
world
d
--------------------------
d
world
b
a

Vector类的特有功能

public void addElement(E obj)
public E elementAt(int index)
public Enumeration element()
案例演示

import java.util.Enumeration;
import java.util.Vector;
public class test {
    public static void main(String[] args) {
       
        Vector v=new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");
        
        Enumeration en=v.elements();   //获取枚举
        while(en.hasMoreElements())     //判断集合中是否有元素
            System.out.println(en.nextElement());  //获取集合中的元素
       
    }    
}
输出：
a
b
c
d

List的三个子类的特点

ArrayList：底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
Vector：底层数据结构是数组，查询快，增删慢。线程安全，效率低。
LinkedList：底层数据结构是链表，查询慢，增删快。线程不安全，效率高。
查询多用ArrayList
增删多用LinkedList
如果都多用ArrayList