Java中集合框架-简单解释

一、list

（1）List 是接口，继承至Collection接口（Collection接口下还有个Queue接口，有PriorityQueue类）；

（2）List下有ArrayList，Vector，LinkedList

ArrayList的实现原理

/**
 * @author DouZi
 * @Blog areone.top
 */
public class DemoList {
    public static void main(String[] args) {
        List li = new ArrayList(); //创建一个集合元素  长度默认为10
        li.add("DouZi");
        li.add(21);
        li.add(new Date());
        System.out.println(li);
        li.add(2,"男"); //在下标为2的地方添加一个数据  数据要进行位移
        System.out.println(li);

        List li2 = new ArrayList();
        li2.add("a");
        li2.add("b");
        li.addAll(li2);
        System.out.println(li);

        //删除
        li.remove(2); //删除下标2
        li.clear();//清空
         li.set(2,"刘德华");//修改操作

    }
}

 Demo2:

public class DemoList01 {
    public static void main(String[] args) {
        List li = new ArrayList(); //创建一个集合元素  长度默认为10
        li.add("DouZi1");
        li.add("DouZi2");
        li.add("DouZi3");
        //查询
        Object o = li.get(0);
        System.out.println(o);

        int s = li.size();
        System.out.println(s);

        boolean f = li.contains("java01");
        System.out.println(f);

        int index = li.indexOf("DouZi2");
        System.out.println(index);

        //遍历集合中的元素
        for (Object obj : li) {
            System.out.println(obj);
        }

    }
}

ArrayList的优缺点

优点：底层数据结构是数组，查询快，增删慢。

缺点： 线程不安全，效率高

二、ArrayList集合

ArrayList的底层代码:

从构造方法来入手。new ArrayList(22) 底层声明了一个Object类型的数组 名字elementData
  Object[] elementData

  public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) { //大于0
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) { //等于初始化为一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else { //抛出一个异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

==========add("java01")======E理解为Object类型================  
   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 扩容 
        elementData[size++] = e;  //把元素赋值给数组的相应位置
        return true;
    }
==========indexOf("java02") 判断元素在集合中第一次的位置=============
     public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i])) //和数组中的每个元素内容进行比对
                    return i;  //返回元素在集合中位置
        }
        return -1;
    }   

===========size() 请求数组的长度======================
 public int size() {
        return size;
    }   

============contain("java05")判断元素是否在集合中==============
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
===============get(1) 获取指定位置的元素========
   public E get(int index) {
        rangeCheck(index); //判断指定的位置是否合法 

        return elementData(index);
    }  

    E elementData(int index) {
        return (E) elementData[index];
    } 

============toString() 为什么不打印对象的引用地址 
    [java01, java02, java03, java02]因为重写了Object里面的toString方法。
    
 public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }   
    
    
通过对ArrayList方法的底层代码分析：底层就是对数组的操作。
    ArrayList的底层就是基于数组实现的。

三、LinkedList:

添加元素

        lin.add("java01"); //追加尾部
        lin.addFirst("java02"); //添加到头部
        lin.addLast("java03");//追加到尾部
        lin.addFirst("java04"); //追加到头部
        lin.addLast("java05");//追加到尾部
        System.out.println(lin);

 删除操作:

        lin.removeFirst();//移除头部元素
        System.out.println(lin);

        lin.remove(2);//移除指定位置的元素
        System.out.println(lin);

        lin.removeLast();//移除尾部的元素
        System.out.println(lin);

修改操作

        lin.set(1,"DouZi");
        System.out.println(lin);

查询操作:

       int size = lin.size();//求长度
        System.out.println("长度为:" + size);
        boolean empty = lin.isEmpty();//是否为空
        System.out.println("是否为空:" + empty);
        boolean b = lin.contains("java01");//判断元素是否在集合中
        System.out.println("是否在集合里:" + b);
        Object o = lin.get(1);//根据下标获取指定位置的元素
        System.out.println("1这个位置为:" + o);
        Object first = lin.getFirst();//获取第一个元素
        System.out.println(first);
        Object last = lin.getLast();
        System.out.println(last);

 

链表结构

四、HashSet

 public static void main(String[] args) {
        //new 一个 默认空间为16  负载因子 0.75
        HashSet hs = new HashSet();
        //添加操作
        hs.add("Java01");
        hs.add("Java02");
        hs.add("Java03");
        hs.add("Java04");
        System.out.println(hs); //随机哈希排序


        /*
        //初始大小  LinkList不可以初始大小
        HashSet hs1 = new HashSet(16);
        //第二个参数代表负载因子 / 使用70%时 要求扩容
        HashSet hs2 = new HashSet(15, 0.7f);
         */
    }

其中0.75为负载因子,当达到时就开始扩容

删除操作:

没有顺序的

 //删除操作
        hs.remove("Java01");
        System.out.println(hs);

修改操作:

      //修改操作
        //判断是否为空
        boolean b = hs.isEmpty();
        System.out.println(b);

        //判断是否存在此数据
        boolean bb = hs.contains("DouZi");
        System.out.println(bb);

遍历:

   //遍历
        for (Object o : hs){
            System.out.println(o);
        }

//迭代器循环
        Iterator it = hs.iterator();
        while (it.hasNext()){ //判断指针是否能够移动
            Object next = it.next(); //指定移动并获取当前元素
            System.out.println(next);
        }

五 TreeSet:

不允许重复的元素

     //TreeSet中的方法和HashSet方法一样 ,  只是实现不相同
       /*
        TreeSet tr = new TreeSet();
        //储存String类型
        tr.add("Java01");
        tr.add("Java02");
        tr.add("Java03");
        tr.add("Java04");
        tr.add("Java05");
        System.out.println(tr);
        */

储存一个对象类型:

import java.util.TreeSet;

/**
 * @author DouZi
 * @Blog areone.top
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        //储存对象类型
        TreeSet tr1 = new TreeSet();
        tr1.add(new Student("DouZi",21));
        tr1.add(new Student("刘德华",35));
        tr1.add(new Student("小水牛",32));
        System.out.println(tr1);
    }
}

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

会报错:

因为Student类没实现Comparable接口 

解决办法1:让类实现Comparable接口

解决方法2:创建TreeSet指定排序的对象

自动导入方法

//排序  如果大于0,表示返回当前元素比0大  

如果返回-1  : 当前添加的元素比0小 返回0表示相同元素

 

 所以需要改变下:

按照年龄排序:

 public int compareTo(Object o) {
//        System.out.println(this+"---->"+o);
        //按照年龄排序
        Student s = (Student) o;
        if (this.age > s.age) {
            return 1;
        }
        if (this.age < s.age) {
            return -1;
        }
        return 0;
    }

 

HashMap

创建增删改

  // 创建默认容量的 Map    默认长度16  负载因子 0.75
        Map m = new HashMap();

        Map m = new HashMap(20);

        Map m = new HashMap(20, 0.6F);

增删改

    /*  Map 存储数据的时候 使用 put 函数  需要两个参数 第一个代表 key  第二个代表 value
         *  并且 key  和 value 的数据类型 都是 Object
         *  也就是说   任意对象都可以当成 key
         *  但是我们一般 key 使用 String  value 取决于具体业务
         *
         *  返回值是 当前key 对应的上一个值  或者 null
         * */
    //添加操作
        m.put("name", "DouZi"); //m的key必须唯一
        m.put("age", 21);
    //        m.put("name","Dddd");  //如果相同的key值,后者会替换前者
    //        System.out.println(m);
        Map m1 = new HashMap();
        m1.put("n1", "DouZi11"); //m的key必须唯一
        m1.put("a1", 211);
        m.putAll(m1);
    //        System.out.println(m);


       m.replace("name","DouZi","张三三"); // {name=张三三, age=21}

    //删除操作
    //        m.remove("a1");//根据key删除
    //        System.out.println(m);