给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
这是一个非常经典的链表问题，可以采用模拟加法的方式来解决。具体地讲，我们可以维护一个表示进位的变量carry，然后将两个链表上对应的节点相加并加上进位carry，最后得到的结果就是当前位置上的数字，如果超过了10，那么需要将进位carry设置为1，否则设为0。
具体操作步骤如下：
1.首先定义一个空节点dummy和一个指针p，表示结果链表的头节点和当前节点。
2.定义两个指针p1和p2分别指向两个链表的头节点，然后遍历它们，直到其中一个链表为空为止。
3.在循环中，首先计算当前位置上的数字，然后新建一个节点存储这个数字，并将其添加到结果链表末尾。同时更新进位carry的值。
4.如果一个链表已经遍历完了，那么我们需要将另一个链表剩余的部分以及进位carry依次加到结果链表中。
5.最后返回dummy的下一个节点即可。
代码实现如下：
package com.example.算法;
public class ListNode1 {
public static void main(String[] args) {
//创建两个链表l1和l2（此处省略创建过程）
ListNode1 l1 = new ListNode1(2, new ListNode1(4, new ListNode1(3)));
ListNode1 l2 = new ListNode1(5, new ListNode1(6, new ListNode1(4)));
//调用addTwoNumbers函数计算结果
ListNode1 result = addTwoNumbers(l1, l2);
//遍历并输出新链表中的每个节点值
while (result != null) {
System.out.print(result.val + " ");
result = result.next;
}
}
int val;
ListNode1 next;
ListNode1() {
}
ListNode1(int val) {
this.val = val;
}
ListNode1(int val, ListNode1 next) {
this.val = val;
this.next = next;
}
public static ListNode1 addTwoNumbers(ListNode1 l1, ListNode1 l2) {
ListNode1 dummy = new ListNode1(0); // 这里需要用到哑结点技巧
ListNode1 tail = dummy; // 定义一个尾指针，用于构建答案链表
int carry = 0; // 进位信息，初始值为0
while (l1 != null || l2 != null) {
int x = (l1 != null) ? l1.val : 0;
int y = (l2 != null) ? l2.val : 0;
int sum = carry + x + y;
carry = sum / 10; // 更新进位信息
tail.next = new ListNode1(sum % 10); // 构造答案链表的下一个节点
tail = tail.next; // 将尾指针向后移动一位
if (l1 != null) {
l1 = l1.next;
}
if (l2 != null) {
l2 = l2.next;
}
}
if (carry > 0) {
tail.next = new ListNode1(carry); // 处理最高位的进位
}
return dummy.next; // 返回哑结点的下一个节点，即为所求的答案链表
}
}
常用方法
package com.example.算法;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import static java.util.Collections.replaceAll;
public class ListNode {
public static void main(String[] args) {
final int l1 = 9999999;
final int l2 = 9999;
int carry = 0;
String a = new Demo().lee(l1, l2);
System.out.println("------------------------------------");
String a2 = new Demo().lee3(l1, l2);
System.out.println("------------------------------------");
Double aa = 1003.0;
aa = aa / 10;
System.out.println(aa);
int abc = aa.intValue();
System.out.println(abc);
}
}
class Demo {
public String lee(int l1, int l2) {
int num = l1 + l2;
// 反转后的数字
int reverseNum = 0;
// 反向遍历每一位数字
while (num != 0) {
int digit = num % 10; //10的余数可以理解为取最后个位数
// System.out.println("现在的digit代表着个位数" + digit);
reverseNum = reverseNum * 10 + digit; // 将个位数添加到反转数中
num /= 10; // 去掉已处理的最后一位数
}
// 将反转后的数字转换成字符串形式
String nums = Integer.toString(reverseNum);
// 创建一个 StringBuffer 对象，用于拼接结果字符串
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nums.length(); i++) {
//append 拼接字符串 nums.charAt(i) 先拿到其中的每一位
sb.append(nums.charAt(i));
// 如果不是最后一位数字，则在数字之间添加一个逗号
if (i != nums.length() - 1) {
sb.append(",");
}
}
// 将 StringBuffer 对象转换成字符串，并返回结果
String fa = sb.toString();
System.out.println("输出:1[" + fa + "]");
return fa;
}
public String lee3(int l1, int l2) {
int num = l1 + l2;
List<Integer> digits = new ArrayList<>();
// 取出每一位数字并添加到列表中
while (num > 0) {
//余数可以理解为取最后个位数 相当于把数据倒序了下取出来 num%10 取出来个位数 add 给了digits 下面再把已经add的数据删除了
digits.add(num % 10);
//再取消最后一位 把上面num % 10
num /= 10;
}
// 将列表中的数字反转并拼接成字符串
//首先使用stream()方法将整数列表转换为流，然后使用map()方法将每个整数转换为字符串形式。Object::toString
// 表示将每个对象（包括整数）转换为它的字符串表示形式。最后，使用collect()方法与Collectors.joining()静态方法结合使用，
// 使用逗号连接符将所有字符串组合在一起，并返回拼接后的字符串。
String fa = digits.stream()
.map(Object::toString)
.collect(Collectors.joining(","));
System.out.println("输出3:[" + fa + "]");
return fa;
}
}
这是一段Java代码，主要实现了将两个整数相加，并将其结果按照逆序的形式输出为字符串。代码中使用了两种不同的方法来实现，第一种方法中，通过取余和除法操作，反向遍历每一位数字，并将其添加到反转数中；第二种方法中，先将计算得到的数字存储在一个列表中，再将列表中的数字反转并拼接成字符串。最后，通过调用main()方法，可以得到程序的输出结果。
具体来说，代码中包含以下重要的部分：
两个整数相加
代码中定义了两个常量l1和l2，它们分别代表需要相加的两个整数。通过将它们相加，得到了num的值，即两数之和。
final int l1 = 9999999;
final int l2 = 9999;
int num = l1 + l2;
反向遍历每一位数字
为了将数字逆序输出，代码中使用了while循环语句，对num进行反向遍历。在每次循环中，通过对10取余的操作获取num的最后一位数字，并将其添加到reverseNum中。然后，通过除以10的操作，去掉已经处理过的最后一位数字。当num等于0时，说明所有的数字都已经处理完毕，循环结束。
while (num != 0) {
int digit = num % 10;
reverseNum = reverseNum * 10 + digit;
num /= 10;
}
将数字转换成字符串并输出
代码中先将反转后的数字reverseNum转换成字符串形式nums，然后遍历其中的每一位数字，在数字之间添加一个逗号，并将结果添加到StringBuffer对象sb中。最后，将sb转换成字符串fa并返回。
String nums = Integer.toString(reverseNum);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nums.length(); i++) {
sb.append(nums.charAt(i));
if (i != nums.length() - 1) {
sb.append(",");
}
}
String fa = sb.toString();
System.out.println("输出:1[" + fa + "]");
return fa;
使用流操作将数字反转并拼接成字符串
代码中定义了另外一个方法lee3，它与前面的方法lee相比，使用了Java8中新增的流操作来实现。具体来说，代码中首先将计算得到的数字num中的每一位数字添加到一个列表digits中，然后通过stream()、map()和collect()等方法，将列表中的数字反转并拼接成字符串。最后，将拼接后的字符串fa返回。
List<Integer> digits = new ArrayList<>();
while (num > 0) {
digits.add(num % 10);
num /= 10;
}
String fa = digits.stream()
.map(Object::toString)
.collect(Collectors.joining(","));
System.out.println("输出3:[" + fa + "]");
return fa;
总的来说，这段代码使用了两种不同的方法来实现将两个整数相加，并将其结果按照逆序的形式输出为字符串。其中，通过取余和除法操作反向遍历每一位数字的方法更加直观易懂，而使用流操作来实现则更加简洁高效。不同的方法都有各自的优点和适用场景，根据具体情况进行选择即可。
在第一种方法中，代码通过while循环语句遍历整数的每一位数字，并将其添加到一个反转数中。然后，将反转后的数字转换成字符串并遍历其中的每一位数字，在数字之间添加逗号并输出为字符串。
在第二种方法中，代码首先将计算得到的数字中的每一位数字添加到一个列表中，然后使用流操作将列表中的数字反转并拼接成字符串。
总的来说，这段代码展示了Java中不同的处理方式来实现相同的目标，并且说明了它们的优点和适用场景。
