java-Collections集合工具类方法,map接口及其实现类,of

Collections

常用方法

多元素一齐添加和打乱顺序

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

public class t1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //可以一次性添加多个元素
        Collections.addAll(list,"a","b","c","d");
        System.out.println(list);//[a,b,c,d]

        //打乱顺序
        Collections.shuffle(list);
    }
}

Comparable排序

创建一个Person子类,用于比较自定义类型

import java.util.Objects;

public class Person extends Object implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 int compareTo(Person o) {
        //return 0; //默认,认为元素都是相同的
        //自定义比较规则,比较两人的年龄
        return this.getAge() - o.getAge();//年龄升序排序
        //return o.getAge() - this.getAge();//年龄降序排序

    }
}

主程序

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

public class t1 {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        Collections.addAll(list01,1,2,3,6,5);//[1, 2, 3, 6, 5]
        System.out.println(list01);

        //升序排序
        Collections.sort(list01);
        System.out.println(list01);//[1, 2, 3, 5, 6]

        ArrayList<Person> list03 = new ArrayList<>();
        list03.add(new Person("张三",18));
        list03.add(new Person("李四",19));
        list03.add(new Person("王五",20));

        Collections.sort(list03);
        System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=19}, Person{name='王五', age=20}]

    }
}

Comparater排序

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


public class t1 {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        Collections.addAll(list01,1,2,3,6,5);//[1, 2, 3, 6, 5]

        Collections.sort(list01, new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//升序
                //return o2-o1;//降序
            }
        });
        System.out.println(list01);

    }
}

创建一个Student子类,用于比较自定义类型

package test.code.src.cn.itcast.day11.demo08;

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 +
                '}';
    }
}

主程序

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


public class t1 {
    public static void main(String[] args) {
        ArrayList<Student> list02 = new ArrayList<>();

        list02.add(new Student("a迪丽热巴",18));
        list02.add(new Student("b古力娜扎",20));
        list02.add(new Student("c杨幂",17));
        list02.add(new Student("d杨幂",18));

        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result = o1.getAge()-o2.getAge();
                if (result==0){
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list02);//[Student{name='c杨幂', age=17}, Student{name='a迪丽热巴', age=18}, Student{name='d杨幂', age=18}, Student{name='b古力娜扎', age=20}]

    }
}

注意事项:

1.sort(list list)使用前提:被排序的集合里面存储的元素,必须实现Comparable,重写接口中的方法compareTo
例如:Integer底层源码覆盖重写了CompareTo方法所以可以直接进行排序

2.Comparable接口排序规则:
this-参数:升序
参数-this:降序
3.Comperator和Comparable的区别
comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则comparTo方法
Comparater:相当于找一个第三人的裁判,比较两个

map接口

Map集合的特点:

1.Map 集合是双列集合,一个元素包含两个值(一个key,一个value)
2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
3.Map集合元素,key不允许重复
4.Map集合中的元素,key和value是一一对应

Map接口的实现类

实现类HashMap<K,V>:基于哈希表的Map接口实现的无序集合,查询速度特别快
实现类LinkedHashMap<K,V>:基于哈希表和链表实现的有序集合,具有可预知迭代顺序的集合

Map接口中的常用方法

put:存储键值对时,key不重复,返回值是null
存储键值对时,key重复,返回被替换的值

import java.util.*;

public class t1 {
    public static void main(String[] args) {
        show04();

    }

    private static void show04() {
        //containsKey
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("范冰冰",178);
        boolean b1 = map.containsKey("赵丽颖");
        System.out.println(b1);//true
        boolean b2 = map.containsKey("赵颖");
        System.out.println(b2);//false
    }

    private static void show03() {
        //get方法
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("范冰冰",178);
        Integer hight = map.get("范冰冰");
        System.out.println(hight);//178

    }

    private static void show02() {
        //remove方法
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("范冰冰",178);
        map.remove("赵丽颖");

        System.out.println(map);
    }

    private static void show01() {
        //put方法
        //创建Map集合对象
        HashMap<String, String> map = new HashMap<>();

        String v1 = map.put("李晨", "范冰冰1");
        System.out.println(v1);//null

        String v2 = map.put("李晨", "范冰冰2");
        System.out.println(v2);//范冰冰1

        //remove方法
    }
}

Map集合的第一种遍历方法:通过键找值得方式

1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
2.遍历Set集合,获取Map集合中的每一个key
3.通过Map集合中的方法get(key),通过key找到value

import java.util.*;

public class t1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("范冰冰",178);

        //1.
        Set<String> set = map.keySet();
        //2.-3.
        for (String s : set) {
            Integer value = map.get(s);
            System.out.println(value);
        }
    }
}

Entry建值对对象

Map集合遍历的第二种方式:使用Entry对象遍历

1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
2.遍历Set集合,获取每一个Entry对象
3.使用Entry对象中的方法getKey()和getValue()获取键与值

import java.util.*;

public class t1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("范冰冰",178);

        //1.
        Set<Map.Entry<String, Integer>> set = map.entrySet();

        //2.
        for (Map.Entry<String, Integer> s : set) {
            String key = s.getKey();
            Integer value = s.getValue();
            System.out.println(key);
            System.out.println(value);
        }
    }
}

HashMap存储自定义类型

创建一个Person类,作为自定义的类型键和值

import java.util.Objects;

public class Person extends Object implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 int compareTo(Person o) {
        //return 0; //默认,认为元素都是相同的
        //自定义比较规则,比较两人的年龄
        return this.getAge() - o.getAge();//年龄升序排序
        //return o.getAge() - this.getAge();//年龄降序排序

    }
}

主程序

import java.util.*;


public class t1 {
    public static void main(String[] args) {
        show1();

    }

    private static void show1() {
        //自定义类型作为HashMap的key,必须重写hashCode和equals以保证key唯一
        HashMap<Person, String> map = new HashMap<>();
        map.put(new Person("张三",18),"北京");
        map.put(new Person("李四",19),"上海");
        map.put(new Person("王五",20),"广州");
        map.put(new Person("张三",18),"北京");
        Set<Person> set = map.keySet();
        for (Person person : set) {
            String value = map.get(person);
            System.out.println(value);
        }
    }

    private static void show() {
        HashMap<String, Person> map = new HashMap<>();
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(value);
        }
    }
}

继承HashMap的子类LinkedHashMap集合

底层原理:哈希表+链表(记录元素的顺序)

import java.util.*;

public class t1 {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new HashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("b","b");
        map.put("d","d");
        System.out.println(map);//有序集合存取一致
    }
}

Map集合练习:计算一个字符串中每个字符出现的次数

import java.util.*;

public class t1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        System.out.println(s);

        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            Integer value = map.get(c);
            if (value == null) {
                map.put(c, 1);
            } else {
                value++;
                map.put(c, value);
            }
        }
        //打印集合
        System.out.println(map);
    }
}

JDK9对集合添加优化of

List接口,Set接口,Map接口里面增加了一个静态方法of,可以给集合一次性添加多个元素

使用场景

当集合中存储的元素的个数已经确定,不在改变时使用

注意事项:

1.of方法只适用于List接口,Set接口,Map接口,不适用接口的实现类
2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素
3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常