集合类-CSDN博客

本文链接：https://blog.csdn.net/lmj13639154026/article/details/112846806

集合类的常用集合

泛型
Collection（单列集合）
Map
- HashMap

泛型

1、作用

1、通过泛型的语法定义，约束集合元素的类型，进行安全检查，把错误显示在编译期
2、代码通用性更强，后面有案例
3、泛型可以提升程序代码的可读性，但它只是一个语法糖（编译后这样的东西就被删除，不出现在最终的源代码中），对于JVM运行时的性能是没有任何影响的。

2、泛型的声明

1，泛型的标志<>
2，泛型的好处：规定了数据的类型，不能想放什么数据就放什么类型，要遵守泛型规定的类型
3，泛型的数据类型只能是引用类型，不能是基本类型
4，如果类型不对，把运行时期才会报的错ClassCastException直接在编译时期就报出来

public interface Collection<E> {}  //修饰在接口上
public static<E> void test(E[] arr){} //修饰在方法上
HashMap<Integer,String> hm  = new HashMap();  //修饰在引用类型上

常用的名称

E–Element 适合所有的数据类型
T–Type java类
K–Key 键
V–Value 值
N–Number 数值类型

Collection（单列集合）

用来存放对象的数据结构，其中长度可变，而且集合中可以存放不同类型的对象。
数组的缺点：长度是固定不可变的，访问方式单一，插入、删除等操作繁琐

在这里插入图片描述

List

特点：1、数据有序。
2、允许元素重复。
3、元素都有索引

ArrayList

1）存放于java.util包中。
2）内部用数组存放数据，封装了数组的操作，每个对象都有下标
3）内部数组默认初始容量是10，如果不够会以1.5倍容量增长
4）查询快，增删数据效率会降低。

public class ArrayListDemo {
    public static void main(String[] args) {
 ArrayList list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add("hello");
        list.add(1.11);
        ArrayList list1 = new ArrayList();
        list1.add(444);
        list1.add(555);
        //是否包含111，包含返回true
        System.out.println(list.contains(111));
        //返回List的大小
        System.out.println(list.size());
        //根据索引返回对应的值
        System.out.println(list.get(1));
        //根据对应的值返回索引
        System.out.println(list.indexOf(222));
        //最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
        System.out.println(list.lastIndexOf(1.11));
        //根据索引替换对应的值
        System.out.println(list.set(4,"world"));
        //判断是否为空列表
        System.out.println(list.isEmpty());
        //将list1复制给list,5是开始复制的索引
        list.addAll(5,list1);
        //根据索引删除元素
        System.out.println(list.remove(0));
        //自动装箱,如果不装箱会默认认为是索引值
        System.out.println(list.remove(new Integer(444)));
        //删除所有元素
//        System.out.println(list.removeAll(list));
        //清空所有元素
//        list.clear();

//遍历集合元素的三种方式
          //第一种
            //Iterator迭代遍历，封装了下标
	       Iterator it = list.listIterator();  //区别：可以使用父接口的功能，同时拥有自己的特有功能，不仅顺序向后迭代还可以逆向迭代
	       while (it.hasNext()){  //如果有数据
	           System.out.println(it.next());  //一个一个向后遍历
	       }
		  //第二种	
//        for (int i=0;i<list.size();i++){
//            System.out.println(list.get(i));
//        }

		 //第三种
//        for(Object e:list){
//            System.out.println(e);
//        }
		
   }
}

LinkedList

特点：增删效率快，迭代器遍历效率高，双向链表。底层就是数组和链表实现的。

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(111);
        list.add(333);
        list.add(444);
        list.add(1,666);
        list.add(555);
        list.addFirst("hello");
        list.addLast("world");
        //判断是否包含指定元素，包含返回true，不包含返回-1
        System.out.println(list.contains(444));

        // 返回此 LinkedList 的浅表副本。
        System.out.println(list.clone());

        //获取但不移除此列表的头
        System.out.println(list.element());

        //根据指定索引返回元素
        System.out.println(list.get(2));

        //获取第一个元素
        System.out.println(list.getFirst());

        //获取最后一个元素，不需要索引
        System.out.println(list.getLast());

        //指定最后一个元素返回索引位置
        System.out.println(list.lastIndexOf("world"));

        //指定元素返回索引，没有返回-1
        System.out.println(list.indexOf(555));

        //根据指定元素添加到列表的末尾
        System.out.println(list.offer(777));
        System.out.println(list.offerLast(888));

        //根据指定元素添加到列表的开头
        System.out.println(list.offerFirst("my"));

        //获取但不移除此列表的头,和element相同
        System.out.println(list.peek());

        //获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
        System.out.println(list.peekFirst());

        //获取但不移除此列表的最后一个元素，如果此列表为空，则返回null
        System.out.println(list.peekLast());

        //替换元素
        System.out.println(list.set(3,222));

        //返回列表大小
        System.out.println(list.size());

        //根据索引删除元素
        System.out.println(list.remove(0));
        System.out.println(list);

		//顺向迭代遍历
//        Iterator a = list.listIterator();
//        while (a.hasNext()){
//            System.out.println(a.next());
//        }
        //逆向迭代遍历
//        Iterator di  = list.descendingIterator();
//        while (di.hasNext()){
//            System.out.println(di.next());
//        }
    }
}

Set

特点：无序去重，无下标

public class SetDemo {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("Hello");
        set.add("b");
        set.add("world");
        set.add("a");
        set.add("b");
        set.add("n");
        System.out.println(set);
        
        //迭代器
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

HashSet

实现了Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序；
特别是它不保证该顺序很久不变。此类允许使用null元素。

public class HashSetDemo1 {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add("a");
        hs.add("g");
        hs.add("f");
        hs.add("b");
        hs.add("g");
        hs.add("h");
        hs.add("j");
        
        System.out.println(hs.isEmpty());
        System.out.println(hs.size());
        System.out.println(hs.contains("b"));
        System.out.println(hs.remove("h"));
        System.out.println(hs);  //无序不重复
        
        Iterator it = hs.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

Map

特点：
可以根据键提取对应的值
键不允许重复，如果重复值会被覆盖
存放的都是无序数据
初始容量是16，默认的加载因子是0.75

在这里插入图片描述

HashMap

HashMap<Integer,String> hm  = new HashMap();
        hm.put(100,"卡哇伊~");
        hm.put(101,"哟西哟西");
        hm.put(102,"索嘎");
        hm.put(103,"西内~！");
        hm.put(104,"雅蔑蝶!!!");
        //返回指定键所映射的值，如果没有则返回null
        System.out.println(hm.get(102));
        //是否包含键103
        System.out.println(hm.containsKey(103));
        //是否为空
        System.out.println(hm.isEmpty());
        //是否包含映射的值--雅蔑蝶！！！
        System.out.println(hm.containsValue("雅蔑蝶!!!"));
        //返回长度
        System.out.println(hm.size());
        //根据键删除值
        hm.remove(102);

		
        HashMap<Integer,String> hm1  = new HashMap();
        hm1.put(105,"球都麻蝶!");
        hm1.put(106,"八嘎雅鹿!");
        hm.putAll(hm1);   //将hm1的所有值复制给hm
        System.out.println(hm);
//遍历元素的方式1
        Set set = hm.keySet();
        System.out.println(set);
        Iterator it = set.iterator();
        while (it.hasNext()){
            Integer a = (Integer) it.next();
            String b = hm.get(a);
            System.out.println(a+"---"+b);
        }

//遍历元素的方式2
        Set<Map.Entry<Integer,String>> set = hm.entrySet();
        for (Map.Entry<Integer,String>entry:set){
            Integer a = entry.getKey();
            String b = entry.getValue();
            System.out.println(a+"---"+b);
        }



//遍历元素的方式3
        Set<Integer> set = hm.keySet();
        for (Integer a:set){
            String value = hm.get(a);
            System.out.println(a+"---"+value);