1.集合框架-CFANZ编程社区

1.1目录

1.为什么使用集合?

2.集合架构有哪些?

3.List集合

4.ArrayList集合

5.LinkedLIst集合

6.Set集合

7.HashSet集合

8.TreeSet集合

9.Map

10.HashMap集合

11.TreeMap集合

1.2为什么使用集合

数组有缺陷长度固定(一旦数组定义好，数组的长度就无法改变)没有办法动态扩展如果需要改变数组长度,变的很复杂而集合(集合就是用于存储对象的容器)存储数据时是没有长度限制的，是可以动态扩展的。

是否可以自己定义长度可变的容器--当然可以

手撕一个长度可变的容器

//自定义一个自动扩容的容器
public class MyArray3 {
    //声明定义一个Object类型数组
    private Object[] arr;
    //声明一个变量充当数组的下标
    private int size;
    //创建一个无参构造
    public MyArray3() {
    }
    //创建一个有参构造
    public MyArray3(int initSize) {
        //判断传过来的参数是否有误
        if (initSize<0){
            throw new RuntimeException("数组长度有误");
        }
        //将传过来的参数赋值给定义的数组 创建一个定容数组
        arr=new Object[initSize];
    }
    //创建一个存储元素的方法
    public void addData(Object o){
        //判断下标是否超过定容数组的长度
        if (size>=arr.length){
            //数组满了就要扩容  1容器的长度变大变长 2把原来容器的元素复制到新的容器中去
           //Arrays(数组的工具类)  original(起初的 原先的) 将原来的元素扩容到新的地方
            Object[] al = Arrays.copyOf(arr, arr.length * 2);
        }
        //将传递过来的元素存储到数组中来 不能直接传到0的位置这样数值覆盖 就不能创建一个动态扩容的数组了
        //需要声明一个变量初始值为0 然后让其自增
        arr[size]=o;
        size++;
    }
    //创建一个根据传过来的下标 查找元素
    public Object getData(int index){
        //判断下标是否越界
        if (index>=size){
            throw new ArrayIndexOutOfBoundsException("下标越界异常");
        }
        //入过传过来的下标没有越界异常根据这个下标查到元素并返回
        Object o = arr[index];
        return o;
    }

    @Override
    public String toString() {
        return "MyArray3{" +
                "arr=" + Arrays.toString(arr) +
                ", size=" + size +
                '}';
    }
}

测试类

public class TestMyArray3 {
    public static void main(String[] args) {
        MyArray3 myArray3 = new MyArray3(2);
        myArray3.addData("张三");
        myArray3.addData("王五")
        System.out.println(myArray3);
        Object data = myArray3.getData(1);
        System.out.println(data);
    }
}

java官方基于数组根据不同的数据结构创建了多个类这些类统称为集合框架。所以我们说结合框架时就是表示多个类

1.3集合的架构

1.4List集合-ArrayList

1.4.0创建集合对象

//创建一个集合对象如果没有指定集合容器的长度默认为15

List list = new ArrayList();

List list1 = new ArrayList(15);

1.4.1添加操作

public static void main(String[] args) {
    ArrayList<Object> aryt = new ArrayList<>();
    aryt.add("张三");
    aryt.add("张三");
    aryt.add(123);
    aryt.add(null);
    System.out.println(aryt);
    //下标为1的位置添加元素
    aryt.add(1,"王五无");
    System.out.println(aryt);
    ArrayList<Object> aryt2 = new ArrayList<>();
    aryt2.add("java");
    aryt2.add("集合");
    aryt2.add(333);
    aryt2.add(222);
    System.out.println(aryt2);
    //添加多个元素把aryt中的每个元素一一添加到aryt2中
    aryt2.addAll(1,aryt);
    System.out.println(aryt2);
}

1.4.2 删除操作

public static void main(String[] args) {
    ArrayList<Object> arty = new ArrayList<>();
    arty.add("张三");
    arty.add(123);
    arty.add("java");
    arty.add(null);
    System.out.println(arty);
    //删除下标为0的元素
    arty.remove(0);
    System.out.println(arty);
     //删除指定元素
    boolean remove1 = arty.remove("java");
    System.out.println(remove1);
    System.out.println(arty);
    //清空集合中的元素
    arty.clear();
    Syetem.out.println(arty);
}

1.4.3修改操作

public void test(){
    ArrayList<Object> alt = new ArrayList<>();
    alt.add("张三");
    alt.add("java");
    alt.add(21233);
    System.out.println(alt);
    //修改下标为1的元素
    alt.set(1,"王五无");
}

1.4.4查询操作

public static void main(String[] args) {
    ArrayList<Object> alt = new ArrayList<>();
    alt.add("java01");
    alt.add("java02");
    alt.add("java03");
    //根据下标获取元素
    Object o=alt.get(1);
    //获取集合中元素的个数
    System.out.println(o);
    int size = alt.size();
    System.out.println(size);
    //判断元素是否在集合中
    boolean java05 = alt.contains("java05");
    System.out.println(java05);
    //查询元素在集合中第一次出现的位置
    int java03 = alt.indexOf("java03");
    System.out.println(java03);
    //遍历集合中的元素 for循环
    for (int i=0;i< alt.size();i++){
        Object o1=alt.get(i);
        System.out.println(o1);
    }
    //遍历集合中的元素 forEach循环
    for (Object o1:alt){
        System.out.println(o1);
    }
}

1.4.5ArrayList底层源码

ArrayList arrayList = new ArrayList(22);

        //ArraylIst 底层使用的还是Object类型的数组
    //底层无参构造
/*DEFAULTCAPACITY_EMPTY_ELEMENTDATA(默认容量空元素数据)
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}*/

    //底层声明了一个Object类型的数组名字为elementData
    //transient Object[] elementData;
    //底层有参构造
   /*new ArrayList(22) 参数22给了initialCapacity(初始容量)
    public TestArrayList(int initialCapacity) {
            //判断穿过来的参数是否大于0
        if (initialCapacity > 0) {
        //将22初始容量赋值给这个数组长度为22
            this.elementData = new Object[initialCapacity];
            //如果为0初始化一个空数组
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
        //不大于0也不等于0抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }*/
    //======================add("java01")======E理解为Object类型=============
    //底层代码
    //将java01 变量给e 相当于给了elementData[size++]数组的响应位置
    /*public boolean add(E e) {
        //扩容element数组的长度
        ensureCapacityInternal(size + 1); // Increments modCount!!
        //上面已经扩容了判断是否扩容复制完之后size再加加 ++在后先执行在++
        elementData[size++] = e;
        return true;
    }*/
    //=====================indexOf("java02")判断元素在集合中第一次出现的位置

    /*public int indexOf(Object o) {
        //判断传过来的对象是否为空
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
        //不为空执行这个循环
            for (int i = 0; i < size; i++)
            //传过来的对象和数组中的元素进行对比
                if (o.equals(elementData[i]))
                //若有返回元素在数组中的位置
                    return i;
        }
        //没有找到该元素返回-1
        return -1;
    }*/
    //=====================size()求数组的长度=========================
    /*public int size() {
        return size;
    }*/
    //=====================contain("java01")=================
    /*public boolean contains(Object o) {
    //调用indeOf(o) 将java01传过去如果数组没有indexOf(o) >= 0 为false   若有返回true
        return indexOf(o) >= 0;
    }*/

    //=======================get(i)获取指定位置的元素===================
    /*public E get(int index) {
        //rangeCheck(index)方法判断指定位置是否合法传过来的参数index可能超过下标或为负数
        rangeCheck(index);
        //调用elementData(index)方法并传参
        return elementData(index);
    }*/
    /*E elementData(int index) {
        //返回elementData[index];这个下标的元素
        return (E) elementData[index];
    }*/
    //=================toString()为什么不打印引用对象的地址=============
    //重写了object里面的toString()方法
    /*public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }*/
    //通过对ArrayList方法的底层代码分析：底层就是对数组的操作
   //ArrayList的底层就是基于数组实现的

1.5LinkedList

LinkedList是一个链表结构

1.5.1添加

//LinkedList是链表结构
public static void main(String[] args) {
    //LinkedList底层不是数组不在指定长度
    LinkedList linkedList = new LinkedList();
    //不加First Last 默认添加到数组的尾部
    linkedList.add("java01");
    //添加元素到头部
    linkedList.addFirst("java02");
    //也重写了toString方法
    System.out.println(linkedList);
    //添加元素到尾部
    linkedList.addLast("java03");
    //代码从上往下执行 java04在元素的头部
    linkedList.addFirst("java04");
    //代码从上往下执行 添加元素到尾部
    linkedList.addLast("java05");
    System.out.println(linkedList);
}

1.5.2 删除

//移除头部元素
linkedList.removeFirst();
System.out.println(linkedList);
//移除指定下标元素
linkedList.remove(3);
//移除尾部元素
System.out.println(linkedList);
//清空所有元素
linkedList.clear();
System.out.println(linkedList);

1.5.3修改操作

linkedList.set(2,"张三");
System.out.println(linkedList);

1.5.4查询操作

//查询长度
int size = linkedList.size();
System.out.println(size);
//是否为空
boolean empty = linkedList.isEmpty();
System.out.println(empty);
//是否含有某元素
boolean contains = linkedList.contains("张三");
System.out.println(contains);
//根据下标获取指定位置的元素
Object o = linkedList.get(1);
System.out.println(o);
//获取第一个元素
Object first = linkedList.getFirst();
System.out.println(first);
//获取最后一个元素
Object last = linkedList.getLast();
System.out.println(last);