美文网首页
常用集合

常用集合

作者: 劳资爱学习 | 来源:发表于2019-08-07 23:45 被阅读0次
    /**
     * ArrayList
     * 优点: 底层数据结构是数组,查询快,增删慢。
     * 缺点: 线程不安全,效率高
     */
    public static  void ArrayLst(){
        ArrayList list = new ArrayList<>();
        //添加
        list.add(1);
        list.add("这是一个字符串");
        System.out.println(list);

        //清空集合
        list.clear();
        System.out.println(list);
    }

  public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }
/**
     * LinkedList
     * 优点: 底层数据结构是链表,查询慢,增删快。
     * 缺点: 线程不安全,效率高
     */
    public static void LinkedList(){
        LinkedList list = new LinkedList<>();
        list.add(1);
        list.add("这是一个字符串");
        System.out.println(list);
        list.clear();
        System.out.println(list);
    }
 public boolean add(E e) {
        linkLast(e);
        return true;
    }
  void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }
    /**
     * 不仅不能保证元素插入的顺序,而且在元素在以后的顺序中也可能变化(这是由HashSet按HashCode存储对象(元素)决定的,对象变化则可能导致HashCode变化)
     * HashSet是线程非安全的
     * HashSet元素值可以为NULL
     * 实现Set接口的HashSet,依靠HashMap来实现的。
     * 我们应该为要存放到散列表的各个对象定义hashCode()和equals()。
     */
    public static void HashSet(){
        HashSet set = new HashSet<>();
        set.add(1);
        set.add("这是一个字符串");
        set.clear();
        System.out.println(set);
    }
    public HashSet() {
        map = new HashMap<>();
    }
   public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
    public void clear() {
        Node<K,V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }
    /**
     * TreeSet是一个有序的集合,它的作用是提供有序的Set集合。它继承了AbstractSet抽象类,实现了NavigableSet<E>,Cloneable,
     * Serializable接口。TreeSet是基于TreeMap实现的,TreeSet的元素支持2种排序方式:自然排序或者根据提供的Comparator进行排序。
     *
     */
    public static void TreeSet() {
        TreeSet<Object> set = new TreeSet<>();
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(10);
        set.add(4);
        System.out.println(set);
        set.clear();
        System.out.println(set);
        //输出结果
        // [1, 2, 3, 4, 10]
        //[]
public class Student implements Comparable {
    private String name;
    private int age;
    @Override
    public int compareTo(Object o) {
        //如果将compareTo()返回值写死为0,元素值每次比较,都认为是相同的元素,这时就不再向TreeSet中插入除第一个外的新元素。
        // 所以TreeSet中就只存在插入的第一个元素。
        return 0;
        //如果将compareTo()返回值写死为1,元素值每次比较,都认为新插入的元素比上一个元素大,于是二叉树存储时,
        // 会存在根的右侧,读取时就是正序排列的。
        return 1;
        //如果将compareTo()返回值写死为-1,元素值每次比较,都认为新插入的元素比上一个元素小,于是二叉树存储时,
        // 会存在根的左侧,读取时就是倒序序排列的。
        return -1;
    }
}
 /**
     * 底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
     * 1.由链表保证元素有序
     * 2.由哈希表保证元素唯一
     */
    public static void LinkedHashSet(){
        LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(111);
        linkedHashSet.add("这是一个字符串");
        //使用迭代器遍历
        Iterator<Object> it = linkedHashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
 /**
     * HashMap是一个散列桶(数组和链表),它存储的内容是键值对(key-value)映射
     * HashMap采用了数组和链表的数据结构,能在查询和修改方便继承了数组的线性查找和链表的寻址修改
     * 当向HashMap中put一对键值时,它会根据key的hashcode值计算出一个位置,该位置就是此对象准备往数组中存放的位置
     * HashMap是非synchronized,所以HashMap很快
     * HashMap可以接受null键和值,而Hashtable则不能(原因就是equlas()方法需要对象,因为HashMap是后出的API经过处理才可以)
     * 如果该位置没有对象存在,就将对象直接放进数组当中;如果该位置已经有对象存在了,则顺着此存在的对象的链开始寻找(Entry  类有一个Entry类型的next成员变量,指向了该对象的下一个对象),如果此链上有对象的话,再去使用equal方法进行比较,如果对此链上的某个对象的equals方法比较为false,则将该对象放到数组当中,该位置以前存在的那个对象链接到此对象的后面
     */
    public static void HashMap(){
        HashMap<Object, Object> map = new HashMap<>();
        map.put(1,"这是一个数字1");
        map.put("张三","18岁了");
        System.out.println(map);
        //使用迭代器遍历
        Iterator<Object> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //输出结果
        // {1=这是一个数字1, 张三=18岁了}
        //1
        //张三

    }

相关文章

  • Java基础之Collection集合

    标题常用集合 Java集合中,几个常用集合关系图 Collection单列集合中常用集中集合关系 Collecti...

  • 面试聊几句

    一.常用的集合 Collection下的List集合的话有ArrayList和LinkedList,Set集合常用...

  • 2019-06-04

    RedisTemplate常用集合使用说明(一) RedisTemplate常用集合使用说明-opsForValu...

  • Java(二)Java基础--05集合类

    一、常用集合类的使用 常用集合类 二、ArrayList 和 LinkedList 和 Vector 的区别 1、...

  • 常用集合

  • 第1章 第1节 集合

    集合(集) 定义 具有某种特定性质,具体的或抽象的对象(集合的元素)汇集的总体 。集合通常用大写的表示。元素通常用...

  • JJJJJava集合

    集合与数组的区别 Collection集合的方法 常用集合的分类 Collection 接口的接口 对象的集合(单...

  • java基础-day15-集合和Object

    集合和Object 1. 集合 1.1 为什么要使用集合 1.2 集合结构简述 1.3 集合常用方法 【补充知识点...

  • 集合

    常用集合类 单列集合 Collection:Iterable 是单列集合类的根接口 Collection用于存储一...

  • java基础-day16-list集合

    List集合 1. List集合 1.1 List集合特征 1.2 List常用方法 2. ArrayList 可...

网友评论

      本文标题:常用集合

      本文链接:https://www.haomeiwen.com/subject/pkyzdctx.html