Luhn Check program in Java не правильно вычисляется

Question

Я создал эту проверку Luhn Check (или Mod 10) на Java, а четные и нечетные суммы не складываются правильно, и я не могу понять, почему. Это сработало, когда я написал этот раздел отдельно, и он, казалось, работал нормально. В целом программа со всеми другими Методами не работает. У кого-нибудь есть идеи?

Ввод номера 4388576018410707 должен быть действительным.

import java.util.Scanner; 
import java.io.*; 

public class combineAll { 

    public static void main(String[] args) { 
     Scanner input = new Scanner(System.in); 
     System.out.print("Enter a credit card number: "); 
     long userInput = input.nextLong(); 

     int getSize=getSize(userInput); //Run getSize() Method. 
     Integer z = (int) (long) getPrefix(userInput, getSize); //Run getPrefix() Method. 

     if (prefixMatch(userInput, z)== true) { //Run prefixMatch() Method. 
      long n=sumbOfDoubleEvenPlace(userInput); //Run sumbOfDoubleEvenPlace() Method. 
      long m=sumOfOddPlace(userInput); //Run sumOfOddPlace() Method. 
      System.out.println("Total Even: " +n); 
      System.out.println("Total Odd: " +m); 
      long v=n+m; 
      if (isValid(v)==true) { 
       System.out.println("Valid"); 
      } else if (isValid(v)==false){ 
       System.out.println("Invalid"); 
      } 
     } else { 
      System.out.println("Invalid"); 
     } 
    } //End main 

    //Return the number of digits in d 
    public static int getSize(long d) { 
     String str = Long.toString(d); 
     int x = str.length(); 
     return x; 
    } 

    //Return the first k number of digits from number. If the number of digits in number is less than k, return number 
    public static long getPrefix(long number, int k) { 
     int z=0; 
     if (k>=13 && k<=16) { 
      String str = Long.toString(number); 
      String g = str.substring(0,1); 
      String h = str.substring(0,2); 

      int d=Integer.parseInt(g); 
      int q=Integer.parseInt(h); 

      if (d==4 || d==5 ||d==6) { 
       z=d; 
      } else if (q==37) { 
       z=q; 
      } 

     } else { 
      z=-1; 
     } 

     return z; 
    } 

    //Return true if the digit d is a prefix for number 
    public static boolean prefixMatch(long number, int d) { 
     if (d==4 || d==5 || d==6 || d==37) { 
      return true; 
     } else { 
      return false; 
     } 
    } 

    //Get the result from step 2 
    public static int sumbOfDoubleEvenPlace(long number) { 
     long a=number; 
     int d=0; //Adds each individual numbers. 
     while (a>0) { 
      long b=0; 
      long c=0; //Equals the Mod of UserInput. 
      a=a/10; 
      c=a%10; 
      System.out.println("even: " +c); 
      b=c*2; 

      if (b>=10) { 
       Integer digit = (int) (long) b; 
       d+=getDigit(digit); //Run getDigit() Method. 
      } else { 
       Integer digit = (int) (long) b; 
       d+=b; 
      } 

      a=a/10; //Advance decimal one space to the left. 
     } 
     return d; 
    } 

    //Return sum of odd-place digits in number 
    public static int sumOfOddPlace(long number) { 
     long a=number; 
     int d=0; //Adds each individual numbers. 
     while (a>0) { 
      long b=0; 
      long c=0; //Equals the Mod of UserInput. 
      c=a%10; 
      System.out.println("odd: " +c); //Print for debugging. 
      b=c*2; 

      if (b>=10) { 
       Integer digit = (int) (long) b; 
       d+=getDigit(digit); //Run getDigit() Method. 
      } else { 
       Integer digit = (int) (long) b; 
       d+=b; 
      } 

      a=a/10; //Advance decimal one space to the left. 
      a=a/10; 
     } 
     return d; 
    } 

    //Return this number if it is a single digit, otherwise return the sum of the two digits 
    public static int getDigit(int number) { 
     int d=0; 
     int x=0; 
     int y=number; 
     while (y>0) { 
      x+=y%10; 
      y=y/10; 
     } 
     return x; 
    } 

    //Return true if the card number is valid 
    public static boolean isValid(long number) {  
     long c=number%10; 
     if (c==0) { 
      return true; 
     } else { 
      return false; 
     } 
    } 
} 

Answer 1

Код немного трудно поддается наблюдению. На основе формы описания алгоритма Wikipedia реализация должна быть намного проще. Here - другая реализация после описания от Wikipedia.

public class Cards { 
/** 
* Checks if the card is valid 
* 
* @param card 
*   {@link String} card number 
* @return result {@link boolean} true of false 
*/ 
public static boolean luhnCheck(String card) { 
    if (card == null) 
     return false; 
    char checkDigit = card.charAt(card.length() - 1); 
    String digit = calculateCheckDigit(card.substring(0, card.length() - 1)); 
    return checkDigit == digit.charAt(0); 
} 

/** 
* Calculates the last digits for the card number received as parameter 
* 
* @param card 
*   {@link String} number 
* @return {@link String} the check digit 
*/ 
public static String calculateCheckDigit(String card) { 
    if (card == null) 
     return null; 
    String digit; 
    /* convert to array of int for simplicity */ 
    int[] digits = new int[card.length()]; 
    for (int i = 0; i < card.length(); i++) { 
     digits[i] = Character.getNumericValue(card.charAt(i)); 
    } 

    /* double every other starting from right - jumping from 2 in 2 */ 
    for (int i = digits.length - 1; i >= 0; i -= 2) { 
     digits[i] += digits[i]; 

     /* taking the sum of digits grater than 10 - simple trick by substract 9 */ 
     if (digits[i] >= 10) { 
      digits[i] = digits[i] - 9; 
     } 
    } 
    int sum = 0; 
    for (int i = 0; i < digits.length; i++) { 
     sum += digits[i]; 
    } 
    /* multiply by 9 step */ 
    sum = sum * 9; 

    /* convert to string to be easier to take the last digit */ 
    digit = sum + ""; 
    return digit.substring(digit.length() - 1); 
} 

public static void main(String[] args) { 
    String pan = "4388576018410707"; 
    System.out.println("Validate pan number '" + pan + "': " + luhnCheck(pan2)); 
}  
}