Improvement to Luhn-Checksum Algorithm in Java I just made a small Luhn Checksum validator
Description of Luhn Checksum
Every number in the Integer gets added individually together, but every second digit gets instead doubled and added. If the doubled number is over ten each individual digit gets added.
It works, but is there a way to make it more elegant and maybe more efficient, while maintaining readability?
The while loop seems a bit ugly to me, and I'm not completely satisfied with the name getLuhn but I don't know how else to name it.
public class Luhn {
    public static void main(String[] args) {
        System.out.println(validate(1762483));
    }

    public static boolean validate(int id){
        int totalSum = 0;
        while(id&gt;0){
            totalSum += id%10;
            id /= 10;
            if(id&gt;0){
                totalSum += getLuhn(id%10);
                id /= 10;
            }
        }
        return (totalSum%10 == 0);
    }

    private static int getLuhn(int id){
        id *= 2;
        return id%10 + id/10;
    }
}

Every comment is appreciated &lt;3
From cleaner code, over more idiomatic Java, to improvements in performance.
There is not much to improve in your code, it's compact and efficient. These are few suggestions:
Input validation
When the input number is negative the result is always true. To avoid confusion you can launch an exception.
public static boolean validate(int id) {
        if (id &lt; 0) {
            throw new IllegalArgumentException(&quot;Input cannot be negative.&quot;);
        }
        // ..
}

Clarity
The Luhn Checksum algorithm is described very well on Wikipedia and by you on your question, but your implementation is not easy to follow. For example:
totalSum += id%10;

Here the last digit of id is added to totalSum. Adding a method (with the explanation of the operation in the name) makes it more readable:
totalSum += getRightMostDigit(id);

Same for:
id /= 10;

This operation removes the last digit of id, which can be changed to:
id = dropRightMostDigit(id);

I would also change the input variable name from id to number, but this is personal taste.
Perfomance
It's hard to improve performance and keep readability for your method. The only change I would suggest is to replace the getLuhn method with a static array.
This change makes it two times faster on my machine and gets rid of the additional method.
Code refactored
public static boolean validate(int number) {
    if (number &lt; 0) {
        throw new IllegalArgumentException(&quot;Input cannot be negative.&quot;);
    }
    // Array containing:
    // - for index in [0,4]: the double of the index value   
    // - for index in [5,9]: the sum of the digits of the doubled index value. E.g. index = 6 -&gt; 6*2 = 12 -&gt; 1+2 = 3
    int[] luhn = new int[] { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };
    
    int totalSum = 0;
    while (number &gt; 0) {
        totalSum += getRightMostDigit(number);
        number = dropRightMostDigit(number);
        if (number &gt; 0) {
            totalSum += luhn[getRightMostDigit(number)];
            number = dropRightMostDigit(number);
        }
    }
    return totalSum % 10 == 0;
}

private static int getRightMostDigit(int number) {
    return number % 10;
}

private static int dropRightMostDigit(int number) {
    return number / 10;
}


Personal opinion
Many implementations of the Luhn Checksum accept a String as input, so they can be used to validate credit cards or simply to operate on numbers bigger than an int. What is the use case of your algorithm?
The purpose of your implementation can also be included as a comment, it will help others to understand whether they need it or not.