java-集合

导读：

       在实际的业务开发中，我们几乎离不开集合的使用。无论是使用集合进行数据存储还是使用集合工具类进行排序等相关操作，都需要对它们进行一定的了解，对每一种集合的适用场景，优缺点，常用方法，特点等等进行足够的理解，对集合工具类的使用进行掌握。如此，在实际的开发过程中我们才能够根据按需分配，按需执行。

附上思维导图：

使用场景：

1.存放数据是否为列表形式,且存放数据有序：->List

      默认： ->ArrayList

          查询效率较高，增删改效率较低： ->ArrayList,Vector

                 线程安全： ->Vector  

          查询效率较低，增删改效率较高： ->LinkedList

2.存放数据是否不可重复： ->Set

      默认： ->HashSet 

         可以排序，必须重写equals()与hashcode()方法： ->TreeSet

         存放数据有序： ->LinkedHashSet

         

3.存放数据是否按K/V的形式： ->Map

        默认： ->HashMap

          是否允许存在空键或者空值的情况： ->HashMap

          线程安全:  ->Hashtable,ConcurrentHashMap

             效率高： ->ConcurrentHashMap

          存放数据有序： ->LinkedHashMap,ConcurrentHashMap

ArrayList:通过数组实现，通过数组复制实现数组的扩容

附上代码简单了解：

public class OverrideArrayList {
    //定义一个Object类对象数组
    public Object[] elementsData;
    //集合的大小
    public int size;

    //初始化数组大小10
    public OverrideArrayList(){    
        this(10);
    }

    //初始化数组
    public OverrideArrayList(int InitCapacity){    
        if(InitCapacity<0) {
            try {
               System.out.println("初始化数值异常！");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        elementsData=new Object[InitCapacity];
    }

    //判断集合是否为空
    public boolean isEmpty() {
        return size==0;
    }
    
    public void add(Object obj) {
        //数组扩容，判断size是否大于数组的长度
        if(size==elementsData.length) {
            Object[] newArray=new Object[size*2+1];
            //原数组0的位置复制到新数组0的位置，数组元素为原数组数据
            System.arraycopy(elementsData, 0, newArray, 0, elementsData.length);
            //转化为新的数组
            elementsData=newArray;
        }
        elementsData[size++]=obj;
    }
    
    //根据索引位置查找数组对应下标的值
    public Object get(int index) {
        rangeCheck(index);
        return elementsData[index];
    }
    
    //在对应索引位置更改对应的值
    public void set(int index,Object obj) {
        elementsData[index]=obj;
    }
    

    //判断索引位置与数组大小，越界则抛出异常
    public void rangeCheck(int index) {
        if(index<0 || index>=size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }    
    }
    
    //测试
    public static void main(String[] args) {
        OverrideArrayList list=new OverrideArrayList();
        list.add(1);
        list.add(new Date());
        System.out.println(list.isEmpty());
        System.out.println(list.size);
        list.set(0, 2);
        System.out.println(list.size);
        list.add("测试");
        System.out.println(list.get(2));
    }
}

效果截图：

 

LinkedList:底层通过链表实现

//模拟链表实体类
public class Node {
    //上一个节点
    public Node previous;
    //下一个节点
    public Node next;
    //自身节点对象
    public Object obj;
    
    public Node() {

    }
    
    public Node(Node previous, Node next, Object obj) {
        super();
        this.previous = previous;
        this.next = next;
        this.obj = obj;
    }
    
    public Node getPrevious() {
        return previous;
    }
    public void setPrevious(Node previous) {
        this.previous = previous;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
    public Object getObj() {
        return obj;
    }
    public void setObj(Object obj) {
        this.obj = obj;
    }

}

//链表操作方法实现
public class TestLinkedList {
    //获取节点的头和尾以及链的长度大小
    private Node first;
    private Node last;
    private int size;
    
    //新增元素的方法
    public void add(Object obj) {
        Node n=new Node();
        //链表的头节点
        if(first==null) {
            n.setPrevious(null);
            n.setObj(obj);
            n.setNext(null);
            first=n;
            last=n;
        }else {
            //直接往last节点后增加新的节点
            n.setPrevious(last);
            n.setObj(obj);
            n.setNext(null);
            //下一个节点
            last.setNext(n);
            last=n;
        }
        size++;
    }

    //获取size
    public int size() {
        return size;
    }

    //根据下标获取元素的值
    public Object get(int index) {
        //获取index位置上的node对象
        Node temp=node(index);
        checkRange(index);
        if(temp!=null) {
            //返回当前节点的对象的值
            return temp.obj;
        }
        return null;
    }
    
    //索引位置对应node对象获取->first:头  ->next：下一个节点
    public Node node(int index) {
        Node temp=null;
        if(first!=null) {
            temp=first;
            //如果下一个节点不为空
            for(int i=0;i<index;i++) {
                temp=temp.next;
            }
        }
        return temp;

    }
    
    //设置index对应的对象的值
    public Object set(int index) {
        return null;
    }

    //删除index对应的对象的值
    public void remove(int index) {
        Node temp=node(index);
        if(temp!=null) {
            Node up=temp.previous;
            Node down=temp.next;
            //上一个节点的头指向下一个节点的尾
            up.next=down;
        }
        size--;

    }
    
    //检查是否越界
    public void checkRange(int index) {
        if(index<0 || index>=size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    //测试
    public static void main(String[] args) {
        TestLinkedList list=new TestLinkedList();
        //数据添加
        list.add("hello");
        list.add("abc");
        list.add(new Date());
        //数据移除
        list.remove(2);
        System.out.println("集合大小："+list.size());
        System.out.println("当前索引1对应的值为："+list.get(1));

    }
}

简单了解：

public class LinkedListTest {
    private List list = new LinkedList();

    @Test
    public void test() {
        //添值
        list.add(0,1);
        list.add(1,"2");
        list.add(2,'3');
        //设值
        list.set(0, 123);
        //集合大小
        System.out.println(list.size());
        //取值
        System.out.println(list.get(0));
        //获取对应值的索引下标  若值不存在返回-1
        System.out.println(list.indexOf(123));
        //获取对应下标的list迭代器
        ListIterator listIterator=list.listIterator(1);
        //迭代器是否存在下一个值
        System.out.println(listIterator.next());
        //获取list集合的list迭代器
        ListIterator listIterator1=list.listIterator();
        //集合切割，生成从索引为1到3   -> [1,3)的新集合
        List newList=list.subList(1,3);
        //集合转变为数组
        Object [] obj=newList.toArray();
        //遍历数组
        for(Object ob:obj){
            System.out.println(ob);
        }
    }

}

效果截图：

ConcurrentHashMap:底层是数组加链表或者红黑树实现，内部使用到分段锁技术保证多线程的环境安全

简单了解：

public class ConcurrentHashMapTest {
    //ConcurrentHashMap:本身就是一个线程安全的，有序
    private ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<Object, Object>();

    @Test
    public void test() {
        //数据存放
        map.put(1, "abc");
        map.put(2, 123);
        map.put("x", 'x');
        //是否包含123的值
        System.out.println(map.contains(123));
        //是否包含2的键
        System.out.println(map.containsKey(2));
        //是否包含123的值
        System.out.println(map.containsValue(123));
        //同key下新的值替换旧的值
        map.replace(2, 123, 345);
        //存放键与值均不为空
        map.putIfAbsent('z', 123);
        System.out.println("z:" + map.get('z'));
        //获取枚举对象 里面仅存放所有值，不包含键信息
        Enumeration<Object> elements = map.elements();
        //遍历枚举对象
        while (elements.hasMoreElements()) {
            System.out.println(elements.nextElement());
        }
        //获取set对象
        Set set = map.entrySet();
        //构造迭代器遍历set
        Iterator it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

详细了解：https://www.cnblogs.com/banjinbaijiu/p/9147434.html

 文章若有什么不当之处，欢迎指正。