集合——Collection接口,List接口

集合：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

集合和数组的区别：

• 数组长度固定，集合长度不固定
• 数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型。

集合的位置：java.util.*;

Collection体系集合：

Collection父接口：

特点：代表一组任意类型的对象，无序，无下标，不能重复

方法：

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

使用；

package com.java.leetcode.collection;
/*
Collection接口的使用
添加，删除，遍历，判断
 */

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

public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
        //添加
        collection.add("苹果");
        collection.add("香蕉");
        collection.add("梨");
        System.out.println("当前元素个数："+collection.size());
        System.out.println(collection);
        /*
        遍历元素
        1.使用增强for。不能用for，因为collection没有下标。
         */
        System.out.println("********使用增强for********");
        for (Object object:collection) {
            System.out.println(object);
        }
        /*
        2.使用迭代器（专门用来遍历集合的一种方法）
        Iterator是一个接口，没有实现类，通过以下方法实现集合的遍历
        hasNext() 如果仍有元素可以迭代，则返回true
        next() 返回迭代的下一个元素
        remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素
        在迭代器中只能使用迭代器的移除方法，不能用collection的
         */
        System.out.println("********使用迭代器********");
        Iterator iterator =collection.iterator();
        while (iterator.hasNext()){
            String object = (String)iterator.next();
            System.out.println(object);
        }
        System.out.println("是否有苹果？"+collection.contains("苹果"));
        System.out.println("是否有榴莲？"+collection.contains("榴莲"));
        collection.remove("香蕉");
        System.out.println(collection);
        collection.clear();
        System.out.println(collection);
    }
}

运行结果：

List子接口

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

方法：

• void add(int index,Object o)   //在index位置插入对象o
• boolean addAll(int index,Collection c)   //将一个集合中的元素添加到此集合中的index位置
• Object get(int index)   //返回集合中指定位置的元素
• List subList(int fromIndex,int toIndex)   //返回fromIndex和toIndex之间的集合元素。

1.

package com.java.leetcode.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
List子接口
特点：有序，有下标，元素可以重复
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();
        //添加元素
        list.add("苹果");
        list.add("香蕉");
        list.add("榴莲");
        list.add("火龙果");
        list.add("黄桃");
        System.out.println("元素个数"+list.size());
        System.out.println("元素内容："+list.toString());
        //删除元素
        list.remove("苹果");
        list.remove(1); //因为list有下标，可以通过下标删除。苹果删除之后，下标为1的是榴莲
        System.out.println("删除之后："+list.toString());
        //遍历，使用for遍历
        System.out.println("*******使用for循环遍历*******");
        for (int i = 0; i <list.size(); i++) {
            System.out.println(list.get(i));  //此处get返回的是Object类型
        }
        System.out.println("*******使用增强for遍历*******");
        for (Object o:list ) {
            System.out.println(o);
        }
        System.out.println("*******使用迭代器遍历*******");
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        /*
        接口 ListIterator<E>
        方法：
        void add(E e)     //将指定的元素插入列表。
        boolean hasNext() //以正向遍历列表时，如果列表迭代器有多个元素，则返回true。
        boolean hasPrevious //如果以逆向遍历列表，列表迭代器有多个元素，就返回true。
        E next()  //返回列表中的下一个元素
        int nextIndex() //返回对nxt的后续调用所返回元素的索引。
        E previous()    //返回列表的前一个元素
        int PreviousIndex() //返回对previous的后续调用所返回元素的索引
        void remove()  //从列表中移除由next或previous返回的最后一个元素
        void set(E e)  //用指定元素替换next或previous返回的最后一个元素
         */
        System.out.println("*******使用列表迭代器从前往后遍历*******");
        ListIterator lit = list.listIterator();
        while (lit.hasNext()){
            System.out.println("下标"+lit.nextIndex()+":"+lit.next());
        }
        System.out.println("*******使用列表迭代器从后往前遍历*******");
        while (lit.hasPrevious()){  //此时经历上面从前往后的遍历后，指针已经走到了列表的最后
            System.out.println("下标"+lit.previousIndex()+":"+lit.previous());
        }
        //判断 contains
        System.out.println();
        System.out.println("苹果是否存在？"+list.contains("苹果"));
        System.out.println("列表是否为空？"+list.isEmpty());
        //获取位置
        System.out.println("黄桃的位置："+list.indexOf("黄桃"));
    }
}

运行结果：

2.

package com.java.leetcode.collection;

import java.util.ArrayList;
import java.util.List;

public class Demo03 {
    public static void main(String[] args) {
        List list = new ArrayList();
        /*
        添加数字数据(自动装箱)
        集合只能存储引用数据类型，不能存储基本数据类型。
        在向集合添加基本数据类型时，会自动装箱。
        例如list.add(200);  该200已经不是基本数据的int 的200了，而是包装类Integer
         */
        for (int i = 0; i <=100 ; ) {
            list.add(i);
            i = i+10;
        }
        System.out.println("元素个数："+list.size());
        System.out.println("元素内容："+list);
       // list.remove(20);这里会报IndexOutOfBoundsException异常，因为列表大小为11，而这里传入的20 认为是下标
        list.remove((Object)20);
        System.out.println("删除之后："+list);
        list.remove(new Integer(0)); //Integer是包装类，是一个类。
        System.out.println("删除之后："+list);
        //subList,返回子集合,含头不含尾
        List sublist = list.subList(1,5);
        System.out.println(sublist);
    }
}

运行结果

 List实现类：

　　ArrayList;

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

　　Vector:

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

　　LinkedList:

• 链表结构实现，增删快，查询慢
• 是一个双向链表