Ttykuu

Approach 1:

Repeated division-modulus operations:

long num = 123456789;
int count = 0;
while(num > 0)

 int digit = num % 10;
 if(digit == 1)
 count ++;
 num /= 10;

Approach 2:

Convert it into an String and get the characters at the position:

long num = 123456789;
int count = 0;
String s = String.valueOf(num);
for(int i = 0; i < s.length(); i++)

 char ch = s.charAt(i);
 if(ch == '1')
 count ++;

The second operation doesn't need to get the remainder and the quotient each time. A charAt() method can be enough.

Which approach is considered to be better and why?

Consider taking the input from the console.

1st Case:

long num = scanner.nextLong();

2nd Case:

String s = scanner.nextLine();

Here there would be no overhead on converting the number to string.

Also let us assume it is for positive numbers.

I would suggest a third approach that extends the conversion-to-string approach: conversion to List of Character

The benefits of this is that you can utilise Java 8 collection stream feature to perform filtering, aggregation and other functions on the elements.

for instance, your example can be expressed as such (edited following @h.j.k's comment):

 long num = 123456789;
 String s = String.valueOf(num);
 long count = s.chars()
 .mapToObj(i -> (char)i)
 .filter(ch -> ch.equals('1'))
 .count();

This method below allows you to get a specific number from a int value based on a specific index

 public static int getSpecificNum(int number, int index) 
 int numOfDigits = 0;
 int pow = 1, test = 0, counter = 0;

//gets the number of digits

 while (test != number) // once the full int is retrieved
 counter++;//<-digit counter
 pow *= 10;
 test = number % pow;//go through the entire int
 

// number of digits are found, reset everything

 numOfDigits = counter;
 counter = 0;
 pow = 1;
 test = 0;

// now count until the index

 while (counter != (numOfDigits - index)) // this is numOfDigits was needed
 counter++;
 pow *= 10;
 test = number % pow;// same thing

 

// exp = finding the power of 10

 int exp = numOfDigits - (index + 1);
 exp = (int) Math.pow(10, exp);
 return test / exp;//divide and conquer 

Corner failure

while(num > 0) ... fails to get the right count when long num = 0; and the digit sought is 0. count result is 0. I'd expect 1.

Failure when num < 0 as int digit = num % 10; will result in a negative value.

Oops now see in the end: "Also let us assume it is for positive numbers." Making answer wiki as a reference.

Too bad as it is not difficult to make the code work for all int.

If you want to find the length of the number you don't need an array. Just using log base 10 will get you the number of places the number has so,

long num = 1234567890;
int length = (int) Math.log10(num); //should make the length 9

Now to get a specific number it's

public int getNthDigit(int number, int base, int n) 
return (int) ((number / Math.pow(base, n - 1)) % base);

if you enter getNthDigit(num,10,2); then it will return 2.