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

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

2023-05-29 108
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
目录
相关文章
Java开发者
|
18天前
|
存储 缓存 安全
除了变量，final还能修饰哪些Java元素
在Java中，final关键字不仅可以修饰变量，还可以用于修饰类、方法和参数。修饰类时，该类不能被继承；修饰方法时，方法不能被重写；修饰参数时，参数在方法体内不能被修改。
Java开发者
22 2
Java开发者
|
17天前
|
存储 缓存 安全
java 中操作字符串都有哪些类，它们之间有什么区别
Java中操作字符串的类主要有String、StringBuilder和StringBuffer。String是不可变的，每次操作都会生成新对象；StringBuilder和StringBuffer都是可变的，但StringBuilder是非线程安全的，而StringBuffer是线程安全的，因此性能略低。
Java开发者
39 8
龙大吉
|
24天前
|
Java
那些与Java Set擦肩而过的重复元素，都经历了什么？
在Java的世界里，Set如同一位浪漫而坚定的恋人，只对独一无二的元素情有独钟。重复元素虽屡遭拒绝，但通过反思和成长，最终变得独特，赢得了Set的认可。示例代码展示了这一过程，揭示了成长与独特性的浪漫故事。
龙大吉
20 4
大树营养快线
|
1月前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
26 7
2G冲浪词条
|
26天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
31 1
软件求生
|
1月前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解（社招面试不踩坑）
本文介绍了Java中`Object`类的几个重要方法，包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点，掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景，详细解析了每个方法的作用和重写技巧，帮助读者更好地应对面试和技术开发。
软件求生
86 4
众所周知
|
29天前
|
存储 算法 Java
为什么Java Set如此“挑剔”，连重复元素都容不下？
在Java的集合框架中，Set是一个独特的接口，它严格要求元素不重复，适用于需要唯一性约束的场景。Set通过内部数据结构（如哈希表或红黑树）和算法（如哈希值和equals()方法）实现这一特性，自动过滤重复元素，简化处理逻辑。示例代码展示了Set如何自动忽略重复元素。
众所周知
28 1
众所周知
|
1月前
|
Java 编译器 开发者
Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面，帮助开发者提高代码质量和程序的健壮性。
众所周知
49 2
游客xl2p7nx4x3c7g
|
安全 Java 流计算
【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（下）
【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（下）
游客xl2p7nx4x3c7g
319 0
【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（下）
游客xl2p7nx4x3c7g
|
算法 Java 索引
【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（上）
【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（上）
游客xl2p7nx4x3c7g
264 0

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    Java - List＜Byte＞ 转 byte[ ]
  • 3
    阿里巴巴Java开发规约-插件使用[Idea和Eclipse]
  • 4
    关于Java面向对象的分析题
  • 5
    Java笔记8：java类，对象，方法
  • 6
    《连载 | 物联网框架ServerSuperIO教程》1.4种通讯模式机制。附小文：招.NET开发，结果他转JAVA了，一切都是为了生活
  • 7
    java-subString方法易导致内存溢出
  • 8
    【Java学习笔记】TCP客户端/服务器端
  • 9
    漫谈 Java 实例化类
  • 10
    Java程序内存分析：使用mat工具分析内存占用
  • 1
    面试官：素有Java锁王称号的‘StampedLock’你知道吗？我：这什么鬼？
    99
  • 2
    Java的取余如何编写代码
    75
  • 3
    Java获取字符串最后一位
    574
  • 4
    Java一分钟之-Lambda表达式与函数式接口
    75
  • 5
    Java一分钟之-Java内部类与匿名类
    47
  • 6
    Java一分钟之-Java注解的理解与应用
    49
  • 7
    Java一分钟之-Java反射机制：动态操作类与对象
    79
  • 8
    Java一分钟之线程池：ExecutorService与Future
    146
  • 9
    深入理解Java并发编程：线程安全与性能优化
    47
  • 10
    Java中Lambda表达式的深入理解与应用
    48

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月