集合框架总结-CSDN博客

本文链接：https://blog.csdn.net/m0_67193029/article/details/124202905

List列表

特点：
有序集合（也称为序列）。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

可以简单的理解成和数组的使用方式差不多，存储到List中的数据有顺序的并且可以通过索引编号对其进行操作

ArrayList 快速数组创建

public class ArraList {
    //数组的创建
    public void test(){
        List list1=new ArrayList();
    }

ArrayList 添加数据

//添加关键字:add

public static void main(String[] args) {

    List list2=new ArrayList();
    list2.add(1);
    list2.add(2);
    list2.add(3);
    list2.add(1,"孙悟空");
    System.out.println(list2);

}

输出结果：[1, 孙悟空, 2, 3]

ArrayList 删除数据

//删除关键字：remove

public static void main(String[] args) {

    List list2=new ArrayList();
    list2.add(1);
    list2.add(2);
    list2.add(3);
    list2.remove(2);//删除下标为2的元素
    System.out.println(list2);
//输出结果为：[1, 2]

}

ArrayList 修改数据

//修改关键字：set

public static void main(String[] args) {

    List list2=new ArrayList();
    list2.add(1);
    list2.add(2);
    list2.add(3);
    list2.set(2,"猪八戒");//修改下标为2的元素
    System.out.println(list2);
//输出结果为：[1, 2, 猪八戒]

}

ArrayList查询数据

//查询关键字：contains

public static void main(String[] args) {

    List list2=new ArrayList();
    list2.add(1);
    list2.add(2);
    list2.add(3);
    int size = list2.size();
    System.out.println(size); //size:求数组中的个数
        输出结果为：3
//判断孙悟空是否在数组集合中，有输出ture无,为false
boolean contains = list2.contains("孙悟空");
System.out.println(contains);

}

遍历数组

public static void main(String[] args) {

List list2=new ArrayList();

list2.add(1);

list2.add(2);

list2.add(3);

for (int i = 0; i < list2.size(); i++) {
            Object o1 = list2.get(i);
            System.out.println(o1);
        }

        /* js 中的 for-in */
        for (Object o1 : list2) {
            System.out.println(o1);
        }
    }

输出结果为1.2.3

LinkedList的创建

public class Link {
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList();

}

LinkedList的数据添加

public static void main(String[] args) {
    LinkedList linkedList=new LinkedList();
    //增加关键字：add
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add("王五");
    linkedList.add("赵六");
    linkedList.add("王八");
    //增加元素在第一位
    linkedList.addFirst("哈喽");
 System.out.println(linkedList);
输出结果：[哈喽, 张三, 李四, 王五, 赵六, 王八]
    //增加元素在最后一位
    linkedList.addLast("嗨");
 System.out.println(linkedList);
输出结果：[哈喽, 张三, 李四, 王五, 赵六, 王八, 嗨]
    System.out.println("=========");
    //将整个数组添加，关键字:addAll
LinkedList linkedList1=new LinkedList();
linkedList1.add("白龙马");
linkedList1.add("小龙女");
linkedList.addAll(linkedList1);
System.out.println(linkedList);
输出结果：[哈喽, 张三, 李四, 赵六, 王八, 嗨, 白龙马, 小龙女]

}

LinkedList的数据删除

public static void main(String[] args) {
    LinkedList linkedList=new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add("王五");
    linkedList.add("赵六");
    linkedList.add("王八");
linkedList.remove(3);//删除下标为3的元素
System.out.println(linkedList);
输出结果：[ 张三, 李四, 王五, 王八]
//删除第一个元素
linkedList.removeFirst();
System.out.println(linkedList);
输出结果：[李四, 王五, 赵六, 王八]

}

LinkedList的数据修改

public static void main(String[] args) {
    LinkedList linkedList=new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add("王五");
    linkedList.add("赵六");
linkedList.set(0,"猪八戒");//修改第一个元素
System.out.println(linkedList);
输出结果：[ 猪八戒, 李四, 王五, 赵六, 王八]
}

LinkedList的数据查找

public static void main(String[] args) {
    LinkedList linkedList=new LinkedList();
    //增加
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add("王五");
    linkedList.add("赵六");
    linkedList.add("王八");
//查找集合里面是否有孙悟空，有为true,没有为false

boolean chazhao=linkedList.contains("孙悟空");
System.out.println(chazhao);
//输出结果：false
//查找集合里面是否有李四，有为true,没有为false

boolean chazhao2=linkedList.contains("李四");
System.out.println(chazhao2);
//输出结果：true
}

HashSet

HashSet的数据创建

public class Test1 {
    public static void main(String[] args) {
        //容器大小如果未定义，默认大小为16，负载因子为0.75
        HashSet hashSet=new HashSet();
    }
}

HashSet的数据添加

public class Test1 {
    public static void main(String[] args) {
        HashSet hashSet=new HashSet();
//添加关键字：add、addAll
      //HashSet是无序，不可重复的，两个同名元素只会出现一次
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("张三");
        hashSet.add("赵六");
        hashSet.add("黄七");
        System.out.println(hashSet);
输出结果：[李四, 张三, 王五, 赵六, 黄七]
        HashSet hashSet1=new HashSet();
        hashSet1.add("孙悟空");
        hashSet1.add("猪八戒");
        hashSet.addAll(hashSet1);
       System.out.println(hashSet);
输出结果：[李四, 张三, 王五, 孙悟空, 赵六, 猪八戒, 黄七]
}
}

HashSet的数据删除

public class Test1 {
    public static void main(String[] args) {
        HashSet hashSet=new HashSet();
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("赵六");
        hashSet.add("黄七");
//删除关键字：remove
//removeAll:清空所有元素
       hashSet.remove("李四");
      System.out.println(hashSet);
输出结果：[ 张三, 王五, 赵六, 黄七]
    }
}

HashSet的数据查询

public class Test1 {
    public static void main(String[] args) {
        HashSet hashSet=new HashSet();
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("赵六");
        hashSet.add("黄七");
        System.out.println(hashSet);
//查询数组内是否为空
     boolean empty = hashSet.isEmpty();
     System.out.println(empty);
//判断王五是否在容器里面，是为true，没有则为false
boolean ww = hashSet.contains("王五");
System.out.println(ww);
//遍历数组
   for (Object O:hashSet){
       System.out.println(O);
//迭代器遍历
      Iterator iterator = hashSet.iterator();
   while (iterator.hasNext()){
       Object next=iterator.next();
    System.out.println(next);
}
    }
}

TreeSet

tree底层是一个二叉树结构，可以实现有序集合，但需要比较器进行实现

特点：有序、不重复、添加删除，判断元素效率较高、但是线程不安全。

TreeSet对元素进行排序的方式：

1.如果是基本数据类型和String类型，无需其他操作，直接进行排序。

2.对象类型元素排序，需要实现Comparable接口，并覆盖Compare To 方法。

3.自己定义实现了Comparato接口的排序类，并将其传给TreeSet，实现自定义排序规则。

例：存储String类型

public class Test2 {
    public static void main(String[] args) {
        TreeSet treeSet=new TreeSet();
        treeSet.add("a1");
        treeSet.add("a5");
        treeSet.add("a3");
        treeSet.add("a4");
        treeSet.add("a2");
        System.out.println(treeSet);
        输出结果：[a1, a2, a3, a4, a5]
    }
}

存储对象类型

public class Test04 {
    public static void main(String[] args) {
        TreeSet treeSet=new TreeSet(); //TreeSet不允许重复元素
        treeSet.add(new Student("张三",17));
        treeSet.add(new Student("李四",16));
        treeSet.add(new Student("王五",16));
        treeSet.add(new Student("赵六",15));

        System.out.println(treeSet);
    }
}
class Student implements Comparable{
     private String name;
     private Integer age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    //排序：---返回如果大于0 表示当前元素比o大  如果返回-1 当前添加的元素比o小  返回0表示相同元素。
    @Override
    public int compareTo(Object o) {
        Student student= (Student) o;
        System.out.println(this+"===================>"+o);

        if(this.age>student.age){
            return 1;
        }
        if(this.age<student.age){
            return -1;
        }

        return 0;
    }
}