java-MT14_整数加法

java-MT14 整数加法

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        while(in.hasNext()){
            solution(in);
        }
    }

    /**
     * 模拟法
     * @param in
     */
    private static void solution(Scanner in){
        String[] nums = in.nextLine().split(" ");
        String num0 = nums[0];
        String num1 = nums[1];

        if(num0.matches("\\d+") && num1.matches("\\d+")){
            StringBuilder sb = new StringBuilder();
            normalAdder(sb, num0, num1);
            System.out.println(sb);
        }else{
            System.out.println("error");
        }
    }

    /**
     * 两个字符串 对位相加
     * @param sb
     * @param num0
     * @param num1
     */
    private static void normalAdder(StringBuilder sb, String num0, String num1){
        int len0 = num0.length();
        int len1 = num1.length();
        int lenMin = Math.min(len0, len1);

        int carry = 0;
        int sum;
        int remainder;
        for(int i=1; i<=lenMin; i++){
            char ch0 = num0.charAt(len0-i);
            char ch1 = num1.charAt(len1-i);
            sum = carry + Integer.parseInt(String.valueOf(ch0)) + Integer.parseInt(String.valueOf(ch1));
            carry = sum/10;
            remainder = sum%10;
            sb.insert(0, remainder);
        }

        if(len0 == len1){
            if(carry > 0){
                sb.insert(0, carry);
            }
        }else{
            if(len0 > lenMin){
                singleAdder(sb, num0, lenMin, len0, carry);
            }
            if(len1 > lenMin){
                singleAdder(sb, num1, lenMin, len1, carry);
            }
        }
    }

    /**
     * 单个字符串 多余部分与进位相加
     * @param sb
     * @param num
     * @param lenMin
     * @param lenMax
     * @param carry
     */
    private static void singleAdder(StringBuilder sb, String num, int lenMin, int lenMax, int carry){
        int sum, remainder;
        for(int i=lenMin+1; i<=lenMax; i++){
            char ch = num.charAt(lenMax-i);
            sum = carry + Integer.parseInt(String.valueOf(ch));
            carry = sum/10;
            remainder = sum%10;
            sb.insert(0, remainder);
        }
        if(carry > 0){
            sb.insert(0, carry);
        }
    }
}
### Java `MethodType` 使用说明 #### 方法类型表示 在 Java 中,`MethodType` 类用于描述方法签名。它包含了参数列表以及返回类型的定义[^1]。 ```java import java.lang.invoke.MethodType; public class MethodTypeInfo { public static void main(String[] args) throws Throwable { // 定义一个接受两个整数并返回整数的方法类型 MethodType mt = MethodType.methodType(int.class, int.class, int.class); System.out.println("Defined method type: " + mt.toString()); } } ``` 此代码片段展示了如何创建一个代表特定方法签名的对象实例。这里创建了一个名为 `mt` 的对象,该对象表示接收两个 `int` 参数并返回单个 `int` 值的方法类型。 #### 获取现有方法的 `MethodType` 除了手动构建外,还可以通过反射机制来获得已存在类中某个具体方法对应的 `MethodType` 实例: ```java import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodType; class ExampleClass { public String greet(String name) { return "Hello, " + name; } } public class ReflectionExample { public static void main(String[] args) throws Throwable { MethodHandles.Lookup lookup = MethodHandles.lookup(); MethodType mt = lookup.findVirtual(ExampleClass.class, "greet", MethodType.methodType(String.class, String.class)).type(); System.out.println("Retrieved method type via reflection: " + mt.toString()); } } ``` 这段程序先查找了给定名称和参数类型的虚拟方法句柄,再从中提取出其关联的方法类型信息。 #### 动态调用与适配器模式 利用 `MethodType` 和其他相关 API 可实现动态调用不同形式的目标函数,甚至可以方便地转换它们之间的接口差异——即所谓的适配器模式。这使得编写更加灵活通用的应用成为可能。 ```java import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodType; interface MathOperation { double apply(double x, double y); } public class AdapterPatternDemo { private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); @SuppressWarnings("removal") public static void main(String[] args) throws Exception { // 创建加法操作的手柄 MethodHandle adderMH = LOOKUP.findStatic(DoubleMathOps.class, "add", MethodType.methodType(double.class, double.class, double.class)); // 将手柄转化为目标接口的形式 MathOperation opAddition = (MathOperation) MethodHandles.insertArguments( MethodHandles.exactInvoker(MethodType.methodType(double.class, double.class)), 0, adderMH); System.out.printf("%.2f + %.2f = %.2f%n", 3.5, 4.7, opAddition.apply(3.5, 4.7)); } static class DoubleMathOps { public static double add(double a, double b) { return a + b; } } } ``` 上述例子展示了一种方式,即将静态方法作为可执行单元封装到实现了自定义接口的对象里去。这种方式不仅限于简单的算术运算,在更复杂的场景下也能发挥重要作用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值