Java学习笔记（七）之集合_new hashset<string>() {}-CSDN博客

本文链接：https://blog.csdn.net/qq_26498311/article/details/109693102

集合

HashSet集合

HashSet是Set接口的典型实现，我们大多数时候说的set集合指的都是HashSet。

HashSet具有以下特点：

不能保证元素的排列顺序 ------>存在set集合哪个位置由这个值的hashCode决定
不可重复------->不可重复，指的是hashCode不相同
HashSet不是线程安全的
集合元素可以是null

public class Test {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add(1);  //添加元素
        set.add("aaa");
        set.remove(1);  //移除元素
        System.out.println(set);

        boolean a = set.contains("aaa");  //判断是否包含元素
        System.out.println(a);

        set.clear();  //清空集合
        System.out.println(set);

        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        set.add(null);

        //使用迭代器遍历集合
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //for-each迭代集合，推荐使用这种
        for (Object obj : set) {  //这个的意思是说把set的每一个值取出来赋值给obj，直到循环set的所有值
            System.out.println(obj);
        }

        System.out.println(set.size());  //获取集合的元素个数

        //如果想要让集合只能存同样类型的对象，怎么做？
        //使用泛型
        Set<String> set1 = new HashSet<String>();  //比如指定String为集合的泛型,就只能存放String类型的元素
        set1.add("aaaa");
    }
}

TreeSet集合

TreeSet是SortedSet接口的实现类。

TreeSet可以确保集合元素处于排序状态，支持两种排序方法：自然排序和定制排序，默认情况下，TreeSet采用自然排序。

自然排序：

public class Test1 {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        //TreeSet自然排序
        set.add(3);
        set.add(2);
        set.add(7);
        set.add(6);

        System.out.println(set);  //输出：[2, 3, 6, 7]
    }
}

定制排序：

public class Person implements Comparator<Person> {
    int age;
    String name;

    public Person() {
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public int compare(Person o1, Person o2) {
        if (o1.age > o2.age) {  //年龄正序排列
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}

public class Test1 {
    public static void main(String[] args) {

        Person p1 = new Person(25, "张三");
        Person p2 = new Person(21, "李四");
        Person p3 = new Person(29, "王五");
        Person p4 = new Person(22, "赵六");

        Set<Person> set1 = new TreeSet<>(new Person());
        set1.add(p1);
        set1.add(p2);
        set1.add(p3);
        set1.add(p4);

        for (Person p : set1) {
            System.out.println(p.name + "   " + p.age);  
//            输出： 李四   21
//                  赵六   22
//                  张三   25
//                  王五   29
        }
    }
}

List集合：

public class Test2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("aa");
        System.out.println(list);
        System.out.println(list.get(3));  //通过下标获得元素

        list.add(2, "123"); //从指定下标位置插入元素
        System.out.println(list);
        
        System.out.println(list.indexOf("aa"));  //通过指定元素获得元素第一次出现的下标
        System.out.println(list.lastIndexOf("aa"));  //通过指定元素获得元素最后一次出现的下标

        List<String> list1 = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list.addAll(2, list1);  //在指定下标位置插入集合
        System.out.println(list);

        list.remove(2);  //移除指定下标的元素
        System.out.println(list);

        list.set(0, "王五");  //修改指定下标的元素
        System.out.println(list);

        List<String> subList = list.subList(2, 4); //根据下标的起始位置截取一段元素形成新的集合，遵循左闭右开原则
        System.out.println(subList);

    }
}

Map集合：

public class Test3 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("1", "aa"); //添加数据
        map.put("2", "bb");
        map.put("3", "cc");
        map.put("4", "dd");

        System.out.println(map);
        System.out.println(map.get("2"));  //根据key取值

        map.remove("3");  //根据key移除键值对
        System.out.println(map);
        System.out.println(map.size()); //map集合长度
        System.out.println(map.containsKey("2"));  //判断当前的map集合是否包含指定的key
        System.out.println(map.containsValue("ee")); //判断当前的map集合是否包含指定的value

        Set<String> keys = map.keySet();//获取map集合的key集合
        System.out.println(keys);
        Collection<String> values = map.values();//获取map集合的所有value值
        System.out.println(values);

        //通过map.keySet(),遍历map集合
        for (String key : keys) {
            System.out.println("key:" + key + "," + "value:" + map.get(key));
        }

        //通过map.entrySet(),遍历map集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> en : entries) {
            System.out.println("key:" + en.getKey() + "," + "value:" + en.getValue());
        }
    }
}

操作集合的工具类：Collections

public class Test4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("ab");
        list.add("abc");
        list.add("abcd");
        list.add("1");

        System.out.println(list);

        Collections.reverse(list); //反转list中元素顺序
        System.out.println(list);

        Collections.shuffle(list); //对list中元素进行随机排序
        System.out.println(list);

        Collections.sort(list);  //list集合元素升序排列
        System.out.println(list);

        Collections.swap(list, 2, 3); //将指定list集合中的i处元素和j处元素进行交换
        System.out.println(list);

        System.out.println(Collections.max(list));  //返回集合中最大元素
        System.out.println(Collections.min(list));  //返回集合中最小元素
        System.out.println(Collections.frequency(list, "a")); //返回当前集合中指定元素出现的次数

        Collections.replaceAll(list, "a", "lol");  //使用新值替换list对象的所有旧值
        System.out.println(list);

//        Student s1 = new Student(23, "张三");
//        Student s2 = new Student(13, "李四");
//        Student s3 = new Student(18, "王五");
//        Student s4 = new Student(27, "赵六");
//
//        List<Student> list = new ArrayList<>();
//        list.add(s1);
//        list.add(s2);
//        list.add(s3);
//        list.add(s4);
//
//        for (Student s : list) {
//            System.out.println(s.name + "," + s.age);
//        }
//        System.out.println("==============");
//        Collections.sort(list, new Student());
//        for (Student s : list) {
//            System.out.println(s.name + "," + s.age);
//        }
    }
}

class Student implements Comparator<Student> {

    int age;
    String name;

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

    public Student() {
    }

    @Override
    public int compare(Student o1, Student o2) {  //根据年龄升序排列对象
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}