集合容器!

集合|容器

一.集合|容器

集合|容器

​ 作用:存储多个数据

数组:

​ 数组是一个引用数据类型

​ 定长,长度一旦确定不可改变

​ 储存任意类型的数据但是,数据类型保持一致

​ 有序,有索引从0开始

容器:

​ 可以随着数据的增删改变容量

​ 可以储存任意引用数据类型

1.List

List接口继承了Collection接口

List 有序可以重复

新增内容:新增了一些根据索引操作的方法

public class Class001_List {
    public static void main(String[] args) {
        //创建一个集合
        //泛型: 增强程序的稳定性与可读性
        //强制检测数据的类型
        //使用: 在类型的后面添加<类型>
        //规定当前集合对象中存储的所有数据的类型为String
        List<String> list = new ArrayList<>();
        list.add("宋刚");
        list.add("季鹏");
        list.add("陈浩");
        list.add("浩然");

        System.out.println(list);
        list.add(2,"义本");
        System.out.println(list);

        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。
        System.out.println(list.set(2,"石义本"));;
        System.out.println(list);

        //E remove(int index) 删除此列表中指定位置的元素（可选操作）。
        System.out.println(list.remove(1));
        System.out.println(list);

        //E get(int index) 返回此列表中指定位置的元素。
        System.out.println(list.get(0));

        //int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.indexOf("陈浩"));

        //static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
        List<Integer> list1 = List.of(1,2,3,4,5);
        System.out.println(list1);
        //System.out.println(list1.remove(1));  //UnsupportedOperationException 运算操作不支持

        //List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
        List<String> list2 = list.subList(1,3);
        System.out.println(list2);
    }

List 有序可重复

遍历方法:

public class Class002_each {
    public static void main(String[] args) {
        //创建一个集合n
        //规定当前集合对象中存储的所有数据的类型为String
        List<String> list = new ArrayList<>();
        list.add("美国队长");
        list.add("钢铁侠");
        list.add("浩克");
        list.add("灭霸");
        list.add("蜘蛛侠");

        System.out.println(list);

        //1.contains
        /*if(list.contains("灭霸")){
            list.add("惊奇队长");
        }
        System.out.println(list);*/

        //2.普通for
        /*for(int i=0;i<=list.size()-1;i++){
            if("灭霸".equals(list.get(i))){
                list.add("惊奇队长");
            }
        }*/

        //3.for each
        //ConcurrentModificationException
        /*for(String s:list){
            if("灭霸".equals(s)){
                list.add("惊奇队长");
            }
        }*/

        //4.iterator
        //ConcurrentModificationException
       /* Iterator<String> it = list.iterator();
        while(it.hasNext()){
            if("灭霸".equals(it.next())){
                list.add("惊奇队长");
            }
        }*/

        //5.ListIterator<E> listIterator() 返回此列表中元素的列表迭代器（按适当顺序）。
        //1)获取列表迭代器对象
        /*ListIterator<String> it2 =  list.listIterator();
        //2)判断是否存在下一个或者上一个元素
        while(it2.hasNext()){
            if("灭霸".equals(it2.next())){
                it2.add("惊奇队长");
            }
        }*/
        //System.out.println(list);


        //通过列表迭代器 反向遍历
        //ListIterator<E> listIterator(int index) 从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
        ListIterator<String> it3 = list.listIterator(list.size());
        while(it3.hasPrevious()){
            System.out.println(it3.previous());
        }
    }
}

2.ArrayList

ArrayList 是List接口的实现类
特点: 有序 可重复

ArrayList :
底层结构: 可变数组
优点: 根据索引查询效率高,访问速度快
缺点: 增删涉及到数组的拷贝问题等效率较低
应用场景: 大量做查询,少量做增删的情况下适合使用ArrayList存储数据
扩容: 初始容量为10,扩容机制->int newCapacity = oldCapacity + (oldCapacity >> 1); 每次扩容原容量的1.5倍,利用Arrays.copyOf实现扩容
新增方法: void forEach(Consumer<? super E> action) 对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。

​ //定义一个ArrayList,测试使用
​ //存储自定义的引用数据类型的数据 Student类型->操作使用

Vector 向量
特点: 有序 可重复
底层结构特点与ArrayList相同
Vector 与 ArrayList 区别:
1)ArrayList 线程不安全,不同步->效率较高 Vector 是线程安全,同步 -> 效率较低
2)ArrayList->每次扩容原容量的1.5倍 Vector 每次扩容原容量的2倍,ArrayList更有利于内存的节约

public class Class003_ArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        System.out.println(list);
        for(Integer i:list){
            System.out.println(i);
        }

        //foreach
        list.forEach(System.out::println);
    }
}

3.LinkedList

LinkedList
特点: 有序 可重复

​ 底层结构: 双向链表
​ 优点 : 做查询效率较低
​ 缺点 : 做增删效率较高
​ 应用场景 : 大量做增删少量做查询推荐使用LinkedList
​ 新增功能 : 新增了一些可以操作链表头尾的方法

//自定义一个链表,存储自定义引用数据类型的数据,简单操作测试

public class Class004_LinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();

        /*list.add("aaa");
        list.add("bbb");
        list.add("ccc");*/

        System.out.println(list);

        list.addFirst("111");
        list.addLast("555");
        System.out.println(list);

        System.out.println(list.getFirst());
    }
}

4.Srt

Set 无序 不可重复|去重
新增方法: Set of(E… elements)返回包含任意数量元素的不可修改集。
无序: 存放的顺序与内部真实存储的顺序不一致(内部与自己存储的规则)
去重: 两个数据调用equals方法返回值true,相同需要去重,false不同可以添加
遍历方式 :
1.for each
2.迭代器 iterator
*/

public class Class001_Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(123);
        set.add(123);
        set.add(123);
        set.add(123);
        System.out.println(set);

        Set<String> set2 = new HashSet<>();
        set2.add("哈哈");
        set2.add("ab");
        set2.add("呵呵");
        set2.add("bd");
        set2.add("a");
        set2.add("吼吼");
        System.out.println(set2);

        //static <E> Set<E> of(E... elements) 返回包含任意数量元素的不可修改集。
        Set<Integer> set3 = Set.of(1,2,3,4,5);
    }
}

5.HashSet

HashSet
底层结构: 哈希表 (数组+链表+红黑树) ->是由HashMap维护
优点 : 查询,增删效率较高
缺点 : 无序
应用场景: 实现不存储相同数据,查询,增删效率较高的时候建议使用HashSet
新增功能: 无新增功能

定义一个哈希表结构,存储自定义引用数类型的数据Person,实现去重(所有两个对象成员变量的值都想等,就应该去重)

public class Class002_HashSet {
    public static void main(String[] args) {
        HashSet<String> hash = new HashSet();
    }
}