java集合大全

1.Collection

Collection是一个接口，不能被实例化。但是Java封装了实现类。咱们可以借助于多态De形式来实例化出来父类引用【重点】

collection接口下面的方法，子类或者子类的接口都可以使用

增：

boolean  add(E  e)；添加一个数据到集合中

boolean addAll(Collection<? extends E> c); 将一个集合数据添加到另外一个集合中
    Collection<? extends E>:元素 是E本类或者继承的E，才能添加到另外一个集合中
删:
    boolean remove(Object obj);删除指定的元素
 boolean removeAll(Collection<? extends E> c);  删除的是交集
     [a,b,c]  [b, c, d]
 void clear();清空的
查:
 int size();  查看集合中元素的个数 
 Object[] toArray(); 将集合转为Object类型数组
 boolean contains(Object obj); 集合中是否包含这个元素 如果包含返回true 
 boolean containsAll(Collection<? extends E> c);一个集合是否另外一个集合子集合
 boolean isEmpty();   判断集合是否为空

2.增强for循环

语法格式：

for(集合中元素的数据类型 临时变量 ： 集合或者数组) {
    sout（临时变量）
}

快捷键：iter

public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("张张");
        list.add("美女");
        list.add("好姑娘");
        list.add("小媳妇");
        System.out.println(list);
        //String s : list
        //将list集合 进行迭代，每次取一个值然后赋值给 s
        //将list集合中的数据挨个的赋值给s
        for (String s : list) {
            System.out.println(s);
        }
    }

3.迭代器

也是一种遍历工具

public class Demo4 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("小张");
        list.add("小平");
        list.add("小泽");
        list.add("王涛");

        //接下来咱们是哟个迭代器进行数据的遍历
        //1.通过集合对象创建迭代器对象 cursor  光标 指针
        Iterator<String> iterator = list.iterator();
        //2第一个方法  hasNext(); 判断一个集合中是否有下一个元素
       // System.out.println(iterator.hasNext());//true

        //3.next() 一个方法干了两件事情，
        //会返回当前光标下面的元素。并把光标挪到下一元素的位置
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//true
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());//false
//        System.out.println(iterator.next());
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

在集合中存的自定义的对象

public class Person {
    private String name;
    private int age;

    //有参构造方法，对属性进行赋值

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

    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;
    }

public class Demo5 {
    public static void main(String[] args) {
        Person person = new Person("老邢", 78);
        System.out.println(person);//
        // 之前打印的person对象是内存地址，现在在类中重写了toString方法
        //以后，输出一个对象的话，就会打印出来一个字符串
        //在集合中添加person对象
        Collection<Person> list = new ArrayList<>();
        list.add(person);
        list.add(new Person("骚磊", 45));
        list.add(new Person("阳仔", 89));
        list.add(new Person("源哥", 35));
        System.out.println(list);
        Object[] objects = list.toArray();
        Person person1 = (Person)objects[1];
        System.out.println(person1.getName());

    }
}

List接口

List是Collection的子接口

开发中用List而不用Collection

因为List接口下面的方法比Collection多，List在Collection基础之上添加了很多的方法

有序的可以重复的数据

Collection下面的方法List肯定有的，因为是继承关系。上午讲了Collection下面的方法，在List中也可以用。接下来咱们讲List独有的方法。
List独有的方法：
    增:
        void add(int index, E e);在指定的位置上插入一个元素
        boolean addAll(int index, Collection<? extends E> e);将一个集合插入到另外一个集合的指定的位置
    删：
        Collection删除的时候，通过元素来删除的。 remove(Object obj)
        E remove(int index);通过索引来删除指定的元素。返回的是被删除的元素
    改：
        E set(int index, E e); 通过指定的索引修改数据元素，返回值是被修改的原数据
    查:
        E get(int index);  通过索引下标去获取指定元素
        int indexOf(Object obj);通过元素获取指定的下标的
        int lastIndexOf(object obj);通过元素获取最后一次出现的元素的下标
        List<E> subList(int formIndex, int toIndex);截取一部分出来

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        //有序的  可重复的
        System.out.println(list);//[张三, 李四, 王五, 张三]
        list.add(2, "狗蛋");
        System.out.println(list);
        List<String> list1 = new ArrayList<>();
        list1.add("麻子");
        list1.add("赵四");
        list1.add("贝贝");
        list.addAll(1, list1);
        System.out.println(list);

        System.out.println(list.remove(0));//在删除
        System.out.println(list);//目的是删除以后的集合的数据展示一下
        //[麻子, 赵四, 贝贝, 李四, 狗蛋, 王五, 张三]

        System.out.println(list.set(2, "彩云"));//贝贝
        System.out.println(list);//修改之后的集合
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        //System.out.println(list.get(89));
        System.out.println(list.indexOf("麻子"));//0
        list.add(2, "张三");
        System.out.println(list.lastIndexOf("张三"));//7

        System.out.println(list);
        List<String> strings = list.subList(3, 5);
        System.out.println(strings);

    }
}

ArrayList和LinkedList和Vector的区别

ArrayList和Vector 底层是数组，但是Vector是线程安全的，所以效率底，开发中不用Vector
接下来介绍ArrayList和linkedListu区别:
    1.ArrayList底层是数组
     LinkedList底层是双向链表
    2.ArrayList 的特征：
        查询快： 底层是索引，有序的通过内存有序地址，直接找到 时间复杂度  o(1)
        增删慢： 增加数据和删除数据有可能扩容。每次扩1.5倍。扩容的话，浪费内存浪费时间o（n）
    3.LinkedList的特征：
        查询慢：底层是二分法查找的算法 时间复杂度是log以2为底 n的对数
        增删快：直接找前置结点 Node prev，后继结点 Node next
        。时间复杂度是 o(1)
    所以开发时候的用ArrayList
    后续还要学习ArrayList的源码