Iterative solution

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = l1;

        ListNode prev = dummyNode;
        int carry = 0;

        while (l1 != null && l2 != null) {
            int num = l1.val + l2.val + carry;
            System.out.println(num);
            l1.val = num > 9 ? (num - 10) : num;
            carry = num > 9 ? 1 : 0;

            prev = l1;
            l1 = l1.next;
            l2 = l2.next;
        }

        while (l1 != null) {
            int num = l1.val + carry;

            l1.val = num > 9 ? (num - 10) : num;
            carry = num > 9 ? 1 : 0;

            prev = l1;
            l1 = l1.next;
        }

        while (l2 != null) {
            int num = l2.val + carry;

            l2.val = num > 9 ? (num - 10) : num;
            carry = num > 9 ? 1 : 0;

            prev.next = l2;
            prev = prev.next;
            l2 = l2.next;
        }

        if (carry != 0) {
            prev.next = new ListNode(carry);
        }

        return dummyNode.next;
    }
}

Recursive

this one is faster

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        return helper(l1, l2, 0);
    }

    private ListNode helper(ListNode l1, ListNode l2, int carry) {
        if (l1 == null && l2 == null & carry == 0) return null;

        int num = (l1 == null ? 0 : l1.val) + (l2 == null ? 0 : l2.val) + carry;

        carry = num / 10;
        int digit = num % 10;

        ListNode node = new ListNode(digit);
        node.next = helper(l1 == null ? null : l1.next, l2 == null ? null : l2.next, carry);

        return node;
    }
}