java集合容器

       java中集合是一种容器，数组也是一种容器，数组作为容器优势就是效率比较高，而数组本身却不够灵活。数组的容量需要事先定义好，这就不能随着需求的变化而扩容。比如：我们在一个用户管理系统中，需要把今天注册的所有用户取出来，那么这样的用户有多少个?我们在写程序时是无法确定的。这种情况就不能用数组，因而引进集合容器。

Collection接口：一个独立的元素序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，而Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序（通常与它们插入的顺序相同）

集合的体系：

 Collection ：单例集合的根接口
 List：如果是实现了List接口的集合类，具备的特点： 有序，可重复。
 ArrayList：  ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。
LinkedList： LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度慢，增删快。
Vector： 底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。

Set：  如果是实现了Set接口的集合类，具备的特点： 无序，不可重复。
HashSet：底层是使用了哈希表来支持的，特点： 存取速度快.

hashSet的实现原理：
往Haset添加元素的时候，HashSet会先调用元素的hashCode方法得到元素的哈希值，
然后通过元素的哈希值经过移位等运算，就可以算出该元素在哈希表中的存储位置。

情况1： 如果算出元素存储的位置目前没有任何元素存储，那么该元素可以直接存储到该位置上。

情况2： 如果算出该元素的存储位置目前已经存在有其他的元素了，那么会调用该元素的equals方法与该位置的元素再比较一次
，如果equals返回的是true，那么该元素与这个位置上的元素就视为重复元素，不允许添加，如果equals方法返回的是false，那么该元素运行 添加。

 TreeSet 如果元素具备自然顺序 的特性，那么就按照元素自然顺序的特性进行排序存储。

参考：https://blog.csdn.net/qq_38341596/article/details/78749629

Collection方法：

示例：

package jihe;
/**
 * 简单Collection示例
 * @author Gsan
 */

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

public class SimpleCollection {
    public static void main(String[] args){
        Collection<Integer> c=new ArrayList<>();
        for(int i=0;i<10;i++)
            c.add(i);
            for(Integer i:c){//需用foreach遍历输出
                System.out.println(i+",");
            }
    }
}

 运行结果：

package jihe;

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

/**
 * 测试Collection接口中的方法
 * author Gsan
 */
public class TestList {
    public static void main(String[] args){

        test01();
        test02();
        test03();
    }
    public static void test01(){
        Collection<String> c=new ArrayList<>();

        System.out.println(c.size());//Collection长度
        System.out.println(c.isEmpty());//判断Collection是否为空

        //添加内容
        c.add("老谭");
        c.add("小谭");
        System.out.println(c);
        System.out.println(c.size());

        System.out.println(c.contains("小小谭"));//判断Collection中是否包含“小小谭”

        Object[] objs=c.toArray();//转化出一个Object数组
        System.out.println(objs);

        c.remove("小谭");
        System.out.println(c);

        c.clear();//移除所有元素
        System.out.println(c.size());
    }

    public static void test02(){
        List<String> list01=new ArrayList<>();
        list01.add("aa");
        list01.add("bb");
        list01.add("cc");
        System.out.println("list01:"+list01);

        List<String> list02=new ArrayList<>();
        list02.add("dd");
        list02.add("ee");
        list02.add("aa");
        System.out.println("list02:"+list02);

//        // 取交集
//        list01.retainAll(list02);
//        System.out.println("list03:"+list01);

        //list02加进list01
        list01.addAll(list02);
        System.out.println("list01:"+list01);

        //list01里除去list02
        list01.removeAll(list02);
        System.out.println("list01:"+list01);

        //判断list01是否包含全部list02元素
        System.out.println(list01.retainAll(list02));
    }

    public static void test03(){
        List<String> list=new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        System.out.println(list);

        list.add(2,"老谭");//第二个位置插入元素
        System.out.println(list);

        list.remove(2);//删除第二个元素
        System.out.println(list);

        list.set(2,"老谭");//第二个位置设置“老谭”元素，代替原来第二个位置元素
        System.out.println(list);

        System.out.println(list.get(2));//获取第二个元素

        list.add("C");
        list.add("B");
        list.add("A");
        System.out.println(list);
        System.out.println(list.indexOf("B"));//从左到右第一次出现的位置
        System.out.println(list.lastIndexOf("B"));//从左到右最后一次出现的位置
    }
}

运行结果：

ArrayList常用方法演示：

package jihe;

/**
 * ArrayList方法演示
 * @author Gsan
 * @param <E>
 */
public class TestArrayList <E>{
    private Object[] elementData;
    private int size;

    private static final int DEFALT_CAPACITY=10;

    //无参构造方法
    public TestArrayList(){
        elementData=new Object[DEFALT_CAPACITY];
    }

    //带参构造方法
    public TestArrayList(int acpacity){
        if (acpacity<0){
            throw new RuntimeException("容器的容量不能为负数");
        }else if (acpacity==0){
            elementData=new Object[DEFALT_CAPACITY];
        }else if (acpacity>0){
            elementData=new Object[acpacity];
        }
    }

    public void add(E e){

        //何时扩容
        if(size==elementData.length){
            //扩容
            Object[] newarray=new Object[elementData.length+(elementData.length>>1)];//10+10/2
            elementData=newarray;
        }
        elementData[size++]=e;//依次加入数组
    }

    //检查索引，防止数据溢出
    public E get(int index){
        checkRange(index);
        return (E)elementData[index];
    }

    public void set(E element,int index){
        checkRange(index);
        elementData[index]=element;

    }

    //索引的合法判断
    public void checkRange(int index){
        if(index<0||index>size-1){
            throw new RuntimeException("索引不合法"+index);
        }
    }

    //移除方法一，根据元素移除
    public void remove(E element){
        for(int i=0;i<size;i++){
            if(element.equals(get(i))){
                remove(i);
            }
        }
    }

    //移除方法二，根据位置移除
    public void remove(int index){
        int num=elementData.length-index-1;
        if(num>0){
            System.arraycopy(elementData,index+1,elementData,index,num);
            elementData[--size]=null;
        }
    }

    //重写toString输出元素
    @Override
    public String toString() {
        StringBuilder sb= new StringBuilder();
        sb.append("[");
        for (int i=0;i<size;i++){
            sb.append(elementData[i]+",");
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args){
        TestArrayList s1=new TestArrayList();
        s1.add("aa");
        s1.add("bb");
        System.out.println(s1);
        for(int i=0;i<40;i++){//增加到溢出没有扩容时的容量
            s1.add("老谭"+i);
        }

        s1.set("老谭",1);

        s1.remove("老谭");

        s1.remove(4);

        System.out.println(s1);

        System.out.println(s1.get(39));
    }
}