Java集合框架(1)

Java集合框架详解

集合

一、集合的概念：

对象的容器，实现了对对象常用的操作，类似数组功能

二、和数组的区别：

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型 (但是可以装箱)

三、位置：java.util.*

集合所有的类都在这里面

Collection体系集合

Collection父接口

特点：

代表一组任意类型的对象，无序、无下标、不能重复

方法：

boolean add(Object obj);//添加一个对象
boolean addAll(Collection c);//将一个集合中的所有对象添加到此集合中
void clear();//清空此集合中的所有对象
boolean contains(Object o);//检查此集合中是否包含o对象
boolean equals(Object o);//比较此集合是否与指定对象相等
boolean isEmpty();//判断此集合是否为空
boolean remove(Object o);//在此集合中移除o对象
int size();//返回此集合中的元素个数
Object[] toArray();//将此集合转换成数组

使用

List

List子接口

特点：有序、有下标、元素可以重复

方法

void add(int index,Object o);   //index角标
boolean addAll(int index,Collection c);  //将一个集合中的元素添加到此集合中的index位置
Object get(int index);   //返回集合中指定的位置元素
List subList(int fromIndex,int toIndex);//返回fromIndex和toIndex之间的集合元素

List实现类:接口的使用

ArrayList(重点):

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

ArrayList源码分析

DEFAULT_CAPACITY=10; 默认容量大小

​ 注意：如果没用向集合中添加任何元素，它的容量为0 添加一个任意元素之后，变成10

扩容时每次都是原来的1.5倍

elementDate 存放元素的数组

size 实际的元素个数 这个一定是小于它的容量的

add() 添加元素

构造方法:

我们一直调用的无参构造方法:

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

add:

//为第一次操作注释    ////4个反斜杠为扩容时注释
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;  //赋值
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//0
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }//10 与 1(或其他数)比较 取最大的

        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;   //修改次数从0 + 1

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//10-0
            grow(minCapacity);//// 有了第一个之后  大于10时才执行
    }

//数组扩容的实际代码
private void grow(int minCapacity) { //10
        // overflow-conscious code
        int oldCapacity = elementData.length;  //0
        int newCapacity = oldCapacity + (oldCapacity >> 1);// 0 + 0右移一位 还是0
    //// 扩容时   10+10>>1   10>>1==10/2==5   newCapacity变成15
        if (newCapacity - minCapacity < 0)//0-10
            newCapacity = minCapacity;	//如果成立 10
        if (newCapacity - MAX_ARRAY_SIZE > 0) //10 - 无穷(近似认为)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//10
    ////添加第11个元素时，容量变成15
    }

Vector

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

LinkedList

• 链表结构实现，增删快，查询慢 (双向链表) 可以从c++的链表来考虑

LinkedList源码

int size 集合的大小

Node first 链表的头节点

Node last 链表的尾节点

void linkLast(E e) {
        final Node<E> l = last;//局部变量  指向last
        final Node<E> newNode = new Node<>(l, e, null);//(null,e,null)
        last = newNode;  //lsat--->e
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }


private static class Node<E> {
    E item;//item是实际数据
    Node<E> next;//下一个节点
    Node<E> prev;//前一个节点

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

ArrayList 和LinkedList的区别

泛型概述

• Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递

• 常见形式有泛型类、泛型接口、泛型方法

• 语法：

  • <T....>T称为类型占位符，表示一种引用类型

• 好处：

  • (1)提高代码的重用性-----------泛型类方法
  • (2)防止类型转换异常，提高代码的安全性

泛型类接口

泛型类方法

泛型集合

• 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
• 特点
  • 编译时即可检查，而非运行时抛出异常
  • 访问时，不必类型转换(拆箱)
  • 不同泛型之间引用不能相互赋值，泛型不存在多态