唯时

Java集合知识总结

Java集合

数据结构：

逻辑结构：—>思想上的结构（厨房、卧室）—>线性表（数组，链表），图，树，栈，队列
物理结构：—>真实结构（钢筋混凝土+牛顿力学）—>紧密结构（顺序结构），跳转结构（链式结构）

1 集合的概念

概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
和数组区别：
1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型
位置：java.util.*

集合结构图

应用场合：

前后端数据库交互，党需要将相同结构的个体整合到一起的时候，需要集合。
实际应用场合：购物网站、邮件等等

2 Collection接口

子接口：List接口，Set接口

常用方法

增加：add(E e) addAll(Collection c)

删除：clear() remove(Object o) removeAll(Collection c)

修改：stream() 返回以此集合为源的顺序

查看：iterator() 遍历 size()

判断：contains(Object o) equals(Object o) isEmpty()

遍历方式：增强for循环、迭代器

/*
        **Collection常用方法**

        增加：`add(E e)` `addAll(Collection c)`
        删除：`clear()` `remove(Object o)` `removeAll(Collection c)`
        修改：`stream()` 返回以此集合为源的顺序
        查看：`iterator()` 遍历 `size()`
        判断：`contains(Object o)` `equals(Object o)` `isEmpty()`
         */
        //1 创建对象：接口不能创建对象，利用实现类创建对象
        Collection col = new ArrayList();
        //2 调用方法：
        //集合只能存放引用数据类型的数据，不能放基本数据类型
        //基本数据类型自动装箱，对应包装，int-->Integer
        col.add(18);
        col.add(12);
        col.add(10);
        col.add(90);

        System.out.println(col.toString());

        List list = Arrays.asList(new Integer[]{1, 2, 3, 4, 5});
        col.addAll(list);//将另一个集合添加入 col 中
        System.out.println(col);

//        col.clear();//集合清空
        System.out.println(col);
        System.out.println("集合中元素的数量："+col.size());
        System.out.println("集合是否为空："+col.isEmpty());

        boolean isRemove = col.remove(1);
        System.out.println(col);
        System.out.println("集合中的数据是否删除成功："+isRemove);


        Collection col2 = new ArrayList();
        col2.add(18);
        col2.add(12);
        col2.add(10);
        col2.add(90);

        Collection col3 = new ArrayList();
        col3.add(18);
        col3.add(12);
        col3.add(10);
        col3.add(90);

        System.out.println("两集合是否一样："+col2.equals(col3));
        System.out.println(col2==col3);//false,地址不一样

        System.out.println("是否包含元素："+col3.contains(12));

//遍历方法
Collection col = new ArrayList();
col.add(18);
col.add(12);
col.add(10);
col.add(90);
col.add("sad");
col.add(3.4);
//对集合遍历（对集合中元素进行查看）
//方式1：普通for循环,不能完成
/*for(int i=0; i

//方式2：增强for循环
for(Object o:col){
    System.out.println(o);
}
System.out.println("-----------------");
//方式3：iterator()方法
//Iterator：迭代器
/*
通过hasNext()来判断是否有下一个元素，如果有下一个元素，则返回true，否则返回false；
next()方法将元素获取到并且将“指针”下移
 */
Iterator it = col.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

1）Collections工具类

import java.util.ArrayList;
import java.util.Collections;

public class TestCollectios {
    public static void main(String[] args) {
        //Collections不支持创建对象，因为构造器私有化了
        //*ColLections cols = new Collections（）；*/
        //里面的属性和方法都是被static修饰，我们可以直接用类名，去调用即可：
        //常用方法：
        //addAll:
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("cc");
        list.add("gg");
        Collections.addAll(list,"ff","dd","ff");
        Collections.addAll(list,new String[] {"bb","pp","qq"});

        Collections.sort(list);//sort提供升序排列
        //binarySearch 必须在有序的集合中查找--->排序
        System.out.println(Collections.binarySearch(list, "cc"));
        System.out.println(list);
        System.out.println("---------------------");
        //copy：替换方法
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"jj","kk");
        Collections.copy(list,list2);//将list2的内容替换到list 上去
        System.out.println(list);
        System.out.println(list2);

        //fill填充
        Collections.fill(list2,"zz");
        System.out.println(list2);


    }
}

3 List接口与实现类

实现类：ArrayList类、LinkedList类、Vector类（淘汰）

List接口常用方法 扩展的方法都跟索引有关 特点：不唯一，有序

增加：add(int index, E element)

删除：remove(int index) remove(Object o)

修改：set(int index, E element)

查看：get(int index)

判断：

遍历方式：普通for循环、增强for循环、迭代器

List list = new ArrayList();
list.add(13);
list.add(23);
list.add(43);
list.add(11);
list.add(2);
list.add("ab");
System.out.println(list);
list.add(2,10);//增加
System.out.println(list);

list.set(2,1);//修改
System.out.println(list);

list.remove(2);
System.out.println(list);
//在集合中存入的是Integer类型数据时，调用remove方法调用的是：remove(int index)
list.remove("ab");
System.out.println(list);

Object o = list.get(0);
System.out.println(o);

System.out.println("-----list集合遍历----------");
//list集合  遍历
//方式1：普通for循环
for(int i=0; i<list.size(); i++){
    System.out.println(list.get(i));
}
System.out.println("---------------");
//方式2：增强for循环
for(Object obj:list){
    System.out.println(obj);
}
System.out.println("---------------");
//方式3：iterator()迭代器
Iterator it = list.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

1）ArrayList实现类

数组结构实现，查询快、增删慢
JDK1.2版本，运行效率快、线程不安全

源码类似：StringBuilder

ArrayList实现类底层有两个基本要素：（1）Object类型的数组elementData，（2）size：数组的有效长度

transient Object[] elementData; // non-private to simplify nested class access
/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;

JDK1.7源码：底层数组，在调用构造器的时候，数组长度初始化为10；扩容时，扩展为原数组的1.5倍。

JDK1.8源码：底层数组，在调用构造器时，底层数组为{}，在调用add方法后底层数组才重新赋值新数组，新数组的长度为10–>节省了内存，在add后才创建长度为10的数组。

底层依旧时Object类型的数组，size：数组中有效长度;
ArrayList al = new ArrayList();在调用空构造器的时候，底层elementData数组的初始化为{};

2）Vector实现类

数组结构实现，查询快、增删慢；
JDK1.0版本，运行效率慢、线程安全。

与ArrayList实现类的对比：

联系：底层都是数组的扩容

区别：

ArrayList底层扩容长度时原数组的1.5倍，线程不安全 -->效率高
Vector底层扩容长度时原数组的2倍，线程安全–> 效率低（已淘汰）

3）LinkedList实现类

链表结构(双向链表)实现，增删块、查询慢。

LinkedList接口常用方法

增加：addFirst(E e) addLast(E e) offer(E e) offerFirst(E e) offerLast(E e)

删除：poll() pollFirst() pollLast()(<—推荐使用，JDK1.6以后新出的方法，提高代码的健壮性) removeFirst() removeLast()

修改：

查看：element() getFirst() getLast() indexOf(Object o) lastIndexOf(Object o) peek() peekFirst() peekLast()

判断：

遍历方式：普通for循环、增强for循环、迭代器

public class Test4 {
    public static void main(String[] args) {
        /*LinkedList接口**常用方法**
    增加：`addFirst(E e)` `addLast(E e)`
         `offer(E e)` `offerFirst(E e)` `offerLast(E e)`
    删除：`poll()` `pollFirst()` `pollLast()`(<---推荐使用，JDK1.6以后新出的方法，提高代码的健壮性)
         `removeFirst()` `removeLast()`
    修改：
    查看：`element()` `getFirst()` `getLast()`
         `indexOf(Object o)` `lastIndexOf(Object o)`
         `peek()` `peekFirst()` `peekLast()`
    判断：
    遍历方式：普通for循环、增强for循环、迭代器
    */
        //创建一个LinkedList集合对象
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("cc");
        list.add("bbb");//LinkedList可以添加重复数据
        list.add("eee");

        list.addFirst("12");
        list.addLast("345");

        list.offer("qaz");//添加数据在再末尾
        list.offerFirst("00");
        list.offerLast("99");

        System.out.println(list.poll());//删除开头的元素，并将元素输出
        System.out.println(list.pollFirst());
        System.out.println(list.pollLast());

        list.clear();//清空集合
        System.out.println(list);
        System.out.println(list.pollFirst());//提高代码的健壮性

        //System.out.println(list.removeFirst());//报错，Exception in thread "main" java.util.NoSuchElementException

        System.out.println(list);        
    }
}

遍历方式：

//集合的遍历
//1 普通for循环
for(int i=0;i<list.size();i++){
    System.out.println(list.get(i));
}
System.out.println("------------------");
//2 增强for循环
for(String str:list){
    System.out.println(str);
}
System.out.println("------------------");
//3 迭代器
/*Iterator it = list.iterator();
while (it.hasNext()){
    System.out.println(it.next());
}*/
//下面这种方式好，节省内存
for(Iterator<String> it = list.iterator();it.hasNext();){
    System.out.println(it.next());
}

4）ArrayList和LinkedList的区别

ArrayList：数据结构

物理结构：紧密结构
逻辑结构：线性表（数组）

LinkedList：数据结构

物理结构：跳转结构
逻辑结构：线性表（链表，双向链表）

模拟Linked List源码：

public class Node {
    private Node pro;
    private Object object;
    private Node next;

    public Node getPro() {
        return pro;
    }

    public void setPro(Node pro) {
        this.pro = pro;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public void setObject(Node object) {
        this.object = object;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public Object getObject() {
        return object;
    }

    public Node getNext() {
        return next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "pro=" + pro +
                ", object=" + object +
                ", next=" + next +
                '}';
    }
}

public class MyLinkedList {
    //链中一定有一个首节点
    Node first;
    //链中一定有一个尾节点
    Node last;
    //计数器
    int count = 0;
    //提供一个构造器
    public MyLinkedList(){

    }
    //添加元素方法
    public void add(Object o){
        if(first == null){//证明添加的元素是第一个节点
            Node n = new Node();
            n.setPro(null);
            n.setObject(o);
            n.setNext(null);
            //当前链中第一个节点变为n
            first = n;
            //当前链中最后一个节点变为n
            last = n;
        }else{
            Node n = new Node();
            n.setPro(last);//n的上一个节点一定是当前链中的最后已个节点last
            n.setObject(o);
            n.setNext(null);
            //当前链中最后一个节点的下一个元素 要指向n
            last.setNext(n);
            //将最后一个节点变为n
            last = n;
        }
        //链中元素数量加1
        count++;
    }

    //得到集合中元素的数量
    public int getSize(){
        return count;
    }

    //通过下标得到元素
    public Object get(int index){
        //获取链表的头元素
        Node n = first;
        //一路next得到想要的元素
        for(int i = 0;i<index; i++){
            n = n.getNext();
        }
        return n.getObject();
    }
}

public class Test {
    public static void main(String[] args) {
        //创建一个集合对象
        MyLinkedList ml = new MyLinkedList();
        ml.add("aa");
        ml.add("bb");
        ml.add("cc");
        System.out.println(ml.getSize());
        System.out.println(ml.get(0));
        System.out.println(ml.get(1));
        System.out.println(ml.get(2));
    }
}

4 泛型和工具类

1）泛型引入

泛型（Generic）相当于标签

形式：<>

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决，因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的。因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。

Collection，List，ArrayList 这个就是类型参数，即泛型。

如果不使用泛型的话，有缺点：
一般我们在使用的时候基本上往集合中存入的都是相同类型的数据 —>便于管理，所以现在什么引用数据类型都可以存入集合—>不方便！

加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合。

//创建一个ArrayList集合，向这个集合中存入学生的成绩
        ArrayList<Integer> al = new ArrayList<Integer>();
        al.add(78);
        al.add(67);
//        al.add("ssa");//报错
        //对集合遍历
        //方式1
        for(Object obj:al){
            System.out.println(obj);
        }
        //方式2
        for(Integer i:al){
            System.out.println(i);
        }

泛型总结：

JDK1.5以后
泛型实际就是一个<>引起来的参数类型，这个参数类型具体在使用的时候才会确定具体的类型。
使用了泛型以后，可以确定集合中存放数据的类型，在编译时期就可以检查出来。
使用泛型你可能觉得麻烦，实际使用了泛型才会简单，后续的遍历等操作简单。
泛型的类型：都是引用数据类型，不能是基本数据类型。
ArrayList al = new ArrayList(); 在JDK1.7以后可以写为：
ArrayList al = new ArrayList<>(); ----钻石运算符

2）自定义泛型结构

（1）泛型类、泛型接口

【1】泛型类实例化对象

/**
 * GenericTest  泛型类
 * @param 
 *     中，E是一个参数类型，这个类型现在是不确定的，相当于一个占位
 *     但是现在确定的是这个类型一定是一个引用类型，而不是基本数据类型
 */
public class GenericTest <E> {
    int age;
    String name;
    E sex;

    public void a(E n){
    }
    public void b(E[] m){
    }
}

class Test{
    public static void main(String[] args) {
        //GenericTest进行实例化
        //1 实例化的时候 不指定泛型,如果实例化的时候不指定泛型，则认为此泛型为Object类型
        GenericTest genericTest = new GenericTest();
        genericTest.a("abc");
        genericTest.a(12);
        genericTest.a(3.2);

        genericTest.b(new String[]{"a","x","e"});
        //2 实例化时指定泛型  *推荐方式*
        GenericTest<String> genericTest2 = new GenericTest<>();
        genericTest2.sex = "男";
        genericTest2.a("sqw");
        genericTest2.b(new String[]{"a","x","e"});
    }
}

【2】继承情况：

父类指定泛型：

class SubGenericTest extends GenericTest<Integer>{

}
class Demo{
    public static void main(String[] args) {
        //指定父类泛型，那么子类就不需要再指定泛型，可以直接使用
        SubGenericTest sgt = new SubGenericTest();
        sgt.a(12);//Integer类型
    }
}

父类不指定泛型：

class SubGenericTest2<E> extends GenericTest<E>{

}
class Demo2{
    public static void main(String[] args) {
        SubGenericTest2<String> sgt2 = new SubGenericTest2<>();
        sgt2.a("sdf");
        sgt2.sex = "women";
    }
}

【3】注意细节：

泛型类可以定义多个参数类型；
泛型类的构造器写法；
不同的泛型的引用类型不可以相互赋值；
泛型如果不指定，那么就会被擦除，泛型对应的类型为Object类型；
泛型类型中的静态方法，不能使用类的泛型；
不能直接使用E[]的创建。

import java.util.ArrayList;
import java.util.Objects;

/**
 *
 * @param 
 * @param 
 * @param 
 */
public class GenericTest2<A,B,C> {
    A age;
    B name;
    C sex;
    public void a(A a,B b,C c){
        //A[] i = new A[10]; //不可以直接使用E[]创建数组
        A[] i = (A[])new Object[10];//可以先利用Object类型创建数组，再强制转换
    }

    /*public GenericTest2(){
        泛型类构造器这种写法不对
    }*/

    public void b(){
        ArrayList<String> list = null;
        ArrayList<Integer> list2 = null;
       // list = lsit2; 不可赋值
    }

    /*public static int c(A a){//静态方法中出现泛型，报错
        return 1;
    }*/

}