java 集合（基础）

1.Collection

Collection是一个集合接口

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.遍历集合中的数据

3种：
1.使用for循环
2.增强for循环
3.迭代器

2.1for循环遍历

将集合转为数组在for循环遍历

太麻烦不用

2.2增强for循环

语法格式:

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

快捷键：iter （牢记）。

2.3迭代器

是增强for循环的底层

通过集合创建迭代器

迭代器 Iterator iterator = list.iterator();

它有两个方法

第一个方法 hasNext(); 判断一个集合中是否有下一个元素

第二个方法 next() 一个方法干了两件事情，
会返回当前光标下面的元素。并把光标挪到下一元素的位置

3.在集合中存的是自定义的对象

创建一个对象

package com.qfedu.a_collection;

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;
    }
    //在一个类中重写toString方法
    //将内存地址转为程序员能看懂的字符串

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

package com.qfedu.a_collection;


import java.util.ArrayList;
import java.util.Collection;

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());

    }
}

4 List接口

List是Collection的子接口

开发中用List而不用Collection。

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

有序的可以重复的数据

package zzy;

import java.util.ArrayList;
import java.util.List;

public class Dome4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");//增加数据
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        List<String> list1 = new ArrayList<>();
        list1.add("b");
        list.addAll(1,list1);//在指定下标添加一个集合，剩下的往后移
        //删
        list.remove(1);//删除指定下标元素
        list.remove("a");//删除指定元素
        System.out.println(list);
        System.out.println(list.removeAll(list1));//删除与list1相同的数据
        System.out.println(list);
        // list.clear();//清空列表
        System.out.println(list);
        //查
        System.out.println(list.size());//查看元素个数
        //System.out.println(list.toArray());//返回一个Object数组,它就是Object不是其他类；但是我们如果需要获得对应特定类型的数组时：通常都是在取得数组元素时进行强制类型转换
        System.out.println(list.contains(list1));//list 包含 list1 返回true 反之false
        list.containsAll(list1);//list是否包含list1的所有元素
        System.out.println(list.isEmpty());//判段集合是否为空

    }

}

遍历还是和Collection一样

集合中村对象也是和Collection一样

5 ArrayList

ArrayList底层是数组，可以扩容的。默认的容量是10.，超过10以后会自动扩容，扩容1.5倍

特征:

​ 查询快，增删慢。

​ 为啥？

开发就用ArrayList 因为开发的时候，主要查询多！！

6LinkedList

也是List的实现类，双向链表

特征： 查询慢，增删快

7ArrayList和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的源码