集合框架（一）

时间：2017-10-08 10:10:27 阅读：178 评论：0 收藏：0 [点我收藏+]

标签：删除指定元素说明 vector 面向对象语言面向保留链表存储长度

1 集合概述

1.1 为什么出现集合类

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

1.2 数组和集合类同是容器，有什么不同？

数组虽然也可以存储对象，但是长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。

1.3 集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

2 集合的体系及共性

技术分享

添加
- 确保此Collection包含指定的元素。

boolean add(E e)

- 将指定Collection中的所有元素都添加到此Collection中。

boolean addAll(Collection<? extends E> c)

删除
- 从此Collection中移除指定元素的单个示例，如果存在的话。

boolean remove(Object o)

- 移除此Collection中哪些也包含在指定Collection中的所有元素。

boolean removeAll(Collection<?> c)

- 移除此Collection中的所有元素。

void clear()

判断
- 如果此Collection包含指定的元素，则返回true。

boolean contains(Object o)

- 如果此Collection包含指定Collection中的所有元素，则返回true。

boolean containsAll(Collection<?> c)

- 如果此Collection不包含元素，返回true。

boolean isEmpty()

获取
- 返回此Collection中的元素个数

int size()

- 返回在此Collection的元素上进行迭代的迭代器

Iterator<E> iterator()

其他方法
- 仅保留此Collection中哪些也包含在指定Collection的元素，即取交集。

boolean retainAll(Collection<?> c)

- 返回此Collection中所有元素的数组

Object[] toArray()

- 返回此Collection中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

<T> T[] toArray(T[] a)

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

    }

}

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");
        System.out.println(c);

        c.remove("abc");

        System.out.println(c);

    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");
        System.out.println(c);

        c.clear();

        System.out.println(c);
    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");
        System.out.println(c.contains("abc"));


    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

        Collection<Object> c1 = new ArrayList<>();
        c1.add("cde");
        c1.add("def");
        c1.add("efg");

        c.addAll(c1);

        System.out.println(c);


    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

        Collection<Object> c1 = new ArrayList<>();
        c1.add("cde");
        c1.add("def");
        c1.add("efg");

        c.removeAll(c1);

        System.out.println(c);


    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<Object> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

        Collection<Object> c1 = new ArrayList<>();
        c1.add("cde");
        c1.add("def");
        c1.add("efg");

        c.retainAll(c1);

        System.out.println(c);


    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

        Iterator<String> iterator=  c.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

}

技术分享

示例：

package java16;

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

/**
 * 2017/10/7
 * 说明：Collection演示
 */
public class CollectionTest {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();

        c.add("abc");
        c.add("bcd");
        c.add("cde");

        for(Iterator<String> iterator = c.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }
    }
}

3 List和Set的特点

List：有序（存入和取出的顺序一致），元素都有索引（脚标），元素可以重复。
Set：元素不能重复。

4 List集合的常见方法

添加
- 向列表的尾部添加指定的元素

boolean add(E e)

- 在列表的指定位置插入指定的元素

void add(int index,E element)

- 添加指定Collection中的所有元素到此列表的结尾，顺序是指定Collection的迭代器返回这些元素的顺序

boolean addAll(Collection<? extends E> c)

- 将指定的Collection中的所有元素插入到列表的指定位置

boolean addAll(int index,Collection<? extends E> c)

删除
- 从列表中移除所有元素

void clear()

- 移除指定位置上的元素

E remove(int index)

- 从此列表中移除第一次出现的指定元素，如果存在的话

boolean remove(Object o)

- 从列表移除指定Collection中包含的其所有元素

boolean removeAll(Collection<?> c)

判断
- 如果列表包含指定的元素，则返回true

boolean contains(Object o)

- 如果列表包含指定Collection的所有元素，则返回true。

boolean containsAll(Collection<?> c)

- 比较指定的对象与列表是否相等

boolean equals(Object o)

- 如果列表不为空，则返回true

boolean isEmpty()

获取
- 返回列表的元素个数

int size()

- 返回列表指定位置的元素

E get(int index)

- 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，返回-1

int indexOf(Object o)

- 返回此列表中最后出现的指定元素的索引，如果此列表不包含该元素，返回-1

int lastIndexOf(Object o)

- 返回按照适当顺序在列表的元素上进行迭代的迭代器

Iterator<E> iterator()

- 返回此列表元素的列表迭代器

ListIterator<E> listIterator()

- 返回此列表元素的里列表迭代器，从列表的指定位置开始

ListIterator<E> listIterator(int index)

其他方法
- 获取交集

boolean retainAll(Collection<?> c)

- 用指定元素低缓列表中指定位置的元素

E set(int index,E element)

- 返回列表中指定的fromIndex到toIndex之间的集合

List<E> subList(int fromIndex, int toIndex)

- 返回按适当顺序包含列表中的所有元素的数组

Object[] toArray()

- 返回按适当顺序包含列表中的所有元素的数组，返回数组的运行时类型是指定数组的运行时类型

<T> T[] toArray(T[] a)

示例：添加元素

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");
        System.out.println(list);
    }

}

技术分享

示例：插入元素

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");

        //插入元素
        list.add(1,"神经病");

        System.out.println(list);

    }

}

技术分享

示例：按照指定位置删除元素

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");

        //插入元素
        list.add(1,"神经病");

        //删除指定元素
        list.remove(1);


        System.out.println(list);




    }

}

技术分享

示例：修改元素

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");

        //修改元素
        list.set(1,"神经病");

        System.out.println(list);




    }

}

技术分享

示例：根据指定位置获取元素

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        System.out.println(list.get(3));




    }

}

技术分享

示例：获取子列表

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        System.out.println(list.subList(0,2));




    }

}

技术分享

示例：迭代器--遍历List集合

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        for(Iterator<String> iterator = list.iterator();iterator.hasNext();){
           String element = iterator.next();
           System.out.println(element);
        }




    }

}

技术分享

示例：遍历集合

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        for(int x = 0;x<list.size();x++){
            System.out.println(list.get(x));
        }




    }

}

技术分享

示例：验证迭代器不允许并发修改

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        Iterator<String> iterator = list.iterator();

        while(iterator.hasNext()){
            String str = iterator.next();
            if(str.equals("呵呵")){
                list.add("你就是神经病");
            }
            System.out.println(str);

        }




    }

}

技术分享

示例：列表迭代器，允许程序员按任一方向遍历列表，迭代期间修改列表，并获取迭代器在列表中的当前位置。
- ListIterator接口的常用方法：　　
  - 将指定的元素插入列表

void add(E e)

- - 以正向遍历列表时，如果列表迭代器有多个元素，返回true

boolean hasNext()

- - 以逆向遍历列表，列表迭代器有多个元素，返回true

boolean hasPrevious()

- - 返回列表的下一个元素

E next()

- - 返回对next的后续调用所返回元素的索引

int nextIndex()

- - 返回列表的前一个元素

E previous()

- - 返回对previous的后续调用所返回元素的索引

int previousIndex()

- - 从列表移除有next或previous返回的最后一个元素

void remove()

- - 用指定元素替换next或previous返回的最后一个元素

void set(E e)

package java16;

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

/**
 * 2017/10/7
 * 说明：
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("哈哈");
        list.add("呵呵");
        list.add("嘻嘻");
        list.add("笨笨");


        ListIterator<String> iterator = list.listIterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            if(str.equals("呵呵")){
                iterator.add("你就是神经病");
            }
        }
        System.out.println(list);



    }

}