List集合

List集合

List的三个子类的特点

• List：数组元素有序，允许元素重复，选择哪种集合，根据自己的需求而定
• 要安全还是要效率，是查找多还是增删多
  

ArrayList类

1. boolean add(E e) ：将指定的元素添加到此列表的尾部
2. void add(int index, E element)：将指定的元素插入此列表中的指定位置
3. void clear() ：移除此列表中的所有元素
4. Object clone() ：返回此 ArrayList 实例的浅表副本
5. boolean contains(Object o)：如果此列表中包含指定的元素，则返回 true
6. E get(int index)：返回此列表中指定位置上的元素
7. int indexOf(Object o) ：返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
8. boolean isEmpty() ：如果此列表中没有元素，则返回 true
9. int lastIndexOf(Object o)：返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
10. E remove(int index)：移除此列表中指定位置上的元素
11. boolean remove(Object o) ：移除此列表中首次出现的指定元素（如果存在）
12. protected void removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素
13. E set(int index, E element)：用指定的元素替代此列表中指定位置上的元素13、int size() ：返回此列表中的元素数
14. Object[] toArray()：按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组

  ArrayList arrayList = new ArrayList();
        arrayList.add(20);
        arrayList.add(50);
        arrayList.add(100);
//JDK1.8给ArrayList集合提供了一个内部迭代 
//void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 
arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);

            }
        });
	/*20
	  50
	  100*/	

【案例】去除集合中的重复元素：要求是不能创建新的容器，就在原来的集合当中，去掉重复元素；

import java.util.ArrayList;
import java.util.ListIterator;

public class MyTest1
{
    public static void main(String[] args)
    {
        ArrayList list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(100);
        list.add(200);
        list.add(400);
        list.add(500);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        //方式1-----原理：类似于选择排序
        deleteEle(list);

        //方式2------递归
//遍历获取第一个元素，从索引为0处与索引为最后一位处查找这两个位置是否有同一个元素，相等就说明有重复元素在不同的位置，删除此元素；不相等i加1 再次比较直到找到相等的元素，删除，然后接着递归调用从索引为0处与索引为最后一位处查找这两个位置是否相等
//查找一遍后均没有相同元素就return 退出函数；不可以使用continue因为外层没有循环，for循环已经结束
        ArrayList list1=removeEle(list);
        System.out.println(list1);//[500, 100, 200, 300, 400]
    }

//方式3----- 创建一个新集合
//contains方法判断一个集合是否有此元素，
//contains对于对象的比较底层使用equals比较地址值，因此需要重写equals方法来比较成员变量进而判断两个对象是否相等

        ArrayList<Object> list2 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if (!list2.contains(o)){
                list2.add(o);
            }
        }
        System.out.println(list2);
    }
    private static ArrayList removeEle(ArrayList list)
    {
        for (int i = 0; i < list.size(); i++)
        {
            if(list.indexOf(list.get(i))!=list.lastIndexOf(list.get(i)))
            {
                list.remove(list.get(i));
                removeEle(list);
            }
        }
        return list;
    }

    private static void deleteEle(ArrayList list)
    {
        for (int i = 0; i < list.size()-1; i++)
        {
            for (int j = i+1; j < list.size(); j++)
            {
                if (list.get(i).equals(list.get(j)))
                {
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);//[100, 200, 300, 400, 500]
    }
}

Vector类

Vector集合底层数据结构仍然是数组，因此具有查询快，增删慢的特点，线程安全，效率低，因此一般不常用。以下是它的一些常用的方法：

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

举例：

  Vector vector = new Vector();
        //Vector的遍历
        Enumeration elements=vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }

LinkedList类

底层是链表，查询慢，增删快，线程不安全，效率高.
其实它底层实现了双端队列，可以在队头队尾添加元素。
12
LinkedList类特有功能：
public void addFirst(E e)：添加元素至集合最前面
addLast(E e)：添加元素至集合最后面
public E getFirst()：获取第一个元素
getLast()；获取第二个元素
public E removeFirst()：移除第一个元素
public E removeLast()：移除第二个元素
1234567
  LinkedList linkedList=new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        //检索该列表的第一个元素
        System.out.println(linkedList.peekFirst());//100
        //从这个列表所表示的堆栈中弹出第一个元素。
        System.out.println(linkedList.pop());//100
        System.out.println(linkedList);//[200, 300, 400, 500]
        //检索并移除此列表的第一个元素
        System.out.println(linkedList.pollFirst());//200
        System.out.println(linkedList);//[300, 400, 500]
        //列表头部插入一个元素
        linkedList.push("scq");
        System.out.println(linkedList);//[scq, 300, 400, 500]

小应用：
请用LinkedList模拟栈数据结构的集合，并测试

栈的特点：先进的后出，后进的先出。
        class MyList {

            //私有化只能类内访问
            private LinkedList linkedList;
            public MyList(){
                linkedList = new LinkedList();
            }
            public void add(Object obj){
                linkedList.addFirst(obj);
            }
            //外部通过get方法获取linkedList的元素，返回数据类型使用Object
            //从栈内获取一个元素 栈为先进先出，因此获取先进来的元素，并放到最后一个元素
            public Object get(){
                Object firstelement=linkedList.pop();
                linkedList.addLast(firstelement);//放到最后的位置，保持栈内元素不缺
                return firstelement;
            }
        }