JavaSE# 笔记【Collections工具类 Comparator比较器 可变参数 Set接口及子类 Map接口】@Gray

1.Collections工具类

Collections概述：

Collections工具类提供了一些操作集合的静态方法。

常用方法：

方法	说明
static void shuffle(List<?> list)	随机打乱集合元素的顺序
static void sort(List list)	集合的排序(从小到大)
static void sort(List list，Comparator<? super T> )	按照指定的方式排序

看参数,它仅仅适用于List接口下的实现类.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        //创建集合
        List<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(44);
        list.add(77);
        list.add(22);
        list.add(99);

        //static void shuffle(List<?> list)随机打乱集合元素的顺序
        // Collections.shuffle(list);
        // System.out.println(list);

        //static <T> void sort(List<T> list)集合的排序(从小到大) 升序
        // Collections.sort(list);
        // System.out.println(list);

        //创建集合保存字符串
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("abc");
        list02.add("aac");
        list02.add("acb");
        list02.add("def");
        list02.add("aca");

        Collections.sort(list02);
        System.out.println(list02); //aac  abc aca acb def

    }
}

2.Comparator比较器

• compare方法的解释
  ​compare方法是对元素做比较的方法,在元素两两比较的时候会自动调用这个方法.
• 整数类型从大到小排列

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        //创建集合 保存整数
        List<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(44);
        list.add(77);
        list.add(22);
        list.add(99);

        Collections.sort(list); //默认 升序（从小到大）

        System.out.println(list);

        //按照指定的方式排序
        /*
            参数1：list  要排序的集合。
            参数2：排序比较器。由比较器可以决定升序或降序
         */
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            /*
                排序的规则：
                    o1 - o2  升序 (从小到大)
                    o2 - o1  降序（从大到小）
             */
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        System.out.println(list);

        //****************************************************************
        //创建集合保存字符串
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("abc");
        list02.add("aac");
        list02.add("acb");
        list02.add("def");
        list02.add("aca");

        Collections.sort(list02);
        System.out.println(list02);

        //按照指定的方式排序
        Collections.sort(list02, new Comparator<String>() {
            @Override
            /*
                排序的规则：
                    o1 - o2  升序 (从小到大)
                    o2 - o1  降序（从大到小）
             */
            public int compare(String o1, String o2) {
                //return o2.charAt(0) - o1.charAt(0);
                return o2.compareTo(o1);
            }
        });

        System.out.println(list02);
    }
}

3.可变参数(重点)

• 作用

  • 可变参数指的是参数的数量可变。

• 示例代码:

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

        //可变参数支持传递0到n个参数
        // sum();
        // sum(1, 2);
        // sum(1,2,3,4,5);
        int[] arr = {1,2,3,4,5};
        sum(arr);
    }

    //需求：编写一个方法，计算多个整数的和
    //可变参数的语法： 数据类型... 变量名
    //可变参数本质就是一个数组。
    //可变参数支持传递0到n个参数
    //既然可变参数本质是数组，那么是否可以传递数组？可以
    public static void sum(int... a) {
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        System.out.println(sum);
    }

    //注意：一个方法只能定义一个可变参数，且必须放在参数列表的最后。
    public static void method(String s,int... a) {

    }

}

• 注意事项

  1. 可变参数的本质是数组，可变参数使用时直接当做数组使用。
  2. 可变参数可以接受任意个参数, 也可以接受数组形式的参数。
  3. 一个方法只能有一个可变参数，可变参数必须放在参数列表的最后。

• 可变参数的应用场景：给集合批量添加数据

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        Collections.addAll(list, "3","4","J","K");

        Collections.addAll(list, "A","Q","10","9","6");

        System.out.println(list);

    }
}

4.Set接口及子类（重点）

1 HashSet集合

1.1 特点:

​ 无序、不可重复、没有索引

import java.util.HashSet;
import java.util.Set;

/*
    特点：无序、不可重复、没有索引
 */
public class Test01 {
    public static void main(String[] args) {
        //创建一个Set集合
        Set<String> set = new HashSet<>();
        set.add("古力娜扎");
        set.add("迪丽热巴");
        set.add("玛尔扎哈");
        set.add("杨幂");
        set.add("迪丽热巴");

        System.out.println(set);

    }
}

1.2 HashSet存储自定义类型演示

在使用HashSet存储java中已有的类时，能够自动去重，因为类中都已经重写了hashCode和equals方法

在存储自定义类型时，我们就需要自己重写hashcode和equals方法

import java.util.Objects;
//学生类
public class Student {

    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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


    //idea生成
    //快捷键  alt + insert
    //重写之后 hashCode  和 equals 方法 都是在对成员变量做比较,不是在对地址值做比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}


import java.util.HashSet;
public class Test03 {
    public static void main(String[] args) {
        //集合存储学生对象
        HashSet<Student> set = new HashSet<>();

        //添加
        set.add(new Student("张三",23));
        set.add(new Student("张三",23));
        set.add(new Student("李四",24));
        set.add(new Student("老王",28));


        System.out.println(set);
        //[Student{name='张三', age=23}, Student{name='李四', age=24}, Student{name='老王', age=28}]
    }
}

2 LinkedHashSet集合

• 特点

  • 元素没有索引
  • 元素不可重复
  • 元素存取有序

• 代码演示

import java.util.LinkedHashSet;
public class Test04 {
    public static void main(String[] args) {
        //LinkedHashSet
        //元素没有索引 元素不可重复  元素存取有序
        LinkedHashSet<String> set = new LinkedHashSet<>();

        //添加方法
        set.add("马蓉");
        set.add("马蓉");
        set.add("宋喆");
        set.add("王宝强");

        System.out.println(set);  //[马蓉, 宋喆, 王宝强]
    }
}

5. Map接口（重点）

1. Map集合作用

​ Map表示双列集合，双列集合也叫键值对集合，用来保存一对一的键值对元素。

put(key,value);

2. Map常用方法

方法	说明
V put(K key, V value)	添加键值对
V remove(Object key)	根据键删除对应的键值对
V get(Object key)	根据键获取值
boolean containsKey(Object key)	判断是否包含某个键
boolean containsValue(Object value)	判断是否包含某个值
Set keySet()	把键转换成Set集合
Set<Map.Entry<K,V>> entrySet()	把键值对转成Set集合

代码演示

import javax.jnlp.IntegrationService;
import java.util.HashMap;
import java.util.Map;

public class Test01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String, Integer> map = new HashMap<>();

        //V put(K key, V value)添加键值对
        map.put("迪丽热巴",18);
        map.put("古力娜扎",19);
        map.put("马尔扎哈",20);
        map.put("尼格买提",21);

        //map集合中的key不能重复
        //map.put("古力娜扎",20);

        //V remove(Object key)根据键删除对应的键值对
        map.remove("马尔扎哈");

        //V get(Object key)根据键获取值
        Integer age = map.get("古力娜扎");
        System.out.println(age);

        //boolean containsKey(Object key) 判断是否包含某个键
        boolean b = map.containsKey("古力娜扎");
        System.out.println(b);

        //boolean containsValue(Object value)判断是否包含某个值
        boolean b1 = map.containsValue(19);
        System.out.println(b1);


        System.out.println(map);
    }
}

3. Map的遍历

keySet()键找值方式:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test02 {


    public static void main(String[] args) {
        //创建Map集合
        Map<String, Integer> map = new HashMap<>();

        //V put(K key, V value)添加键值对
        map.put("迪丽热巴",18);
        map.put("古力娜扎",19);
        map.put("马尔扎哈",20);
        map.put("尼格买提",21);

        //Set<K> keySet() 把键转换成Set集合
        Set<String> set = map.keySet();
        //得到迭代器对象
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String key = it.next(); //获得第个key
            Integer value = map.get(key);
            System.out.println(key+"\t"+value);
        }
    }
}

entrySet()键值对方式:

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey(); //获取key
    Integer value = entry.getValue(); //获取value
    System.out.println(key+"\t"+value);
}

4. HashMap集合（存储自定义对象类型数据）

​ 特点：

​ 元素键不能重复，元素存取无序

​ HashMap键不重复也是依赖于hashCode()和equals()方法

import java.util.HashMap;
import java.util.Map;

public class Test03 {
    public static void main(String[] args) {
        //创建一个Map集合，保存对象类型数据
        Map<Person,String> map = new HashMap();
        map.put(new Person("奥利给",18 ), "中国");
        map.put(new Person("足球",18),"英国");
        map.put(new Person("三胖",6),"朝鲜");
        map.put(new Person("普精大帝",38),"俄罗斯");
        map.put(new Person("女王",18),"毛里求斯");

        System.out.println(map);

    }
}

5. LinkedHashMap集合

• 特点

  • 元素键不能重复
  • 元素存取有序

• 代码演示:

import java.util.LinkedHashMap;
public class Test05 {
    public static void main(String[] args) {

        //LinkedHashMap
        //元素键不能重复   元素存取有序
        LinkedHashMap<String,String> map = new LinkedHashMap<>();

        //添加元素
        map.put("马蓉","王宝强");
        map.put("李小璐","贾乃亮");

        //存储相同的键,会用新的值覆盖旧的值
        map.put("马蓉","宋喆");

        System.out.println(map);   
        			// 先放的马蓉后放到李小璐，所以马蓉在前 {马蓉=宋喆, 李小璐=贾乃亮}
    }
}

6.练习题

需求：输入一个字符串判断里面每个字符出现次数。统计有多少种字符。

​ 键盘输入一个字符串： abcdabc

​ 输出 a=2 b=2 c=2 d=1

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class TestExmp {
    public static void main(String[] args) {
        //需求：输入一个字符串判断里面每个字符出现次数。统计有多少种字符。
        // ​	键盘输入一个字符串： abcdabc

        //创建Map<String,Integer>集合
        Map<String, Integer> map = new HashMap<>();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();  //abcdabc

        //处理字符串
        /*for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
        }*/

        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            String c = chars[i]+"";
            //判断map集合中是否存在此字符
            if(map.containsKey(c)){  //abacdabc
                //如果集合已经有了这个key
                int count = map.get(c); //把原有的value取出
                count++;
                map.put(c,count); //再放回去
            }else {  //如果集合中没有这个key，把value直接赋值为1
                map.put(c, 1); // a 1
            }
        }

        //System.out.println(map);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"---"+value);
        }

        Set<String> set = map.keySet();
        System.out.println(set.size());

    }
}

总结先记住每个知识点的基本概念

Collections
	shuffle()	:打乱顺序
	sort()		:排序
	addAll()	:添加多个元素
比较器
Comparator
	用匿名内部类来指定排序的规则
可变参数
	可变参数可以接受任意个参数,也可以接受数组形式
Set
	HashSet
		元素没有索引
		元素不能重复
		元素存取无序
	LinkedHashset
		元素没有索引
		元素不能重复
		元素存取有序
hash表保证元素不重复原因：
	hashCode()和equals()方法,在自己定义的类中要重写这两方法才能保证不重复

Map
	HashMap
		元素键不能重复
		元素存取无序
	LinkedHashMap
		元素键不能重复
		元素存取有序
	遍历方式
		keySet()方式
		entrySet()方式