11集合(Collection<E>) Arraylist

是一个长度可变且可以存储多个数(对象)据的容器

Collection<E>是集合的顶级接口

<E>是泛型  用于指定集合元素的数据类型，由于我们泛型的指定所以只能是引用类型

int[] arr;arr的数据类型是数组类型,arr的元素是int类型

Collection<String>c; c的数据类型是引用类型，c中的元素是String类型。

集合存储基本类型数据 1 2 4 可以自动封装成包装类 Integer in=1; in可以存储在集合中

1.Collection<E>是集合的顶级接口

        //创建集合对象
        Collection<String> c=new ArrayList<String>();
        //添加元素
        c.add("徐");
        c.add("love");
        c.add("李");
        //输出集合
        System.out.println(c); //[徐, love, 李]
        //删除元素
        c.remove("李");
        //没有要删除的元素就什么都不做
        c.remove("火");
        System.out.println(c); //[徐, love]
         //清空集合
        //c.clear();
        //判断元素是否包含在集合元素中
        System.out.println(c.contains("徐")); //true
        //判断集合中元素是否为空
        System.out.println(c.isEmpty());
        //集合元素的个数
        System.out.println(c.size());
        //返回包含此集合中所有元素的数组。返回类型是object、
        Object[] os=c.toArray();
        //在转换的过程中指明要转换的数组元素的类型
        String[] ss=c.toArray(new String[2]);

我们要谈collection下的三个子接口 list set queue

2.List(列表)是一个接口，需要实现类来实现

特征:1.存入数据有序 2.可以根据下标操作添加元素3.可以存储我们重复元素

        //创建list集合对象
        List<String> l=new ArrayList<String>();
        //添加元素
        l.add("a");
        l.add("a3");
        l.add("a2");
        l.add("a02");
        System.out.println(l);//[a, a3, a2, a02]
        //根据下标插入元素
        l.add(3,"b");     
        System.out.println(l);//[a, a3, a2, b, a02]
        //可以根据元素也可以根据下标删除元素
        l.remove(0); 
        System.out.println(l);//[a3, a2, b, a02]
        //根据下标返回元素
        System.out.println(l.get(1)); //a2
        //返回指定元素第一次出现的下标值,如果没找到就返回-1
        System.out.println(l.indexOf("a2")); //1
        l.set(0,"123");//用指定元素替换此列表中指定位置的元素
        System.out.println(l);//[123, a2, b, a02]
        List<String> l2=l.subList(1, 3);
        System.out.println(l2);

实现类:ArrayList,LinkedList,Vector,Stack

(1)ArrayList():有序表底层由数组来实现的，默认数组的初始长度是10，根据底层右移运算进行扩容，每次在原来的基础上扩容一半，可以指定容量

特点：查询速度较高，增删元素效率较低线程不安全集合

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length; //elementData是底层创建的数组
        int newCapacity = oldCapacity + (oldCapacity >> 1); //右移操作是除2
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

//创建list集合对象
        List<String> l=new ArrayList<String>();
        //添加元素
        l.add("a");
        l.add("a3");
        l.add("a2");
        l.add("a02");
        System.out.println(l);//[a, a3, a2, a02]
        //根据下标插入元素
        l.add(3,"b");     
        System.out.println(l);//[a, a3, a2, b, a02]
        //可以根据元素也可以根据下标删除元素
        l.remove(0); 
        System.out.println(l);//[a3, a2, b, a02]
        //根据下标返回元素
        System.out.println(l.get(1)); //a2
        //返回指定元素第一次出现的下标值,如果没找到就返回-1
        System.out.println(l.indexOf("a2")); //1
        l.set(0,"123");//用指定元素替换此列表中指定位置的元素
        System.out.println(l);//[123, a2, b, a02]
        System.out.println(l.subList(1, 3));
        System.out.println(l);

用数组重写ArrayList<String>的方法

public class ListArrays {

    public static void main(String[] args) {
 ListA a=new ListA();
 a.add("adg");
 a.add("g");
 a.add("adu");
 System.out.println(a);
    }

}
class ListA
{
    //存储数据的数组
    String[] data;
    //元素个数以及数组下标
    int size=0;
    //无参构造--默认初始容量为10
    public ListA() {
        data=new String[10];
    }
    //有参构造---指定初始容量
    public ListA(int initCaptity) {
        data=new String[initCaptity];
    }
    //数组扩容
    public void grow() {
        //判断数组原长度是否为1
        if(data.length<=1) //为什么要是1 因为下面1/2还是0等于没扩容
        {
            data=Arrays.copyOf(data, 1);
        }
        //在原来的基础上加上一半
        data=Arrays.copyOf(data, data.length+(data.length>>1));
    }

    //判断下标是否越界
    public void out(int index) {

        if(index<0||index>=size) //下标与元素个数比较
        {
            throw new IllegalArgumentException("index+"+index);
        }
    }

    //添加元素    
    public void add(String str)
    {
        if(size>=data.length)
        {
            grow();
        }
        //往数组里添加元素
        data[size++]=str;

    }

    //插入元素
    public void add(int index,String str)
    {
        //是否需要扩容,保证有足够的空间插入
        if(size>=data.length)
        {
            grow();
        }
        //判断下标是否越界
        if(index<0||index>size) //下标与元素个数比较
        {
            throw new IllegalArgumentException("index+"+index);
        }
        //一次把index后面的数组元素往后赋值
        for(int i=size-1;i>=index;i--)
        {
            data[i+1]=data[i];
        }
        //插入这个元素
        data[index]=str;
        //元素个数增加
        size++;
        //也可以直接将要移动的数组部分往后复制一位。
        //System.arraycopy(data,index,data,index+1,size-index);
    }
    //根据下标删除
    public void remove(int index)
    {
        //判断下标值是否越界
        out(index);
        //依次把index的后面的元素往前移动
        for(int i=index;i<size-1;i++)
        {
            data[i]=data[i+1];
        }
        size--;
        //System.arraycopy(data,index+1,data,index,size-(index+1));

    }
    //根据元素删除
    public void remove(String str) {
        //是否能找到;
        int i=indexOf(str);
        if(i!=-1)
        {
            remove(i);
        }
    }
    //返回元素第一次出现的下标值
    public int indexOf(String str)
    {
        //遍历数组依次比较
        for(int i=0;i<size;i++)//只比元素
        {
            //判断是否相等
            if(data[i]==str||data[i]!=null&&data[i].equals(str))
            {
                //返回找的到的元素下标
                return i;
            }

        }
        //数组中没有出现
        return -1;
    }
    //清空集合
    public  void  clear() {
        size=0;    
    }
    //判断是否包含元素
    public boolean contains(String str)
    {
        return(indexOf(str)!=-1);
    }
    //判断集合是否为空
    public boolean isEmpty() {
        return size==0;
    }
    //替换元素
    public void set(int index,String str)
    {//判断是否越界
        out(index);
        //替换
        data[index]=str;
    }
    //返回元素个数
    public int size() {
        return size;
    }
    //截取子列表
    public ListA subList(int fromIndex,int toIndex) {
        //是否越界
        out(fromIndex);
        out(toIndex);
        //判断下标大小是否正确
        if(toIndex<fromIndex) {
            throw new IllegalArgumentException("FromIndex"+fromIndex+"ToIndex"+toIndex);

        }
        //新建列表
        //指定新列表长度
        int count=toIndex-fromIndex;
        ListA list=new ListA(count);
        //拷贝元素
        System.arraycopy(data, fromIndex, list.data, 0, count);
        //赋值size -----把复制的元素个数赋值给新列表的size
        list.size=count;
        //返回新列表
        return list;

    }
    //重写ToString()
    @Override
    public String toString() {
        //创建StringBuilder的对象
        StringBuilder sb=new StringBuilder("[");
        //拼接字符串数组中的元素
        for(int i=0;i<size;i++)
        {
            sb.append(data[i]).append(", ");
        }
        //转成字符串
        String s=sb.toString();
        //截取字串 ---后面的, 不要了
        if(size>0) //只有在字符串中有元素
        s=s.substring(0,s.length()-2);
        return s+="]";
    }
    
}