java笔记--多敲代码三_java 重复敲同一段代码-优快云博客

本文链接：https://blog.youkuaiyun.com/Lily3619/article/details/121323974

集合的体系结构：
collection 单列集合，例如张三李四王五
map双列集合 HashMap
list 单列可重复 ArrayList
set 单列不可重复 HashSet TreeSet

collection集合的概述和基本使用

package heima02;

import java.util.ArrayList;
import java.util.Collection;
/*创建Collection 集合对象
多态的方式*/

public class demo {
    public static void main(String[] args) {
        //创建Collection 集合对象
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c); //[hello, world, java]
    }

}

collection 集合的常用方法
alt+7查看源码结构

public class demo {
    public static void main(String[] args) {
        //创建Collection 集合对象
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
//        c.remove("hello");
//        c.clear();
//        System.out.println(c.isEmpty());
        System.out.println(c.size());
    }
}

collection 集合遍历

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*创建Collection 集合对象
多态的方式*/

public class demo {
    public static void main(String[] args) {
        //创建Collection 集合对象
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        //返回次集合中元素的迭代器，通过集合的iterator（）方法得到；
        Iterator<String> it = c.iterator(); //ctrl+alt+v
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());

        /*//如果迭代有更多元素，则返回true
        if(it.hasNext()){
            for (int i=0;i<c.size();i++){
                System.out.println(it.next());
            }
        }*/

        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

Collection集合存储学生对象并遍历

package heima02;

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;
    }
    //alt+insert 选择toString()--重写了object中的toString方法

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c =new ArrayList<Student>();
        //创建学生对象
        Student s1= new Student("xiaomming1",20);
        Student s2 = new Student("xiaoming2",22);
        Student s3 =new Student("xiaoming3",23);
        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
        }
    }
}

list集合的特点
有序：存储和取出的元素一直
可重复：存储的元素可以重复
list集合存储并遍历学生对象

import java.awt.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student>list =new ArrayList<Student>();
        //创建学生对象
        Student s1= new Student("xiaomming1",20);
        Student s2 = new Student("xiaoming2",22);
        Student s3 =new Student("xiaoming3",23);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //遍历集合（迭代器方式）
        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
        }
        //for循环方式遍历
        for (int i=0;i<list.size();i++){
            Student s = list.get(i);
            System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
        }
        //增强for
        for (Student s :list){
            System.out.println("姓名："+s.getName()+"  年龄："+s.getAge());
        }
    }
}

增强for格式：
for(元素数据类型变量名：数组或collection集合){
在此处使用变量即可
}

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

public class ForDemo {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        for (int i:arr){
            System.out.println(i);
        }
        String[] StringArr={"hello","world","javc"};
        for (String i: StringArr){
            System.out.println(i);
        }
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("w");
        list.add("j");
        for (String s:list){
            System.out.println(s);
        }

    }
}
233

set集合特点：
不包含重复的元素
没有带索引的方法，不能使用普通for循环
hashset对集合的迭代顺序不做保证

hashset集合特点：
由于是set集合，不包含重复的元素
没有带索引的方法，不能使用普通for循环
hashset对集合的迭代顺序不做保证
底层数据是hash表

linkhashset 保证顺序

treeset集合的特点和概述
元素有序；
没有带索引的方法，不能使用普通for循环；
由于是set集合，不包含重复元素的集合

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(20);
        ts.add(10);
        ts.add(50);
        ts.add(80);
        //遍历集合
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

自然排序comparable的使用
用treeset集合存储自定义集合，无参构造方法使用的是自然排序对元素进行排序的；
自然排序就是然元素所属的类实现comparable接口，重写comparTo方法；
重写方法时，一定要按照主要条件和次要条件来写

package heima02;

//实现接口
public class Student implements Comparable<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 int compareTo(Student s) {
//        return 0; // 只能输出一个值，因为后面的值和0比较相等
//        return 1; //  正序排列
//        return -1;  //倒叙排列
        //按照年龄大小排序
//        int num = this.age-s.age;  //按照年龄正序排列
//        int num = s.age-this.age;  //按照年龄倒序排列
        //年龄相同时，按照姓名的字母顺序排序
        int num2 =num == 0? this.name.compareTo(s.name):num;
        return num2;
    }
}

package heima02;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();
        Student s1 = new Student("xiao1", 21);
        Student s2 = new Student("xiao2", 22);
        Student s3 = new Student("xiao2", 23);
        Student s4 = new Student("xiao4", 24);
        Student s5 = new Student("wang", 24);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

比较器comparator的使用
用treeset集合存储自定义集合，带参构造方法使用的是比较器排序对元素进行排序的；
比较器排序就是让集合构造方法接收comparator的实现类对象，重写comparTo（To1,To2）方法；
重写方法时，一定要按照主要条件和次要条件来写

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

package heima02;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        Student s1 = new Student("xiao1", 21);
        Student s2 = new Student("xiao2", 22);
        Student s3 = new Student("xiao2", 23);
        Student s4 = new Student("xiao4", 24);
        Student s5 = new Student("wang", 24);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

获取10个1-20之间的随机数，随机数不重复，输出在控制台

package heima02;

import java.util.HashSet;
import java.util.Random;
import java.util.TreeSet;
/*
获取10个1-20之间的随机数，随机数不重复，输出在控制台
 */
public class SetDemo2 {
    public static void main(String[] args) {
        //创建set集合
//        HashSet<Integer> set = new HashSet<>();  //无序
        TreeSet<Integer> set = new TreeSet<>();  //有序
        //创建随机数对象
        Random random = new Random();
        //判断集合长度<10
        while (set.size()<10){
            //产生一个随机数，添加到集合
            int number = random.nextInt(20) + 1;
            set.add(number);
        }
        //遍历集合
        for (Integer i:set){
            System.out.println(i);
        }
    }
}

泛型类
格式：修饰符 class 类名<类型> {}
范例：public class Generic {}
泛型类举例，使用泛型类实现传参类型为任意类型，指定类型的类在传参时只能传指定的类型，传参其他类型会出现运行前报错

package test01;

public class Student {
    private String name;
    //alt+insert创建get set 方法
    public String getName() {
        return name;
    }

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

package test01;

public class Teacher {
    private Integer age;

    public Integer getAge() {
        return age;
    }

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

package test01;

public class Gene<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

package test01;

public class GeneDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("xiaoming");
        System.out.println(s.getName());

        Teacher t = new Teacher();
        t.setAge(30);
//        t.setAge("20");  //Teacher类中指定了为Integer类型，此处使用String会报错
        System.out.println(t.getAge());

        //使用泛型类实现，传参可以为任意类型
        Gene<String> g1 = new Gene<>();
        g1.setT("xiaoming");
        System.out.println(g1.getT());

        Gene<Integer> g2 = new Gene<>();
        g2.setT(30);
        System.out.println(g2.getT());

        Gene<Boolean> g3 = new Gene<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());

    }
}

泛型方法
格式：修饰符<类型> 返回值类型方法名（类型变量名）{}
范例：public void show(T t) {}

package test02;

/*public class Gene {
    //方法名相同，参数名不同，这叫做方法重载
    public void show(String s){
        System.out.println(s);
    }
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(Boolean b){
        System.out.println(b);
    }
}*/

泛型类改进
//public class Gene <T>{
//    public void show(T t){
//        System.out.println(t);
//    }
//}

//泛型方法改进
public class Gene {
    public <T>void show(T t){
        System.out.println(t);
    }
}

package test02;

public class GeneDemo {
    public static void main(String[] args) {
//        Gene g = new Gene();
//        g.show("xiaoming");
//        g.show(20);
//        g.show(true);
        g.show(12.22);  //报错了，因为没有提供对应的参数方法调用

//        //使用了泛型类，每次创建对象都需要指定类型，麻烦了
//        Gene<String> g1 = new Gene<>();
//        g1.show("xiaomming");
//        Gene<Integer> g2 = new Gene<>();
//        g2.show(20);
//        Gene<Boolean> g3 = new Gene<>();
//        g3.show(true);

        Gene g = new Gene();
        g.show("xiaoming");
        g.show(20);
        g.show(true);
        g.show(12.23);


    }
}

泛型接口
格式：修饰符interface 接口名<类型>{}
范例：public interface Generic ) {}

package test03;

public interface Generic<T>{
    void show(T t);
}

package test03;

public class GenericImpl <T> implements Generic<T>{
    @Override
    public void show(T t){
        System.out.println(t);
    }
}

package test03;

public class GenericDemo {
    public static void main(String[] args) {
        GenericImpl<String> g1 = new GenericImpl<>();
        g1.show("xiaoming");

        GenericImpl<Integer> g2 = new GenericImpl<>();
        g2.show(20);
    }
}

类型通配符<?> list<?>:表示元素类型未知的list，他的元素可以匹配任何的类型，这种通配符的类型仅表示他是各种list的父类，并不能把元素添加到其中

类型通配符上限：<? extends类型>
List<? extends number>表示的是number或其子类型

类型通配符下限：<? super类型>
List<? super number>表示的是number或其父类型

package test04;

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

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

        //类型通配符上限：<? extends类型>
        List<? extends Number> list4 = new ArrayList<Object>(); //报错了
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        //类型通配符下限：<? super类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        List<? super Number> list9 = new ArrayList<Integer>();  //报错了
    }
}

可变参数
指参数个数可变，用做方法的形式出现，那么方法参数个数就是可变的了
格式：修饰符返回值类型方法名（数据类型…变量名）{}
范例：public static int sum (int…a){}
可变参数注意事项：
这里的变量a其实是一个数组，
如果一个方法有多个参数，包含可变参数，可变参数要放到最后。

package test05;

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(2, 3));
        System.out.println(sum(2, 3, 4));
        System.out.println(sum(2, 3, 4, 5));

        System.out.println(sum(2, 3, 4, 5, 6, 7, 8));

    }

    //使用可变参数定义
    public static int sum(int... a) {
//        System.out.println(a);
//        return 0;
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }
//    public static int sum(int a, int b) {
//        return a + b;
//    }
//
//    public static int sum(int a, int b, int c) {
//        return a + b + c;
//    }
//
//    public static int sum(int a, int b, int c, int d) {
//        return a + b + c + d;
//    }
}

public static List asList(T…a) 返回由指定数组支持的固定大小的数组

package test05;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class AegsDemo2 {
    public static void main(String[] args) {
        // public static <T>List<T> asList(T...a) 返回由指定数组支持的固定大小的数组
        List<String> list = Arrays.asList("hello", "world", "java");
//        list.add("python");
//        list.remove('world');
        list.set(1,"py");
        System.out.println(list);

    }
}

Map集合的特点
将键映射到值的对象，不能包含重复的键，每个键可以映射最多一个值

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String >();
        //添加对象
        map.put("xuehao001","xiaoming1");
        map.put("xuehao002","xiaoming2");
        map.put("xuehao003","xiaoming3");
        map.put("xuehao003","xiaoming4"); //当键重复时，值被替换掉，即键是唯一的。
        //输出集合对象
        System.out.println(map);//{xuehao003=xiaoming4, xuehao002=xiaoming2, xuehao001=xiaoming1}
    }
}

Map集合的基本功能

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String >();
        //添加对象
        map.put("xuehao001","xiaoming1");
        map.put("xuehao002","xiaoming2");
        map.put("xuehao003","xiaoming3");
//        //删除键值对
//        map.remove("xuehao001"); //{xuehao003=xiaoming3, xuehao002=xiaoming2}
//        map.remove("xhehao004"); //{xuehao003=xiaoming3, xuehao002=xiaoming2}
//        //移除所有的键值对
//        map.clear(); //{}
        //判断是否包含指定的键
        System.out.println(map.containsKey("xuehao001")); //true
        System.out.println(map.containsKey("xuehao005")); //false
        //判断是否包含指定的值
        System.out.println(map.containsValue("xiaoming1")); //true
        //判断集合是否普为空
        System.out.println(map.isEmpty()); //false
        //集合的长度
        System.out.println(map.size()); //3

        //输出集合对象
        System.out.println(map);
    }
}

Map集合的获取功能

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String >();
        //添加对象
        map.put("xuehao001","xiaoming1");
        map.put("xuehao002","xiaoming2");
        map.put("xuehao003","xiaoming3");
        //根据键获取值
        System.out.println(map.get("xuehao001"));  //xiaoming1
        System.out.println(map.get("xuehao"));  //null
        //获取所有键的集合keySet()
        Set<String> keySet = map.keySet(); //map.keySet() ctrl+alt+v快捷键，
        for(String key:keySet){
            System.out.println(key);
        }
        //获取所有值得方法values()
        Collection<String> values = map.values();
        for (String val:values){
            System.out.println(val);
        }

        //输出集合对象
        System.out.println(map);
    }
}

Map集合遍历一

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加对象
        map.put("xuehao001", "xiaoming1");
        map.put("xuehao002", "xiaoming2");
        map.put("xuehao003", "xiaoming3");

        //获取所有键的集合
        Set<String> keySet = map.keySet(); //map.keySet() ctrl+alt+v快捷键，
        //遍历集合获取每一个键
        for (String key : keySet) {
            //根据键去找值
            String val = map.get(key);
            System.out.println(key + "," + val);
        }
    }
}

Map集合遍历二
entryset

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

public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加对象
        map.put("xuehao001", "xiaoming1");
        map.put("xuehao002", "xiaoming2");
        map.put("xuehao003", "xiaoming3");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每个键值对对象
        for (Map.Entry<String, String >me : entrySet) {
            //根据键值对对象获取每个键和值
            String key = me.getKey();
            String val = me.getValue();
            System.out.println(key + "," + val);

        }
    }
}

HashMap存储学生对象并遍历

package test06;

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

}

package test06;

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

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String, Student> hm = new HashMap<>();
        //创建学生对象
        Student s1 = new Student("xiaomning1", 21);
        Student s2 = new Student("xiaomning2", 22);
        Student s3 = new Student("xiaomning3", 23);
        //把学生添加到集合
        hm.put("test1", s1);
        hm.put("test2", s2);
        hm.put("test3", s3);

        //遍历集合，方式一键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
        //遍历集合，方式二键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> me : entrySet) {
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}

HashMap存储学生对象并遍历二

package test07;

public class Student2 {
    private String name;
    private int age;

    public Student2() {

    }

    public Student2(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student2 student2 = (Student2) o;

        if (age != student2.age) return false;
        return name != null ? name.equals(student2.name) : student2.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

package test07;

import test06.Student;

import java.util.HashMap;
import java.util.Set;

public class HashMapDemo2 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student2, String> hm = new HashMap<>();
        //创建学生对象
        Student2 s1 = new Student2("xiaoming1", 21);
        Student2 s2 = new Student2("xiaoming2", 22);
        Student2 s3 = new Student2("xiaoming3", 23);
        Student2 s4 = new Student2("xiaoming3", 23);
        //把学生添加到集合
        hm.put(s1, "xian");
        hm.put(s2, "wuhan");
        hm.put(s3, "shanghai");
        hm.put(s4,"beijing");  //需要重写hashcode 和equals方法，保证键唯一，值为修改后的值
        System.out.println(hm);
        //遍历集合
        Set<Student2> keySet = hm.keySet();
        for (Student2 key:keySet){
            String value = hm.get(key);
            System.out.println(key.getName()+","+key.getAge()+","+value);
        }
    }
}

ArrayLIst嵌套HashMap

import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        //创建arraylist集合
        ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();
        //创建HashMap集合，并添加元素
        HashMap<String,String> hm = new HashMap<>();
        hm.put("student1","lily1");
        hm.put("student2","lily2");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm);

        HashMap<String,String> hm2 = new HashMap<>();
        hm2.put("student21","lily21");
        hm2.put("student22","lily22");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm2);

        HashMap<String,String> hm3 = new HashMap<>();
        hm3.put("student31","lily31");
        hm3.put("student32","lily32");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm3);
        System.out.println(array);//[{student2=lily2, student1=lily1}, {student21=lily21, student22=lily22}, {student32=lily32, student31=lily31}]

        //遍历ArrayList集合
        for (HashMap<String,String> hsm: array){
            Set<String> keySet = hsm.keySet();
            System.out.println(keySet);
            for (String key:keySet){  //按照HashMap遍历
                String val = hsm.get(key);
                System.out.println(key+","+val);
            }

        }

    }
}

arraylist嵌套hashmap，hashmap为学生对象

package test07;

public class Student2 {
    private String name;
    private int age;

    public Student2() {

    }

    public Student2(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student2 student2 = (Student2) o;

        if (age != student2.age) return false;
        return name != null ? name.equals(student2.name) : student2.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

package test07;

import java.util.ArrayList;

public class HashMapDemo2 {
    public static void main(String[] args) {
        ArrayList<Student2> array = new ArrayList<>();
        //创建学生对象
        Student2 s1 = new Student2("xiaoming1", 21);
        Student2 s2 = new Student2("xiaoming2", 22);
        Student2 s3 = new Student2("xiaoming3", 23);

        array.add(s1);
        array.add(s2);
        array.add(s3);
        System.out.println(array);  //[test07.Student2@5e9fa8b8, test07.Student2@5e9fa8d8, test07.Student2@5e9fa8f8]

        for (Student2 hm:array){

            String name = hm.getName();
            int age = hm.getAge();
            System.out.println(age+name);  
            //21xiaoming1
            //22xiaoming2
            //23xiaoming3

        }

HashMap嵌套ArrayList并遍历


import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        //创建ArrayList集合，并添加元素
        ArrayList<String> array1 = new ArrayList<String>();
        array1.add("array1a");
        array1.add("array1b");
        //把arraylist作为元素添加到HashMap
        hm.put("三国", array1);

        ArrayList<String> array2 = new ArrayList<String>();
        array2.add("array2a");
        array2.add("array2b");
        //把arraylist作为元素添加到HashMap
        hm.put("西游", array2);

        ArrayList<String> array3 = new ArrayList<String>();
        array3.add("array3a");
        array3.add("array3b");
        //把arraylist作为元素添加到HashMap
        hm.put("水浒", array3);
        System.out.println(array1);  //[array1a, array1b]
        System.out.println(hm);  //{水浒=[array3a, array3b], 西游=[array2a, array2b], 三国=[array1a, array1b]}

        //遍历HashMap集合
        Set<String> keySet = hm.keySet();
        for (String Key : keySet) {
            System.out.println(Key);
            ArrayList<String> val = hm.get(Key); //按照ArrayList规则遍历
            for (String s : val) {
                System.out.println("\t" + s);
                //水浒
                //	array3a
                //	array3b
                //西游
                //	array2a
                //	array2b
                //三国
                //	array1a
                //	array1b
            }
        }
    }
}

统计字符串每个字母的个数

package test07;

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

public class HashMapDemo3 {
    public static void main(String[] args) {
        //键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        //创建HashMap集合，键是Character,值是Integer
//        HashMap<Character, Integer> hm = new HashMap<>();
        TreeMap<Character, Integer> hm = new TreeMap<>(); //按字母顺序排
        //遍历字符串得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);
            System.out.println(key);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);
            if (value == null) {
                //如果返回的值是null，说明该字符在HashMap中不存在，就把该字符作为建，1作为值存储
                hm.put(key, 1);
            } else {
                //如果返回的值不是null，说明该字符在HashMap中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key, value);
            }
        }
        System.out.println(hm);
        //遍历HashMap集合，得到键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();
        //输出结果
        System.out.println(result);
    }
}

Collections概述和使用
是针对集合操作的工具类
Collections类的常用方法
public static <T extends Comparable<? super T> > void sort(List list) 将指定的列表按升序排序
public static void reverse(List<？> list) 反转指定列表中元素的顺序
public static void shuffle(List<？> list) 使用默认的随机源随机排列指定的列表
arraylist 存储学生对象并遍历

package test06;

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

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<Student> array = new ArrayList<>();
        Student s1 = new Student("xiaoming1", 30);
        Student s2 = new Student("xiaoming2", 22);
        Student s3 = new Student("xiaoming3", 23);
        Student s4 = new Student("xiaoming4", 24);
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        //使用Collections对arraylist集合排序
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        //遍历集合
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}