集合，数据结构，ArrayList,LinkedList,Vector,泛型概述，增强for循环

2020.5.10(集合，数据结构，ArrayList,LinkedList,Vector,泛型概述，增强for循环)

集合

1. 集合和数组的特点：

   • 共同点：都作为容器，存储元素。

   • 不同点：

     • 数组：数组只能存同一种类型的数据，可以存储基本类型和引用类型，创建完成之后长度固定，不可以临时增加或者删除
     • 集合：只能存储引用类型的数据，集合的长度是可以变的。一个集合可以存储各种类型的数据。

2. 集合会将所用的共性向上抽取形成接口

   

• 子类对象实现父类接口，子类会有自己独特的方法

Collection集合

1. 集合层次的根目录，存贮一些元素对象。

2. 方法：

   方法名	返回值类型	功能
   add(E e )	boolean【true添加成功，false添加失败】	给集合容器添加指定元素
   addAll()	boolean【true添加成功，false添加失败】	将指定集合的所有元素添加到此集合中
   remove(object o)	boolean【true删除成功，false无删除】	删除指定的单个元素
   removeAll(Collection c)	boolean【true删除成功，false无删除】	删除此集合中与指定集合所有的交集元素
   size()	int	获取集合中的元素个数
   contains(object o)	boolean【true包含，false不包含】	判断是否包含指定元素
   containsAll(Collection c)	boolean【true包含，false不包含】	此集合包含指定集合中的所有元素
   clear()		清空此集合
   retainAll(Collection c)	boolean【判断此集合的元素是否发生变化，变了true，没变false】	仅保留此集合中包含在指定集合中的元素【仅将此集合与集合c的交集元素存在此集合中】
   toArray()	Object[]数组	将集合元素转换成数组
   iterator	返回此集合中元素的迭代器	创建此集合的迭代器

方法案例：
import java.util.*;

public class MyCollection {
   
    public static void main(String[] args) {
   
        Collection<String> list = new ArrayList<>();
        list.add("我");
        list.add("爱");
        list.add("学");
        list.add("习");
        Collection<Object> list1 = new ArrayList<>();
        list1.add(100);
        list1.add(200);
        list1.add(300);
        list1.add(400);
        
//        判断list是否包含指定字符串
        boolean b = list.contains("学");
        System.out.println(b);
        
//        判读list是否包含list1的所有元素
        boolean b1 = list.containsAll(list1);
        System.out.println(b1);
        
//        将list所有元素添加到list1的集合中
        boolean b3 = list1.addAll(list);
        System.out.println(b3);
      /* list.addAll(list1)
       此处报错，因为集合list的范围
        Required type: Collection<? extends String>   向下限定，只能是String本身或者其子类
        Provided:Collection<Object>*/
        System.out.println("============");
        
        Collection<Object> list2 = new ArrayList<>();
        list2.add(300);
        list2.add(200);
        list2.add(400);
        list2.add(500);
//        判断集合list1中是否包含list2集合的所有元素。
        boolean b2 = list1.containsAll(list2);
        System.out.println(b2);
        System.out.println(list1);
        System.out.println("=========");
        
//        保留list1中与list2交集的元素
        boolean b4 = list1.retainAll(list2);
        System.out.println(b4);
        System.out.println(list1);
        
//       使用迭代器遍历集合
        Iterator<Object> iterator = list1.iterator();
        while (iterator.hasNext()) {
   
            System.out.println(iterator.next());
        }

        System.out.println("===========");
//        list1向下转型成List类型
        List newlist1= (List) list1;
//        使用List中的方法遍历
        for (int i = 0; i < newlist1.size(); i++) {
   
            Object o = newlist1.get(i);
            Integer num= (Integer) o;
            System.out.println(num);
        }
        System.out.println("+++++++++++++");
             
        boolean b5 = list.remove("我");
        System.out.println(b5);
//        集合转换成数组
        Object[] array = list.toArray();
        System.out.println(Arrays.toString(array));
    }
}

List接口

1. List是Collection的子接口，继承了Collection的方法，也有自己独有的方法。
2. 特有的常用方法

方法名	返回值类型	功能
get(index a)	E	返回指定索引的元素
set(index i,E element)	E,返回旧元素	用指定的元素替换此列表中指定位置的元素。
indexOf(Object o);	int， 索引值	查找指定元素第一次出现的索引，返回元素索引
lastIndexOf (Object o)	int ，索引值	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
listIterator()	ListIterator	返回一个迭代器
subList(int fromIndex, int toIndex)	List	返回指定的 fromIndex（含）和 toIndex之间的列表部分

注意：

• List迭代器继承了Collection的迭代器，但是方法丰富了，里面有反向迭代，反向迭代必须要能检测到前面有元素。才能反向开始，因此要配合正向迭代器使用。
• 通过get和set方法可以使用循环遍历和修改元素。

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
//List的常用方法测试
public class MyList {
   
    public static void main(String[] args) {
   
        List<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(2, 500);
        list.add(600);
        System.out.println(list);
//        替换指定位置的元素，返回旧元素
        Integer list1 = list.set(1, 400);
        System.out.println(list1);
        System.out.println(list);
        System.out.println("===========");
//        遍历元素
        for (int i = 0; i < list.size(); i++) {
   
            System.out.println(list.get(i));
        }
        System.out.println("==============");
        ListIterator<Integer> iterator = list.listIterator();
        while (iterator.hasNext()) {
   
            System