JavaSE基础day16 Map遍历键值对、Collections 工具类、File

一. 双列集合

(一) Map集合的遍历方式

1.1 键遍历

1、获取Map集合中的所有键，放到一个Set集合中，遍历该Set集合，获取到每一个键，根据键再来获取对应的值。

2、获取Map集合中的所有键

Set<K> keySet()

3、遍历Set集合的两种方法：

迭代器

增强for循环

4、拿到每个键之后，获取对应的值

V get(K key)

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

public class MapKeySet {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>();
        map.put(1,"a");
        map.put(2,"hello");
        map.put(3,"world");

        // 1. 获取到map集合中的所有key值集合
        Set<Integer> set = map.keySet();
        // 2. 遍历set集合,获取出每一个key值
        for(Integer key : set){
            // 3. 通过唯一的key值获取到对应的value值
            String value = map.get(key);
            System.out.println(key + "--" + value);
        }
    }
}

1.2 键值对遍历

1. 获取Map<K,V>集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法:entrySet()。

2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

3. 通过键值对(Entry)对象，获取Entry对象中的键与值。方法:getkey() getValue()

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

public class MapEntrySet遍历 {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>();
        map.put(1,"a");
        map.put(2,"c");
        map.put(3,"d");

        // 1. 调用entrySet方法获取到map集合中所有键值对数据
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        // 2. 遍历set集合
        for(Map.Entry<Integer,String> en : set){
            // 3. 获取到一对数据中的key值和value值
            int key = en.getKey();
            String value = en.getValue();
            System.out.println(key + "--" + value);
        }
    }
}

(二) HashMap中key值唯一分析

1、HashMap就是Map集合使用哈希表的存储方式的一种实现类

2、HashMap存储的是jdk中提供的类型的键，就可以直接保证键的唯一性

3、HashMap中存储的键，是自定义类型，无法保证键的唯一性；原因：虽然都是张三、23，但是这些对象并不是相同的对象，这些对象的哈希值计算结果各不相同，就说明一定不是相同的对象，所以无法保证键的唯一。重写hashCode和equals方法

说明：HashMap的键的唯一性和HashSet的元素的唯一性，保证方式都一样

4、HashMap和HashSet的关系：

1、HashSet是由HashMap实现出来的，HashSet就是HashMap的键的那一列

2、将HashMap中的值的那一列隐藏掉，就变成了HashSet

HashSet保证元素唯一原理, 就是使用了HashMap中Key值唯一的原理

import java.util.Objects;
public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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);
    }

    public Person() {
    }

    public Person(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;
    }
}

import java.util.HashMap;
public class Map存储自定义类型 {
    public static void main(String[] args) {
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("张三",19),"新加坡");
        map.put(new Person("李四",20),"中国");
        map.put(new Person("张三",19),"香港");

        System.out.println(map);
    }
}

(二) Collections 工具类

3.1可变参数的使用和注意事项

1. 概述: 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了,方法的参数类型已经确定,个数不确定,我们可以使用可变参数.

2. 格式:

修饰符返回值类型方法名(数据类型...变量名) {

}

3. 注意事项:

(1) 可变参数在方法中其实是一个数组

(2) 如果一个方法有多个参数，包含可变参数，可变参数必须要放在最后

(3) 方法中只能有一个可变参数

案例 : 定义出一个方法功能, 求任意个整数累加和

public class Demo01_可变参数 {
    public static void main(String[] args) {
        // 可变参数在实际传递参数值时候:
        // 1) 传递0-n个指定类型数据
        // 2) 传递指定类型数组
        getSum();
        getSum(6);
        getSum(6,7,8,9);
        int[] arr = {1,3,5,7,9};
        getSum(arr);
    }

    // 案例 : 定义出一个方法功能, 求任意个数整的累加和
    // 1. 可变参数实现参数数量: 0-n
    public static int getSum(int...n){
        // 2. 可变参数在方法中作为一个数组使用
        int sum = 0;
        for(int i : n){
            sum += i;
        }
        System.out.println(sum);
        return sum;
    }

    // 3. 一个方法中最多只能有一个可变参数, 且必须要放在参数列表的最后位置
    // test(3,4): 错误案例
    /*public static int test(int...n,double...d){

    }*/

    // test1(3,7): 错误案例
    /*public static int test1(int...n,int d){

    }*/

    // test2(3,4,5)  test2方法参数支持
    /*public static int test2(int d,int...n){

    }*/
}

3.2 Collections单列集合工具类

1. Collections类是一个单列集合的工具类,在类中封装类很多常用的操作集合的方法.因为Collections工具类中, 没有对外提供构造方法, 因此不能创建对象, 导致类中所有成员和方法全部静态修饰, 类名.直接调用

2. Collections类中的常用方法:

1) sort(List<T> list): 将指定的列表按升序排序,从小到大

2) max、min(Collection c)：获取集合的最大值或者最小值

3) replaceAll(List<E> list, E oldVal, E newVal)：将集合list中的所有指定老元素oldVal都替换成新元素newVal

4) reverse(List<E> list)：将参数集合list进行反转

5) shuffle(List<E> list)：将list集合中的元素进行随机置换

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

public class CollectionsUse {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(13);
        list.add(1);
        list.add(66);
        list.add(13);
        list.add(-9);
        list.add(888);

        // 1.sort(List<T> list): 将指定的列表按升序排序,从小到大
        System.out.println(list);// [13, 1, 66, 13, -9, 888]
        Collections.sort(list);
        System.out.println(list);// [-9, 1, 13, 13, 66, 888]
        // 2.max、min(Collection c)：获取集合的最大值或者最小值
        System.out.println(Collections.max(list));// 888
        System.out.println(Collections.min(list));// -9

        // 3.replaceAll(List<E> list, E oldVal, E newVal)：
        // 将集合list中的所有指定老元素oldVal都替换成新元素newVal
        Collections.replaceAll(list,13,666);
        System.out.println(list);// [-9, 1, 666, 666, 66, 888]

        // 4.reverse(List<E> list)：将参数集合list进行反转
        Collections.reverse(list);
        System.out.println(list);// [888, 66, 666, 666, 1, -9]

        // 5.shuffle(List<E> list)：将list集合中的元素进行随机置换
        Collections.shuffle(list);
        System.out.println(list);
    }
}

一. 学生管理系统

1. 需求描述:

针对目前我们的所学内容，完成一个综合案例：学生管理系统！该系统主要功能如下：

1. 添加学生：通过键盘录入学生信息，添加到集合中

2. 删除学生：通过键盘录入要删除学生的学号，如果学号存在,将该学生对象从集合中删除; 如果学号不存在, 提示,无法删除

3. 修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改, 修改完毕保存在集合中

4. 查看学生：将集合中的学生对象信息进行展示

5. 退出系统：结束程序

2. 实现步骤:

1) 定义学生类Student

成员变量:

学号：sid

姓名：name

年龄：age

生日：birthday

构造方法：

无参构造

带四个参数的构造成员方法：

每个成员变量对应给出get/set方法

2) 学生管理系统主界面的搭建步骤

（1）用输出语句完成主界面的编写

（2）用Scanner实现键盘录入数据

（3）用switch语句完成操作的选择

（4）用循环完成再次回到主界面

3) 学生管理系统的添加学生功能实现步骤

（1）用键盘录入选择添加学生

（2）定义一个方法，用于添加学生

《1》显示提示信息，提示要输入何种信息

《2》键盘录入学生对象所需要的数据

《3》创建学生对象，把键盘录入的数据赋值给学生对象的成员变量

《4》将学生对象添加到集合中（保存）

《5》给出添加成功提示

《6》添加学生信息时, 保证每一个学生的学号都是唯一的

（3）调用方法

4) 学生管理系统的查看学生功能实现步骤

（1）用键盘录入选择查看所有学生信息

（2）定义一个方法，用于查看学生信息

《1》显示表头信息

《2》将集合中数据取出按照对应格式显示学生信息，年龄显示补充“岁”(无所谓)

（3）调用方法

5) 学生管理系统的删除学生功能实现步骤

（1）用键盘录入选择删除学生信息

（2）定义一个方法，用于删除学生信息

《1》显示提示信息

《2》键盘录入要删除的学生学号

《3》调用getIndex方法，查找该学号在学生集合是否存在

《4》如果不存在，提示信息不存在

《5》如果学生信息存在，调用删除方法删除学生信息提示删除成功

（3）调用方法

6) 学生管理系统的修改学生功能实现步骤

（1）用键盘录入选择修改学生信息

（2）定义一个方法，用于修改学生信息

《1》显示提示信息

《2》键盘录入要修改的学生学号

《3》调用getIndex方法，查找该学号在集合存在

《4》如果不存在，提示信息不存在,不能修改

《5》如果存在，键盘录入要修改的学生信息(学号不改)

《6》集合修改对应的学生信息

《7》给出修改成功提示

（3）调用方法

7) 退出系统

使用return;退出程序

public class Student {
    private String id;
    private String name;
    private int age;
    private String birthday;

    public Student() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

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

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class StudentManage {
    static Scanner sc = new Scanner(System.in);
    // list表示存储学生信息的集合
    static ArrayList<Student> list = new ArrayList<>();
    // set(int index, ele)
    public static void main(String[] args) {
        while(true){
            System.out.println("欢迎使用学生管理系统");
            System.out.println("1新增学生\t\t2删除学生\t\t3修改学生\t\t4查询学生\t\t5退出系统");
            int choose = sc.nextInt();
            if(choose == 1){// 新增学生
                addStudent();
            }else if(choose == 2){// 删除学生
                deleteStudent();
            }else if(choose == 3){// 修改学生
                updateStudent();
            }else if(choose == 4){// 查询学生
                selectAllStudent();
            }else if(choose == 5){// 退出系统
                System.out.println("谢谢使用本系统,再见");
                // break;
                // return;
                System.exit(0);
            }else{
                System.out.println("选项有误,如需退出系统使用,请选择5");
            }
        }
    }

    // 1. 新增学生信息: 保证学号唯一
    public static void addStudent(){
        System.out.println("请输入学生学号:");
        String id = sc.next();
        // 验证输入的id是否已经存在
        int index = checkStudentExist(id);
        if(index == -1){// 不存在,可以新增
            System.out.println("请输入学生姓名:");
            String name = sc.next();
            System.out.println("请输入学生年龄:");
            int age = sc.nextInt();
            System.out.println("请输入学生生日:");
            String birthday = sc.next();
            boolean boo = list.add(new Student(id,name,age,birthday));
            if(boo){
                System.out.println("新增成功");
            }else{
                System.out.println("新增失败");
            }
        }else{
            System.out.println(id + "学号已存在,无法新增");
        }
    }

    // 根据学生id验证学生在list集合中是否存在,如果学生所在集合中的索引位置; 如果不存在,返回索引位置为-1
    public static int checkStudentExist(String id){
        // 迭代器  增强for  索引遍历
        for(int index = 0; index < list.size(); index++){
             Student s = list.get(index);
             if(id.equals(s.getId())){
                 return index;
             }
        }
        return -1;
    }

    // 2. 删除学生信息
    public static void deleteStudent(){
        System.out.println("请输入需要删除的学生学号:");
        String id = sc.next();
        // 验证输入的id是否已经存在
        int index = checkStudentExist(id);
        if(index == -1){// 学生不存在,删除失败
            System.out.println(id + "不存在,无法删除");
        }else{
            Student s = list.remove(index);
            if (s == null){
                System.out.println("删除失败");
            }else{
                System.out.println("删除成功");
            }
        }
    }

    // 3. 修改学生信息
    public static void updateStudent(){
        System.out.println("请输入需要删除的学生学号:");
        String id = sc.next();
        // 验证输入的id是否已经存在
        int index = checkStudentExist(id);
        if(index == -1){// 学生不存在,修改失败
            System.out.println(id + "不存在,无法修改");
        }else{
            System.out.println("请输入修改后的学生姓名:");
            String name = sc.next();
            System.out.println("请输入修改后的学生年龄:");
            int age = sc.nextInt();
            System.out.println("请输入修改后的学生生日:");
            String birthday = sc.next();
            list.set(index,new Student(id,name,age,birthday));
            System.out.println("修改成功");
        }
    }

    // 4. 查询学生信息
    public static void selectAllStudent(){
        System.out.println("学号\t\t姓名\t\t年龄\t\t生日");
        for(Student s : list){
            System.out.println(s.getId() + "\t\t" + s.getName() + "\t\t" + s.getAge() + "\t\t" + s.getBirthday());
        }
    }
}

一. File类

(一)概述

1. File类介绍：来自于java.io包

(1) 它是文件和目录路径名的抽象表示。

(2) 文件和目录是可以通过File封装成对象的。

(3) 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已。这个路径名它可以是存在的,也可以是不存在的.将来可以通过具体的操作把这个路径的内容转换为存在的路径操作。

2. 路径：用于描述文件或者文件夹的所在位置的字符串。举例 : D:\笔记

3. 路径分类：

(1) 绝对路径：是一个完整的路径,从盘符开始。举例 : D:\Idea资料

(2) 相对路径：是一个简化的路径,相对当前项目下的路径。举例: a\b\ok.txt

idea中, 默认的路径: 当前项目工程根目录

(二)File类型的构造方法

1、File(String path)：把字符串的路径，封装成一个File对象

2、File(String parent, String child)：将父级路径和子级路径封装成一个File对象，其实描述的是父级路径和子级路径拼接后的路径

3、File(File parent, String child)：将父级File对象路径和字节路径封装成一个File对象，其实描述的也是父级路径和子级路径拼接后的路径

import java.io.File;
public class FileConstructor {
    public static void main(String[] args) {
        // 1. File(String path):
        File f = new File("D:\\0222Java系统班\\day16\\讲义");
        System.out.println(f);

        // 2. File(String fu,String zi): 将fu + zi拼接成一个完整的路径
        String fu = "D:\\0222Java系统班\\day16";
        String zi = "JAVASE_day16.docx";
        File f1 = new File(fu,zi);
        System.out.println(f1);

        // 3. File(File parent, String child):
        File f2 = new File(f,zi);
        System.out.println(f2);

    }
}

(三)File类型的创建方法

1、boolean createNewFile()：创建当前File对象所描述的路径的文件

2、boolean mkdir()：创建当前File对象所描述的路径的文件夹（如果父级路径不存在，那么不会自动创建父级路径）

3、boolean mkdirs()：创建当前File对象所描述的路径的文件夹（如果父级路径不存在，那么自动创建父级路径）

import java.io.File;
import java.io.IOException;
public class FileCreate {
    public static void main(String[] args) throws IOException {
        File f = new File("D:\\abc.txt");
        // 1. boolean createNewFile()：创建当前File对象所描述的路径的文件
        // (当且仅当文件的父路径存在,文件不存在的时候,创建出一个新的,空的文件)
        boolean boo = f.createNewFile();
        System.out.println(boo);

       /* File f1 = new File("D:\\你好\\15.ppt");
        //  boolean createNewFile()：创建当前File对象所描述的路径的文件
        // (当且仅当文件的父路径存在,文件不存在的时候,创建出一个新的,空的文件)
        boolean boo1 = f1.createNewFile();
        System.out.println(boo1);*/

        //2、boolean mkdir()：创建当前File对象所描述的路径的文件夹（如果父级路径不存在，那么不会自动创建父级路径）
        // 每次方法调用只能创建出一层文件夹,file路径封装的最后部分的文件夹: 例如你好
        // makeDirectory
        File f2 = new File("D:\\你好");
        boolean boo2 = f2.mkdir();
        System.out.println(boo2);

        File f3 = new File("D:\\你好\\a\\b\\c");
        boolean boo3 = f3.mkdir();
        System.out.println(boo3);// false

        //3、boolean mkdirs()：创建当前File对象所描述的路径的文件夹（如果父级路径不存在，那么自动创建父级路径）
        System.out.println(f3.mkdirs());
    }
}

(四)File类型的删除方法

1、delete()：删除调用者描述的文件或者文件夹, 文件存在或者文件夹为空才能删除成功

2、注意事项:

1) delete在删除文件夹的时候，只能删除空文件夹, 是为了尽量保证安全性

2) delete方法不走回收站

import java.io.File;
public class FileDelete {
    public static void main(String[] args) {
        File f = new File("D:\\abc.txt");
        System.out.println(f.delete());

        File f1 = new File("D:\\你好\\a\\b");
        System.out.println(f1.delete());

        File f2 = new File("D:\\你好\\a\\b\\c");
        System.out.println(f2.delete());
    }
}

(五)File类型常用的判断功能

1、exists()：判断当前调用者File对象所表示文件或者文件夹，是否真实存在, 存在返回true,不存在返回false

2、isFile()：判断当前调用者File对象，是否是文件

3、isDirectory()：判断当前调用者File对象，是否是文件夹

import java.io.File;
public class FilePanDuan {
    public static void main(String[] args) {
        File f = new File("D:\\0222Java系统班");
        System.out.println(f.exists());// true

        System.out.println(f.isFile());// false
        System.out.println(f.isDirectory());// true

        File f1 = new File("D:\\abc.txt");
        System.out.println(f1.exists());// false
        System.out.println(f1.isFile());// false
        System.out.println(f1.isDirectory());// false
    }
}

(六)File类型的获取功能

1、String getAbsolutePath()：获取当前File对象的绝对路径

2、String getPath()：获取的就是在构造方法中封装的路径

3、String getName()：获取最底层的简单的文件或者文件夹名称（不包含所造目录的路径）

4、String[] list()：获取当前文件夹下的所有文件和文件夹的名称，到一个字符串数组中

5、File[] listFiles()：获取当前文件夹下的所有文件和文件夹的File对象，到一个File对象数组中

import java.io.File;
import java.util.Arrays;
public class FileGet {
    public static void main(String[] args) {
        File f = new File("a\\b\\ok.txt");
        String path = f.getAbsolutePath();
        System.out.println(path);// D:\IdeaProjects\javabase\a\b\ok.txt

        String path2 = f.getPath();
        System.out.println(path2);// a\b\ok.txt

        String name = f.getName();
        System.out.println(name);// ok.txt

        //4、String[] list()：获取当前文件夹下的所有文件和文件夹的名称，到一个字符串数组中获取到的是当前文件夹层次下的所有文件和文件夹
        File f1 = new File("D:\\0222Java系统班\\day16");
        String[] sArr = f1.list();
        System.out.println(Arrays.toString(sArr));

        // 5、File[] listFiles()：获取当前文件夹下的所有文件和文件夹的File对象，到一个File对象数组中
        File[] fileArr = f1.listFiles();
        System.out.println(Arrays.toString(fileArr));
    }
}

练习：

统计一个文件夹中每种文件的个数并打印

打印格式如下：

txt:3个

doc:4个

jpg:6个

import java.io.File;
import java.util.HashMap;

public class FileTest {
    public static void main(String[] args) {
        File f = new File("D:\\你好");
        // map表示文件后缀名和对应数量关系
        HashMap<String,Integer> map = new HashMap<>();
        // 1. 验证提供的f对象是一个真实存在的文件夹
        if(f.isDirectory()){
            // 2. 获取到f路径下的所有文件和文件夹
            File[] fArr = f.listFiles();
            // 3. 遍历fArr获取出每一个文件和文件夹
            for(File file : fArr){
                // 4. 验证file是文件才进行统计
                if(file.isFile()){
                    // 5. 获取出这个文件的名称
                    String name = file.getName();
                    // 6. 继续获取出这个文件的后缀名,通过.进行字符串的切割
                    // 注意: 因为.在字符串规则中表示匹配任意一个字符,还是用\\转义符号将这个.转换成一个普通的
                    // 没有任何含义的.
                    String[] sArr = name.split("\\.");
                    String endName = sArr[sArr.length-1];
                    // 7. 存储,计数
                    if(map.containsKey(endName)){// 不是第一次存储
                        map.put(endName,map.get(endName) + 1);
                    }else{// 第一次存储
                        map.put(endName,1);
                    }
                }
            }
            System.out.println(map);
        }else{
            System.out.println("提供的文件不是一个文件夹级别");
        }
    }
}

相关阅读:
android:background背景图片被拉伸问题
 面试积累(String和StringBuffer, StringBuilder的理解)
面试积累(冒泡排序和选择排序)
面试积累(java的内存分析)
面试积累(java配置环境变量)
异常积累(SQLException)
【linux】fdisk磁盘分区
 【走马观花】十一月十八日通州雨
 【linux】CentOS查看硬件信息
 【linux】go安装及配置
原文地址：https://www.cnblogs.com/lw1095950124/p/16014048.html