集合

一.集合的概念

• 对象的容器，定义对多个对象进行操作的方法。

集合和数组的区别？

• 1.数组长度固定，集合长度不固定（自动申请）。

• 2.数组可以存储基本类型和引用类型，集合只能存储引用类型。

• Java.util.*包中

二.Collection父接口中的常用方法

• boolean add(Object obj)添加一个对象。
• boolean addAll(Collection c)将一个集合中的所有对象添加到此集合中。
• void clear()清空此集合中的所有对象。
• boolean contains(Object o)检查此集合中是否包含o对象
• boolean equals(Object o)比较此集合是否与指定对象相等
• boolean isEmpty()判断此集合是否为空
• boolean remove(Object o)从此集合中移除o对象
• boolean size()返回集合中 的元素个数
• boolean toArray()将此集合转换成数组

遍历集合

//1.增强for
for(Object obj : collection){
	System.out.println(obj);
}
//2.迭代器方法
1.hasNext()有没有下一个元素
2.next()获取下一个元素指针向后移
3.remove()

创建迭代器
Iterator it = collection.iterator();

使用hasNext
while(it.hasNext){
	String s =it.next();
	it.remove();//在迭代器中不能用集合中的remove方法
}

三.List集合

特点：有序，有下标，元素可以重复。
方法：

1.void add(int index,Object o)//在index位置中插入对象o
2.boolean addall(int index,Object 0)//将以个集合中的元素添加到此集合中的index位置。
3.Object get(int index)//返回集合中指定位置的元素
4.set(int index,E element)//用指定元素替换列表中指定位置的元素
5.List subList(int formIndex,int toIndex)//返回formIndex和toIndex之间的集合元素。
List的 迭代器 
listIterator()
方法
add()//将指定元素插入列表
hasNext()
hasPreious()//如何以逆向遍历列表，列表迭代器有多个元素，则返回true
next()
nextIndex()返回对next后续调用所返回元素的索引
provious()返回列表的前一个元素
previousIndex()返回对provious的后续调用所返回元素的索引
remove()
set(E e)用指定元素替换next或previous返回的最后一个元素

简单示例：

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

public class Test {
    public static void main(String[] args){
        Collection collection = new ArrayList();

        //数值类型
        collection.add(32);
        //字符串
        collection.add("YjiaL");
        //浮点型
        collection.add(3.1415926F);
        //布尔类型
        collection.add(false);
        //对象类型
        collection.add(new Test.Student("YjiaLiang",20));

        //遍历打印输出集合元素
        //1.增强for
        for (Object obj: collection) {
            System.out.println(obj);
        }

        //2.迭代器
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
        	//调用next()方法
            System.out.println(iterator.next());
            //在迭代中只能使用迭代器的remove()方法
        }
    }
    static 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 void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

//迭代器从后往前
ListIterator it = list.ListIterator();
while(it.hasPrerious()){
	//把指针重后往前
	System.out.println(it.previousIndex()+":"+it.previous());
}

4.集合

ArrayList

• 数组结构实现，查询快，增删慢，线程不安全

源码分析：

DEFAULT_CAPACITY=10 //默认容量

如果向集合中添加元素 容量0，添加了一个元素后容量为10 .
每次扩容都是原来的1.5倍

Vector

• 数组结构实现，查询快，增删慢；
• JDK1.0版本，运行效率慢，线程安全。

 Vector vector = new Vector();
        vector.add("草莓");
        vector.add("你好");
        vector.add("aa");
        System.out.println("元素个数"+vector.size());

        //遍历
        //使用枚举器
        Enumeration elements = vector.elements();
        while(elements.hasMoreElements()){
            String o = (String)elements.nextElement();
            System.out.println(o);
            elements.
        }
        //4.判断
        System.out.println(vector.contains("你好"));
        System.out.println(vector.isEmpty());
        //Svector方法
        //firsetElement,last

LinkedList

• 链表结构实现 增删快，查询慢。

LinkedList linkedList = new LinkedList();

        linkedList.add("草莓");
        linkedList.add("菠萝");
        linkedList.add("西瓜");
        linkedList.add("银桃");

        System.out.println("元素个数"+linkedList.size());
        linkedList.remove(0);//根据下标和数值来删除
        System.out.println("删除后"+linkedList.toString());

        //isEmpty判断是否为空，如为空会返回true
        if(!linkedList.isEmpty()){
            System.out.println(true);
        }
        //linkedList.clear()清空集合

        //遍历集合
        //1.遍历
        for (int i = 0; i < linkedList.size(); i++) {
            //获取元素的值
            System.out.println(linkedList.get(i));
        }
        //2.增强for
        for (Object obj: linkedList) {
            System.out.println(obj);
        }
        //3.list迭代器实现遍历
        ListIterator listIterator = linkedList.listIterator();
        while(listIterator.hasNext()){
           System.out.println(listIterator.next());