集合（java）

 

 

 1.容器

1.数组：创建一个指定长度的数组，使用数组来存储多个数据，数组的查询速度快

2.集合：程序运行时，数据数量是改变的，但是数据一旦给定，就不能改变，频繁的扩容，对数据操作多种多样的增删多，查询少，链表结构针对于程序中，这种不同的存储需求

public class Demo1 {
//    集合(容器):
//    数组(容器):创建一个指定长度的数组，使用数组来存储多个数据，
//    程序运行时，数据运行时数据数量是改变的，但是数组一旦给定，就不能频繁的扩容，数组优点是查询速度快
//    对数据操作多种多样的，增删多，查询少，链表结构针对程序中，这种不同存储操作需求
//    collection(单列)
//       list(可重复)
//       set(不可重复)
//    Map(多列)
public static void main(String[] args) {
    Collection<String> a=new ArrayList<>();
    a.add("a");
    a.add("b");
    a.add("c");
    a.add("d");
    Collection<String> b=new ArrayList<>();
    b.add("e");
    b.add("f");
    b.add("g");
    b.add("h");
//    a.addAll(b);//集合全部添加到另一个集合中
//    a.clear();//将集合中的所有元素全部清空
//    System.out.println( a.equals(b));//比较俩个集合中的元素是否相等
//    System.out.println(a.isEmpty());//判断是否为空集合
//    a.remove("c");//在集合中指定删除某一个元素
//    System.out.println( a.remove("c"));//成功为ture,失败为false
//    System.out.println( a.retainAll(b));//保留取交集，成功为ture，失败为false
//    System.out.println(a.size());//输出该集合的长度 //数组length是为属性，字符串length()为方法，集合size()为方法
//    String [] sobject=a.toArray(new String [a.size()]);//将集合转化为指定类型
//    System.out.println(Arrays.toString(sobject));
//    Object [] b1=a.toArray();//转化成Object类型
    System.out.println(a);
    System.out.println(b);







}

  public static void main(String[] args) {
        //ArrayList：底层是通过数组实现的，动态数组，查询快，中间增删慢
        //Linkedlist:底层是链表实现，查询慢，中间增删快，只需要改变后继节点的位置
//        Vector:底层是数组实现，较为安全
        //add();向集合中添加元素时，底层会默认创建一个长度为10的Object类型数组，
        // 当数组装满时，再次添加数组时，会创建一个原来数组长度1.5倍的新数组，将原来数组内容复制过来，最后将新数组的地址赋给底层
        ArrayList<String> s=new ArrayList<>();
        s.add("a");
        s.add("b");
        s.add("c");
        s.add("d");
        System.out.println(s.get(2));//根据索引得到指定位置的元素
        s.remove(0);//删除并返回指定位置的元素
        System.out.println(s);
        s.set(0,"X");//替换指定元素并返回数组
        System.out.println(s);
        s.size();
        System.out.println(s.size());//返回实际元素个数
    }

 ArrayList alist = new ArrayList();
        alist.add("a");
        alist.add("b");
        alist.add("c");
        alist.add("d");
        Date date = new Date();
        long s1 = date.getTime();
        System.out.println(s1);
        for (int i = 0; i < 500000; i++) {
            alist.add(2, "c");
        }
        Date date1 = new Date();
        long s2 = date1.getTime();
        System.out.println(s2);
        long s3=s2-s1;
        System.out.println(s3);
        LinkedList llist=new LinkedList();
        llist.add("a");
        llist.add("b");
        llist.add("c");
        llist.add("d");
        Date date2 = new Date();
        long s4 = date2.getTime();
        System.out.println(s4);
        for (int i = 0; i < 500000; i++) {
            llist.add(2, "c");
        }
        Date date3 = new Date();
        long s5 = date3.getTime();
        System.out.println(s2);
        long s6=s5-s4;
        System.out.println(s6);

    迭代器遍历集合1：返回了一个ArrayList的内部类对象，实现Iterator接口
//        此类部类，专门用作对集合进行遍历时的控制
//        ArrayList<String> llist=new ArrayList();
//        llist.add("a");
//        llist.add("b");
//        llist.add("c");
//        llist.add("d");
//        llist.add("e");
//        llist.add("f");
//        llist.add("g");
//        llist.add("g");
//        Iterator<String> it=llist.iterator();
//        while(it.hasNext()){//判断集合中是否有元素
//            String e=it.next();//将下一个元素赋给e
//            if(e.equals("g")){
//                it.remove();//删除时用迭代器进行方法调用，底部有自动的计数器
//            }
//        }System.out.println(llist);
        //迭代器集合2，提供ListIterator()方法
        LinkedList<String> llist = new LinkedList();
        llist.add("a");
        llist.add("b");
        llist.add("c");
        llist.add("d");
        llist.add("e");
        llist.add("f");
        llist.add("g");
        llist.add("g");
        ListIterator<String> it = llist.listIterator(llist.size());//此方法可以指定位置进行迭代
//        while(it.hasNext()){
//            String e=it.next();
//            System.out.println(e);
//        }
        while (it.hasPrevious()) {//此方法可以将集合中的元素进行逆序遍历
            String e = it.previous();
            System.out.println(e);
        }
    }

  //set共同点：不可重复，无序(不是按照添加的顺序进行排序，杂乱)，无序且不重复的集合
        //有遍历俩种形式：1.增强for循环 2.迭代器迭代(无索引故不能使用for循环)
        // Hashset：存储的元素不固定
//        HashSet<String> hset=new HashSet<>();
//        hset.add("a");
//        hset.add("d");
//        hset.add("b");
//        hset.add("x");
//        hset.add("l");
//          hset.add("l");
//          hset.add("l");
//        System.out.println(hset);

//Treeset:可以按照元素的自然顺序进行排序，有序(根据元素的自然顺序进行排序)且不能存储重复元素
//        TreeSet<String> hset=new TreeSet<>();
//        hset.add("a");
//        hset.add("d");
//        hset.add("b");
//        hset.add("x");
//        hset.add("l");
//        System.out.println(hset);

        //可以把另外一个集合的元素赋给Treeset。前提是该集合必须和Comparable有关系或者是继承
//        Demo3 demo1=new Demo3(1,"baoma");
//        Demo3 demo2=new Demo3(2,"baoma");
//        Demo3 demo3=new Demo3(3,"baoma");
//        TreeSet<Demo3> a=new TreeSet<>();
//        a.add(demo1);
//        a.add(demo3);
//        a.add(demo2);
//        System.out.println(a);



    }

具体框架看思维导图