Java集合01

Posted 2020-11-16 Nomad1c

0. 对象数组
(1) 数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。

1. Collection
(1) 集合的由来?
数组的长度固定，不适合变化的需求，Java就提供了集合。
(2) 集合和数组的区别?
　　A:长度区别
　　　　数组固定
　　　　集合可变
　　B:内容区别
　　　　数组可以是基本类型，也可以是引用类型
　　　　集合只能是引用类型
　　C:元素内容
　　　　数组只能存储同一种类型
　　　　集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3) 集合的继承体系结构?
　　由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
　　我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

　　Collection
　　|--List
　　　　|--ArrayList
　　　　|--Vector
　　　　|--LinkedList
　　|--Set
　　　　|--HashSet
　　　　|--TreeSet
(4) Collection的功能概述
　　A:添加功能 boolean add(E e)
　　B:删除功能 boolean remove(Object o)
　　C:判断功能 boolean contains(Object o) / boolean isEmpty()
　　D:获取功能 Iterator<E> iterator()
　　E:长度功能 int size()
　　F:交集 boolean retainAll(Collection<?> c) -> 仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）
　　G:把集合转数组 Object[] toArray()
(5) Collection集合的遍历
　　A:把集合转数组
　　B:迭代器(集合专用方式)
(6) 迭代器
　　A:是集合的获取元素的方式。
　　B:是依赖于集合而存在的。
　　C:迭代器的原理和源码。
　　　　a:为什么定义为了一个接口而不是实现类?
　　　　　　每种集合的数据结构是不同的，所以存储方式和遍历方式是不一样的；而且每种集合的判断和获取功能不一样
　　　　b:迭代器的内部类实现。
(7) Collection集合的案例(遍历方式：迭代器)
集合的操作步骤：
　　A:创建集合对象a:通过集合对象获取迭代器对象
　　B:创建元素对象
　　C:把元素添加到集合
　　D:遍历集合
　　　　a:通过集合对象获取迭代器对象
　　　　b:通过迭代器对象的hasNext()方法判断是否有元素
　　　　c:通过迭代器对象的next()获取元素并移到下一个位置

A:存储字符串并遍历

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

public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //创建并添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        //遍历集合
        Iterator it = c.iterator();
        while(it.hasNext()) {
            String s =(String) it.next();
            System.out.println(s);
        }
    }
}

B:存储自定义对象并遍历

类似

2. List
(1) List是Collection的子接口
　　特点：有序(存储顺序和取出顺序一致)，可重复。
(2) List的特有功能
　　A:添加功能 void add(int index, E element)
　　B:删除功能 E remove(int index) / void clear()
　　C:获取功能 E get(int index)
　　D:迭代器功能 Iterator<E> iterator()
　　E:修改功能 E set(int index, E element)
(3) List集合的特有遍历功能
　　由size()和get()结合。
(4) 列表迭代器的特有功能
　　可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5) 并发修改异常
　　A:出现的现象
　　　　迭代器遍历集合，集合修改集合元素
　　B:原因
　　　　迭代器是依赖于集合的，而集合的改变迭代器并不知道。
　　C:解决方案
　　　　a:迭代器遍历，迭代器修改(ListIterator)
　　　　　　元素添加在刚才迭代的位置
　　　　b:集合遍历，集合修改(size()和get())
　　　　　　元素添加在集合的末尾
(6) 常见数据结构
　　A:栈 先进后出
　　B:队列 先进先出
　　C:数组 查询快，增删慢
　　D:链表 查询慢，增删快
(7) List的子类特点
　　ArrayList
　　　　底层数据结构是数组，查询快，增删慢。
　　　　线程不安全，效率高。
　　Vector
　　　　底层数据结构是数组，查询快，增删慢。
　　　　线程安全，效率低。
　　LinkedList
　　　　底层数据结构是链表，查询慢，增删快。
　　　　线程不安全，效率高。
　　根据需求看到底使用谁，分析：
　　　　要安全吗?
　　　　　　要：Vector(即使要，也不使用这个)
　　　　　　不要：ArrayList或者LinkedList
　　　　查询多：ArrayList
　　　　增删多：LinkedList
　　　　什么都不知道，就用ArrayList。

3. List的子类
(1) List的子类特点
　　ArrayList:
　　　　底层数据结构是数组，查询快，增删慢
　　　　线程不安全，效率高
　　Vector:
　　　　底层数据结构是数组，查询快，增删慢
　　　　线程安全，效率低
　　LinkedList:
　　　　底层数据结构是链表，查询慢，增删快
　　　　线程不安全，效率高
(2) ArrayList
　　A:没有特有功能需要学习
　　B:案例
　　　　a:ArrayList存储字符串并遍历
　　　　b:ArrayList存储自定义对象并遍历
(3) Vector
　　A:有特有功能
　　　　a:添加
　　　　　　public void addElement(E obj) -- add()
　　　　b:获取
　　　　　　public E elementAt(int index) -- get()
　　　　　　public Enumeration<E> elements() -- iterator()
　　B:案例
　　　　a:Vector存储字符串并遍历
　　　　b:Vector存储自定义对象并遍历
(4) LinkedList
　　A:有特有功能
　　　　a:添加
　　　　　　addFirst()
　　　　　　addLast()
　　　　b:删除
　　　　　　removeFirst()
　　　　　　removeLast()
　　　　c:获取
　　　　　　getFirst()
　　　　　　getLast()
　　B:案例
　　　　a:LinkedList存储字符串并遍历
　　　　b:LinkedList存储自定义对象并遍历
(5) 案例：
A:去除集合中的多个字符串的重复元素
　　如果字符串的内容相同，即为重复元素
B:去除集合中的多个自定义对象的重复元素
　　如果自定义对象的成员变量值都相同，即为重复元素
C:用LinkedList模拟一个栈数据结构的集合类，并测试。
　　你要定义一个集合类，只不过内部可以使用LinkedList来实现。

4. 泛型（Generic）
(1) 泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2) 格式：
　　<数据类型>
　　注意：该数据类型只能是引用类型。
(3) 好处：
　　A:把运行时期的问题提前到了编译期间
　　B:避免了强制类型转换
　　C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4) 泛型的前世今生
　　A:泛型的由来
　　　　Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
　　B:泛型类
　　C:泛型方法
　　D:泛型接口
　　E:泛型高级通配符
　　　　? -> 任意类型，如果没有明确，就是Object类以及任意的Java类
　　　　? extends E -> 向下限定，E及其子类
　　　　? super E -> 向上限定，E及其父类
(5) 我们在哪里使用呢?
一般是在集合中使用。

5. 增强for循环
(1) 是for循环的一种
(2) 格式：
for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
　　使用该变量即可，该变量其实就是数组或者集合中的元素。
}
(3) 好处：
　　简化了数组和集合的遍历
(4) 弊端
　　增强for循环的目标不能为null。建议在使用前，先判断是否为null。

6. 静态导入
(1) 可以导入到方法级别的导入
(2) 格式：
　　import static 包名....类名.方法名;
　　import static org.junit.Assert.assertEquals;
(3) 注意事项：
　　A:方法必须是静态的
　　B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
　　所以一般我们并不使用静态导入，但是一定要能够看懂。

7. 可变参数
(1) 如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2) 格式：
　　修饰符 返回值类型 方法名(数据类型... 变量) {}
　　注意：
　　　　A:该变量其实是一个数组名
　　　　B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

public class ChangeabelVar {
    public static void main(String[] args) {
        // 2个数据求和
        int a = 10;
        int b = 20;
        int result = sum(a, b);
        System.out.println("result:" + result);
        // 3个数据的求和
        int c = 30;
        result = sum(a, b, c);
        System.out.println("result:" + result);
        // 4个数据的求和
        int d = 30;
        result = sum(a, b, c, d);
        System.out.println("result:" + result);
    }

    public static int sum(int... a) {
        int s = 0;
        for(int x : a){
            s +=x;
        }
        return s;
    }
}

8. Arrays工具类（java.util.Arrays）
　　A:asList(T... a)方法：把数组转成集合。注意：这个集合的长度不能改变，会产生UnsupportedOperationException
　　B:equals(int[] a, int[] b)判断两个数组是否相等
　　C:toString(int[] a)方法：返回一个指定数组的字符串表现形式
　　D:fill(int[] a, int value)方法：给指定数组的每个元素分配指定的值
　　E:sort(int[] a)：按升序对指定数组进行排序
　　F:binarySearch(int[] a, int value)：使用二分搜索算法在指定的数组中搜索指定的值，并返回该值所在索引位置；若查询不到，则返回-1