面向对象核心编程---Day 04

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量64 收藏
点赞数
分类专栏： 面向对象核心编程 文章标签： java jvm 开发语言 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49544301/article/details/130048927
版权

一、Map集合

（一）Map集合第一种遍历

        1、获取 Map 集合中所有的键，存储在一个 Set 集合中，之后遍历 Set 集合，获取每一个键，根据键获取对应的值
        2、获取 Map 集合中所有的键： keySet ()
        3、遍历 Set 集合
     （1）迭代器遍历
     （2）增强 for 循环遍历
        4、获取每一个键之后，根据键获取值的方法： get (Object key) 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo01_PrintMapOne {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(234, "qwe");
        map.put(345, "asd");
        map.put(745, "zxc");
        map.put(247, "sdf");
        map.put(542, "cvb");
        map.put(845, "rty");
        //增强for循环简写
        for (Integer key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key + "..." + value);
        }
        //获取键集
        Set<Integer> set = map.keySet();
        //增强for循环
        for (Integer key : set) {
            String value = map.get(key);
            System.out.println(key + "..." + value);
        }
    }
    public static void test(Map<Integer, String> map) {
        //获取键集
        Set<Integer> set = map.keySet();
        //迭代器遍历
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            //Set中的元素就是Map中的每一个键
            Integer key = it.next();
            //根据键获取对应的值
            String value = map.get(key);
            System.out.println(key + "..." + value);
        }
    }
}

（二）Map集合第二种遍历

        1、获取 Map 集合中所有的键值对对象（ Entry ），存储在一个 Set 集合中，遍历 Set 集合，获取每一个键值对对象，从键值对对象中，获取键和值
        2、根据 Map 集合中提供的获取键值对对象的方法 : entrySet () 
Set<Map.Entry<Key, Value>> set = map.entrySet();
        3、遍历 Set 集合，获取每一个键值对对象：迭代器遍历、增强 for 循环遍历
        4、得到 Entry 对象之后，从对象中获取 Key 和 Value
     （1）获取 Key ： getKey ()
     （2）获取 Value ： getValue () 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo02_PrintMapTwo {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(234, "qwe");
        map.put(567, "yyy");
        map.put(345, "asd");
        map.put(745, "zxc");
        map.put(247, "sdf");
        map.put(542, "cvb");
        map.put(845, "rty");
        //增强for循环简写
        for(Map.Entry<Integer, String> entry : map.entrySet()) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "..." + value);
        }
        //获取键值对对象
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        //增强for循环遍历
        for(Map.Entry<Integer, String> entry : set) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "..." + value);
        }
    }
    //迭代器遍历
    public static void test(Map<Integer, String> map) {
        //获取键值对对象
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        //获取迭代器对象 泛型类型和Set集合保持一致
        Iterator<Map.Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            //获取每一个键值对对象
            Map.Entry<Integer, String> entry = it.next();
            //根据键值对中的方法获取对应的键和值
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "..." + value);
        }
    }
}

（三）练习

        键盘录入一个字符串，统计每一个字符出现的次数，使用Map 集合
        打印格式为：a 有 1 个， b 有 3 个 ... 
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Demo03_Exercise {
    /**
    * 键盘录入一个字符串，统计每一个字符出现的次数，使用Map集合
    * 打印格式为：a有1个，b有3个...
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串：");
        String str = sc.nextLine();
        //使用Map集合进行存储
        Map<Character, Integer> map = new HashMap<>();
        //为了统计字符个数，先将字符串转为字符数组
        char[] arr = str.toCharArray();
        //遍历数组获取每一个字符
        for (char key : arr) {
            map.put(key, map.containsKey(key) ? map.get(key) + 1 : 1);
        }
        System.out.println(getResult(map));
        /*遍历Map集合
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            Character key = entry.getKey();
            Integer value = entry.getValue();
            System.out.print(key + "有" + value + "个，");
        }*/
    }
    public static <K, V> String getResult(Map<K, V> map) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<K, V> entry : map.entrySet()) {
            K key = entry.getKey();
            V value = entry.getValue();
            sb.append(key).append("有").append(value).append("个，");
        }
        //将StringBuilder对象转为字符串，进行裁剪
        String str = sb.toString();
        //进行字符串裁剪，删除最后被一个逗号
        return str.substring(0, str.length() - 1);
    }
}

（四）HashMap

        1、是 Map 集合的子实现类
        2、 HashMap 存储 JDK 提供类型的元素都可以去重
        3、 HashMap 存储自定义类型元素作为键，无法保证键的唯一性：原因：和 HashSet 的去重原理一样，想要去重，在自定义类型所在类中重写hashCode 和 equals 方法
        4、 HashMap 和 HashSet ： HashSet 就是 HashMap 键的那一列， HashSet 是由 HashMap 实现出来的 
import java.util.*;
    public class Demo04_HashMap {
    public static void main(String[] args) {
        HashMap<Person, Integer> map = new HashMap<>();
        new HashSet<>();
        map.put(new Person("迪丽热巴", "新疆"), 23);
        map.put(new Person("迪丽热巴", "新疆"), 23);
        map.put(new Person("古力娜扎", "新疆"), 23);
        map.put(new Person("迪丽热巴", "新疆"), 30);
        Set<Map.Entry<Person, Integer>> set = map.entrySet();
        Iterator<Map.Entry<Person, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<Person, Integer> entry = it.next();
            Person key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key.hashCode() + "..." + value);
        }
    }
}

（五）HashMap和Hashtable区别

        1、相同点：
        HashMap和 Hashtable 都是 map 接口的实现类，都是双列集合，底层都是哈希表
        2、不同点：
     （1） HashMap ：不安全， Hashtable ：安全
     （2） HashMap ：效率高， Hashtable ：效率低
     （3） HashMap ：允许存储 null 值 null 键， Hashtable ：不允许
     （4） HashMap ：初始容量为 16 ， Hashtable ：初始容量为 11
     （5） HashMap ：扩容为原来的两倍， Hashtable ：扩容为原来的两倍 +1
     （6） HashMap ：会重新计算哈希码值， Hashtable ：会直接使用元素的 hashCode
     （7） HashMap ：出现在 JDK1.2 ， Hashtable ：出现在 JDK1.0

二、File类型

（一）概述

        1、 File 类型：用于表示一个文件或者文件夹的路径
        2、路径：用于描述文件或者文件夹存储位置的字符串
     （1）绝对路径：从根目录开始的路径【可以理解为本地路径 】
     （2）相对路径：从项目路径开始的【 src\com\hqyj\demos\Person.java 】

（二）构造方法

        1、 File (String pathname) ：将一个字符串表示的路径封装为 File 对象
        2、 File (String parent, String child) ：将父级路径和子级路径封装为一个 File 对象，对象中的父级路径是字符串
        3、 File (File parent, String child) ：将父级路径和子级路径封装为一个 File 对象，对象中的父级路径是File对象 
import java.io.File;
public class Demo06_File {
    public static void main(String[] args) {
        File file = new File("src\\com\\hqyj\\demos");
        File file1 = new File(file, "Person.java");
        System.out.println(file1);
        File file2 = new File("src\\com\\hqyj\\demos", "Person.java");
        System.out.println(file2);
    }
}

（三）创建文件的方法

        1、 createNewFile () ：当且仅当不存在具有此抽象路径名指定名称的文件时，创建一个新的文件
        2、 mkdir () ：只能创建单个文件夹，当且仅当 File 对象后表示的抽象文件夹路径不存在的时候，
        3、 mkdirs () ：可以创建嵌套文件夹，如果父级路径不存在，直接创建

（四）练习

        在D 盘下的 a/b/c/d 目录下创建一个文件，名称叫做 Helloworld.txt 
import java.io.File;
import java.io.IOException;
public class Demo08_Exercise {
    public static void main(String[] args) throws IOException {
        /**
        * 在D盘下的a/b/c/d目录下创建一个文件，名称叫做HelloWorld.txt
        * D:a/b/c/d
        * D:a\\b\\c\\d
        */
        //创建路径
        File file = new File("D:a/b/c/d");
        //创建嵌套文件夹
        file.mkdirs();
        //新的路径是父级路径+文件名
        File newFile = new File(file, "HelloWorld.txt");
        //创建文件
        newFile.createNewFile();
    }
}

（五）删除的方法

        1、 delete () ：删除指定路径的文件或者文件夹
        2、注意
     （1）使用该方法删除的文件夹只能是空文件夹
     （2）使用该方法删除不走回收站 
import java.io.File;
public class Demo09_Delete {
    public static void main(String[] args) {
        File file = new File("D:\\a\\b\\c\\d\\HelloWorld.txt");
        System.out.println(file.delete());
    }
}

（六）重命名方法

        1、 renameTo (File dest) ：将调用者对象表示的文件使用参数对象表示的新名称重新命名
        2、注意：
     （1）在同路径下，该方法是重命名
     （2）在不同路径下，该方法是剪切并且重命名 
import java.io.File;
public class Demo10_ReName {
    public static void main(String[] args) {
        File file = new File("a.txt");
        File newFile1 = new File("aaa.txt");
        File newFile2 = new File("D:\\a\\b\\c\\d\\a.txt");
        System.out.println(newFile1.renameTo(newFile2));
    }
}

（七）判断的方法

        1、 exists () ：判断调用者表示的抽象路径是否存在
        2、 isFile () ：判断调用者表示的抽象路径是一个文件
        3、 isDirectory () ：判断调用者表示的抽象路径是一个文件夹 
import java.io.File;
public class Demo11_IsFile {
    public static void main(String[] args) {
        File file = new File("b.txt");
        System.out.println(file.exists());
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
    }
}

（八）获取功能

        1、 getAbsoluteFile () ：获取当前 File 表示的内容的绝对路径
        2、 getName () ：获取文件或者文件夹的名称
        3、 list () ：获取 File 对象指代的文件夹下的所有文件和文件夹存储在一个 String 数组中
        4、 length () ：获取文件的长度，长度指的是字节数
        5、 listFiles () ：将调用者对象表示的文件夹下，每一个文件或者文件夹都封装为一个 File 对象存储在一个File数组中
        6、 getPath () ：将 File 对象表示的路径转为字符串
（九）练习
键盘录入一个字符串，该字符串表示一个文件夹路径，如果不是文件夹则重新录入
打印当前文件夹下，所有大于 5M 的后缀名为 .mp4 格式的文件的绝对路径 
import java.io.File;
import java.util.Scanner;
public class Demo13_Exercise {
    /**
    * 键盘录入一个字符串，该字符串表示一个文件夹路径，如果不是文件夹则重新录入
    * 打印当前文件夹下，所有大于5M的后缀名为.mp4格式的文件的绝对路径
    */
    public static void main(String[] args) {
        File file = getDir();
        //遍历文件夹中的内容
        File[] arr = file.listFiles();
        //遍历数组获取每一个文件或者文件夹
        for (File path : arr) {
            //判断是不是文件
            if (path.isFile()) {
                //获取文件的名字
                String name = path.getName();
                //获取文件名最后一个点出现的索引
                int index = name.lastIndexOf(".");
                //截取点直到结尾就是后缀名
                String suffixName = name.substring(index);
                //判断文件的后缀是不是.mp4格式的
                if (suffixName.equals(".mp4")) {
                    //判断文件的长度是否大于5M 8bit KB MB GB TB
                    if (path.length() / 1024 > 5) {
                        System.out.println(path.getAbsoluteFile());
                    }
                }
            }
        }
    }
    //判断当前录入的是不是一个文件夹路径
    public static File getDir() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个文件夹路径：");
        while (true) {
            String path = sc.nextLine();
            //将String转为File
            File file = new File(path);
            //判断当前字符串是不是合法的文件夹路径
            if (file.isDirectory()) {
                return file;
            } else {
                System.out.println("请录入合法的文件夹路径：");
            }
        }
    }
}

（十）File和递归

键盘录入一个文件夹路径，删除该文件夹，该文件夹是非空文件夹 
import java.io.File;
public class Demo14_Exercise {
    /**
    * 键盘录入一个文件夹路径，删除该文件夹，该文件夹是非空文件夹
    */
    public static void main(String[] args) {
        File file = Demo13_Exercise.getDir();
        deleteFile(file);
    }
   
    public static void deleteFile(File file) {
        //开发文件夹
        File[] arr = file.listFiles();
        //获取文件夹中的每一个内容
        for (File path : arr) {
            //判断是不是文件
            if (path.isFile()) {
                path.delete();
            } else {
                System.out.println(path);
                deleteFile(path);
            }
        }
        file.delete();
    }
}

小麦穗呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python编写圆的面积面向对象_Python--面向对象编程(1)
weixin_30009115的博客
01-14 967
面向对象编程--基础部分一.什么是面向对象的程序以及为什么要有面向对象面向过程的程序设计:核心是过程二字,过程指的是解决问题的步骤,即先干什么,再干什么....面向过程的设计就像是一种流水线,是一种机械式的思维方式优点是：复杂度的问题流程化，进而简单化(一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单)缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，...
day07-面向对象1
08-04
1.4 封装【概念与实现】封装是面向对象编程的核心特性之一，它将数据和操作数据的方法绑定在一起，作为一个相互依赖的整体——对象。封装的目的是隐藏对象的属性和实现细节，仅对外提供公共访问方式。实现封装的步骤...
L19-python核心编程-面向对象编程（day1、2）
楚子航
04-25 1334
一、面向对象编程的基本介绍 1、解决菜鸟买电脑的故事 方式一 1)在网上查找资料 2)根据自己预算和需求定电脑的型号 MacBook 15 顶配 1W8 3)去市场找到苹果店各种店无法甄别真假 随便找了一家 4)找到业务员,业务员推荐了另外一款 配置更高价格便宜,也是苹果系统的 1W 5)砍价30分钟 付款9999 6)成交方式二 1)找一个靠谱的电脑高手 2)给钱交易 买电脑的第一种方式: 强调的是步骤、过程、每一步都是自己亲自去实现的 这种解决问题的思路我们就叫做面向过程买电脑的第二种方式: 强调
Day08-面向对象-封装
小鱼儿的博客
07-07 1015
Java是一种计算机程序设计语言。所有的计算机程序一直都是围绕着两件事在进行的，程序设计就是用某种语言编写代码来完成这两件事，所以程序设计语言又称为编程语言（编写程序的语言）。如何表示和存储数据基本数据类型的常量和变量：表示和存储一个个独立的数据对象：表示和存储与某个具体事物相关的多个数据（例如：某个学生的姓名、年龄、联系方式等）数据结构：表示和存储一组对象，数据结构有数组、链表、栈、队列、散列表、二叉树、堆…基于这些数据都有什么操作行为，其实就是实现什么功能数据的输入和输出。
【Java核心面试宝典】Day10、面向对象常见面试题汇总（五）
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
08-06 1361
Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！、 用坚持缔造技术、用指尖敲动未来！ 和很多小伙伴们一样，我也是一名奔波在Java道路上的“创造者”。也想靠技术来改未来，改变世界！因为我们坚信每一次敲动键盘都能让生活变得更智能、世界变得更有趣！ 在此专栏《Java核心面试宝典》记录我们备战梦想的【day 10】！ 面向对象的方面的相关面试题也和大家总结了好几天了，把其中的内容分成了好几个板块和知识点，今天就来继续和大家分享最后的一部分， 1、聚集关系和组合关系有什么区别？ 聚集关系描述两个对.
day07-Java面向对象基础
ZHUSHANGLIN的博客
05-22 1058
首先每一部电影，都包含这部电影的相关信息，比如：电影的编号（id）、电影的名称（name）、电影的价格（price）、电影的分数（score）、电影的导演（director）、电影的主演（actor）、电影的简介（info）。为了去描述每一部电影，有哪些信息，我们可以设计一个电影类（Movie），电影类仅仅只是为了封装电影的信息，所以按照JavaBean类的标准写法来写就行。return id;
day11-面向对象-static&继承
12-12
面向对象是Java编程语言的核心概念，它允许我们将数据和操作数据的方法封装在一起，形成对象。在Java中，`static`关键字是面向对象编程中的一个重要特性，它与继承一起构成了Java的基础知识。 一、static关键字 1....
day12-面向对象-static&继承
12-12
面向对象是Java编程的核心概念，本篇主要讨论了`static`关键字和继承这两个主题，适合初学者理解基础知识。 首先，`static`关键字在Java中扮演着重要的角色。它主要用于声明类级别的成员，包括变量、方法和代码块。...
Day16-30_Day16-30_python_
10-03
7. **面向对象编程基础**： - 类的定义：使用`class`关键字创建类。 - 对象实例化：创建类的实例。 - 属性和方法：类中的数据成员和函数成员。 - 继承：子类继承父类的属性和方法。 - 多态：不同类的对象可以...
day09-面向对象-封装&构造方法
12-12
本节主要讲解了面向对象的两个核心概念：封装和构造方法。 首先，我们来深入理解一下成员变量和局部变量的区别： 成员变量，也称为类变量，是在类定义中声明的变量。它们在整个类的范围内都是有效的，这意味着类的...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 250
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 621
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 281
集合之Map
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 860
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 743
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 466
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 418
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java8新特性之FlatMap&Reduce
startqbb的博客
07-26 201
【代码】Java8新特性之FlatMap&Reduce。
Java编程：面向对象的核心特性-接口与内部类
"《Java2程序设计实用教程》第二版，作者叶核亚，涵盖了Java编程的多个核心主题，包括面向对象的核心特性、接口、内部类、包等。本摘要聚焦于面向对象的核心特性和接口的介绍。" 在Java编程中，面向对象是其核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值