AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java每日一练(20230511) 有效数字、重复元素II、类和子类

2023-05-29 134
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java每日一练(20230511) 有效数字、重复元素II、类和子类

1. 有效数字


有效数字（按顺序）可以分成以下几个部分：


  1. 一个 小数 或者 整数
  2. （可选）一个 'e' 或 'E' ，后面跟着一个 整数


小数（按顺序）可以分成以下几个部分：


   （可选）一个符号字符（'+' 或 '-'）


   下述格式之一：


       至少一位数字，后面跟着一个点 '.'


       至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字


       一个点 '.' ，后面跟着至少一位数字


整数（按顺序）可以分成以下几个部分：


   （可选）一个符号字符（'+' 或 '-'）


   至少一位数字


部分有效数字列举如下：


   ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]


部分无效数字列举如下：


   ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]

给你一个字符串 s ，如果 s 是一个 有效数字 ，请返回 true 。


示例 1：

输入：s = "0"

输出：true


示例 2：

输入：s = "e"

输出：false


示例 3：

输入：s = "."

输出：false


示例 4：

输入：s = ".1"

输出：true


提示：

   1 <= s.length <= 20

   s 仅含英文字母（大写和小写），数字（0-9），加号 '+' ，减号 '-' ，或者点 '.' 。

以下程序实现了这一功能，请你填补空白处内容：

```Java

class Solution {
    char[] chars;
    boolean point = false;
    boolean exponent = false;
    public boolean isNumber(String s) {
        s = s.trim();
        int length = s.length();
        if (length == 0) {
            return false;
        }
        chars = s.toCharArray();
        String[] ss = s.split("e");
        if (ss.length == 0) {
            return false;
        }
        if (ss[0].length() == 0)
            return false;
        if (ss[0].length() < length)
            exponent = true;
        if (ss[0].length() == length - 1) {
            return false;
        }
        String[] pre = ss[0].split("\\.");
        if (pre.length == 0) {
            return false;
        }
        if (pre[0].length() < ss[0].length())
            point = true;
        boolean result = pre(0, pre[0].length());
        result = result && middle(pre[0].length() + 1, ss[0].length());
        if (exponent) {
            result = result && is(ss[0].length() + 1, length);
        }
        return result;
    }
    ____________________________;
    public boolean middle(int i, int length) {
        if (i >= length && point) {
            if (chars[i - 2] >= '0' && chars[i - 2] <= '9') {
                return true;
            }
            return false;
        }
        for (; i < length; i++) {
            if (chars[i] < '0' || chars[i] > '9') {
                return false;
            }
        }
        return true;
    }
    public boolean is(int i, int length) {
        if (i == 1) {
            return false;
        }
        if (chars[i] == '+' || chars[i] == '-') {
            i++;
        }
        if (i == length) {
            return false;
        }
        for (; i < length; i++) {
            if (chars[i] < '0' || chars[i] > '9') {
                return false;
            }
        }
        return true;
    }
}
```


出处：

https://edu.csdn.net/practice/27544131

代码：

import java.util.*;
public class isNumber {
    public static class Solution {
        char[] chars;
        boolean point = false;
        boolean exponent = false;
        public boolean isNumber(String s) {
            s = s.trim();
            int length = s.length();
            if (length == 0) {
                return false;
            }
            chars = s.toCharArray();
            String[] ss = s.split("e");
            if (ss.length == 0) {
                return false;
            }
            if (ss[0].length() == 0)
                return false;
            if (ss[0].length() < length)
                exponent = true;
            if (ss[0].length() == length - 1) {
                return false;
            }
            String[] pre = ss[0].split("\\.");
            if (pre.length == 0) {
                return false;
            }
            if (pre[0].length() < ss[0].length())
                point = true;
            boolean result = pre(0, pre[0].length());
            result = result && middle(pre[0].length() + 1, ss[0].length());
            if (exponent) {
                result = result && is(ss[0].length() + 1, length);
            }
            return result;
        }
        public boolean pre(int i, int length) {
            if (i >= length) {
                return true;
            }
            if (chars[i] == '+' || chars[i] == '-') {
                i++;
            }
            if (i == length && !point) {
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
        public boolean middle(int i, int length) {
            if (i >= length && point) {
                if (chars[i - 2] >= '0' && chars[i - 2] <= '9') {
                    return true;
                }
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
        public boolean is(int i, int length) {
            if (i == 1) {
                return false;
            }
            if (chars[i] == '+' || chars[i] == '-') {
                i++;
            }
            if (i == length) {
                return false;
            }
            for (; i < length; i++) {
                if (chars[i] < '0' || chars[i] > '9') {
                    return false;
                }
            }
            return true;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        String str = "0";
        System.out.println(s.isNumber(str));
        str = "e";
        System.out.println(s.isNumber(str));
        str = ".";
        System.out.println(s.isNumber(str));
        str = ".1";
        System.out.println(s.isNumber(str));
        str = "-123.456e789";
        System.out.println(s.isNumber(str));
        str = "99e2.5";
        System.out.println(s.isNumber(str));
    }
}


输出：

true

false

false

true

true

false

2. 存在重复元素 II


给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。


示例 1:

输入: nums = [1,2,3,1], k = 3

输出: true


示例 2:

输入: nums = [1,0,1,1], k = 1

输出: true


示例 3:

输入: nums = [1,2,3,1,2,3], k = 2

输出: false


出处：

https://edu.csdn.net/practice/27544132

代码：

import java.util.*;
public class containsNearbyDuplicate {
    public static class Solution {
        public boolean containsNearbyDuplicate(int[] nums, int k) {
            int left = 0;
            int right = -1;
            HashMap<Integer, Integer> hashMap = new HashMap<>();
            while (left < nums.length) {
                if (right + 1 < nums.length && right - left < k) {
                    right++;
                    if (hashMap.containsKey(nums[right])) {
                        return true;
                    } else {
                        hashMap.put(nums[right], 1);
                    }
                } else {
                    hashMap.put(nums[left], hashMap.get(nums[left]) - 1);
                    if (hashMap.get(nums[left]) == 0) {
                        hashMap.remove(nums[left]);
                    }
                    left++;
                }
            }
            return false;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] nums = {1,2,3,1};
        System.out.println(s.containsNearbyDuplicate(nums, 3));
        int[] nums2 = {1,0,1,1};
        System.out.println(s.containsNearbyDuplicate(nums2, 1));
        int[] nums3 = {1,2,3,1,2,3};
        System.out.println(s.containsNearbyDuplicate(nums3, 2));
    }
}

输出：

true

true

false

3. 设计学生类Student和它的一个子类Undergraduate


设计一个学生类Student和它的一个子类Undergraduate，要求如下：


(1)Student类有name和age属性，一个包含两个人参数的构造器，用于给两属性赋值，一个show()方法打印Student的属性信息。


(2)本科生类Undergraduate增加一个degree(学位)属性。有一个包含三参数的构造器，前两个参数用于给集成的属性赋值，第三个参数给degree专业见值，一个show()方法用于打印Undergraduate的属性信息。


(3)在测试类中分别打印Undergraduate和Student对象，调用它们的show()


出处：

https://edu.csdn.net/practice/27544133


代码：


package T1;
public class Test {
    public static void main(String[] args) {
        Student stu = new Student("student", 100);
        stu.show();
        Undergraduate undergraduate = new Undergraduate("Undergraduate", 20, "本科");
        undergraduate.show();
    }
}
class Student {
    private String name;
    private int age;
    public Student() {
        super();
    }
    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 double getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show() {
        System.out.println("名字：" + this.name + "\t年龄：" + this.age);
    }
}
class Undergraduate extends Student {
    private String degree;
    public Undergraduate(String name, int age, String degree) {
        super(name, age);
        this.degree = degree;
    }
    public void show() {
        System.out.println("名字：" + super.getName() + "\t年龄：" + super.getAge() + "\t学位:" + this.degree);
    }
}


输出：

略

文章标签：
Java
索引
关键词：
Java类
Java元素
Java子类
Java重复元素
Java类子类
HannYang
目录
相关文章
34789737
|
7天前
|
存储 Java 索引
用Java语言实现一个自定义的ArrayList类
自定义MyArrayList类模拟Java ArrayList核心功能，支持泛型、动态扩容（1.5倍）、增删改查及越界检查，底层用Object数组实现，适合学习动态数组原理。
34789737
53 4
34789737
|
11天前
|
IDE JavaScript Java
在Java 11中，如何处理被弃用的类或接口？
在Java 11中，如何处理被弃用的类或接口？
34789737
102 5
凉凉心.
|
15天前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
66 1
凉凉心.
|
15天前
|
Java Go 开发工具
【Java】（8）正则表达式的使用与常用类分享
正则表达式定义了字符串的模式。正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
凉凉心.
130 1
凉凉心.
|
15天前
|
存储 Java 程序员
【Java】（6）全方面带你了解Java里的日期与时间内容，介绍 Calendar、GregorianCalendar、Date类
java.util 包提供了 Date 类来封装当前的日期和时间。Date 类提供两个构造函数来实例化 Date 对象。第一个构造函数使用当前日期和时间来初始化对象。Date( )第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
凉凉心.
95 1
凉凉心.
|
15天前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
59 1
蓝易云
|
20天前
|
编解码 Java 开发者
Java String类的关键方法总结
以上总结了Java `String` 类最常见和重要功能性方法。每种操作都对应着日常编程任务，并且理解每种操作如何影响及处理 `Strings` 对于任何使用 Java 的开发者来说都至关重要。
蓝易云
165 5
宫水三叶的刷题日记
|
Java
删除排序链表中的重复元素（虚拟头结点技巧）｜Java 刷题打卡
删除排序链表中的重复元素（虚拟头结点技巧）｜Java 刷题打卡
宫水三叶的刷题日记
150 0
小白学大数据
|
1月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
160 1
Java 数据库 Spring
89 0

热门文章

最新文章

  • 1
    构建基于Java的AI智能体：使用LangChain4j与Spring AI实现RAG应用
  • 2
    Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
  • 3
    使用LangChain4j构建Java AI智能体：让大模型学会使用工具
  • 4
    Java新特性：使用Stream API重构你的数据处理
  • 5
    2025 年 Java 从零基础小白到编程高手的详细学习路线攻略
  • 6
    告别字符串拼接：用Java文本块优雅处理多行字符串
  • 7
    基于JavaWeb的销售管理系统设计系统
  • 8
    Java异常处理：程序世界的“交通规则
  • 9
    告别空指针噩梦：Optional让Java代码更优雅
  • 10
    告别NullPointerException：拥抱Java Optional
  • 1
    2025 版 Java 零基础入门到精通实操指南
    807
  • 2
    java 入门学习视频_2025 最新 java 入门零基础学习视频教程
    170
  • 3
    顺丰同城抢单辅助脚本，顺丰骑士抢单辅助免封号，自动抢单神器【java版开源】
    535
  • 4
    现代化 java 分层开发实施策略与最佳实践指南
    169
  • 5
    我们详细地讲解一下 Java 异常及要如何处理
    93
  • 6
    MinIO Java SDK 7.1.4 升级到 8.5.17 需要注意什么
    350
  • 7
    微信不封号无限加人软件，微信一键自动加人软件，java实现批量化加人
    118
  • 8
    Java 与 C++ 区别深入剖析及应用实例详解
    396
  • 9
    Java 生态大模型应用开发全流程实战案例与技术路径终极对决
    656
  • 10
    Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
    100

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云oss简介和如何对接使用