Explanation of JAVA code

Explanation of code "Magic number"

What is the magic number?
    If the single digit (which is the sum of all digits of the multi-digit number) comes to be 1 then the number is a magic number.

Example:
199 is a magic number as 
1+9+9=19
but 19 is not a single digit number so 
1+9=10 
and then 1+0=1
    
Let we see next code which finds whether given number is magic or not:
    
    import java.util.stream.IntStream;
import java.util.Scanner;
public class MagicNumber{
static int n,sum;
public static void main(String...mgc){
    n=new Scanner(System.in). nextInt();
    System.out.printf("%d is%s magic number",n,IntStream.iterate(1,j->j+1).map(i->(n=String.valueOf(n). chars().map(Character::getNumericValue).sum())).filter(i->i<10).findFirst(). getAsInt()==1?"":" not");     
}
}


Try it

In the code above we use the following built-in methods: printf(), IntStream, iterate(), chars(), map(), sum(), filter(), findFirst(), getAsInt().

Before explaining the code, we need to see the meaning of these methods.

printf()

Printf allows the programmer to specify textual representations of data using two parameters:

1. a format string, or "template," and
2. an argument list, or a  vector of data to be formatted according to the template.

Printf classes simply accept a pair of arguments:

(format_string, argument_vector)

where the first parameter defines the format, and the second parameter is a vector of elements. 

The format string is composed of literal substrings and format specifiers. When output is produced, literal substrings are copied verbatim, but format specifiers are replaced with string representations of elements in the argument list. The conversion of argument list elements into strings is governed by parameters embedded in the format specifiers. 

Format specifiers begin with a percent character (%) and terminate with a "type character," which indicates the type of data (int, string, etc.) that will be converted the basic manner in which the data will be represented. 
Some of format specifier:
%d  -> signed decimal integer
%s  -> string 
%c  -> character

For example :

System.out.printf("%s has %d apples and %d pears", "John", 2, 3); // John has 2 apples and 3 pears
Try it

IntStream

IntStream is a stream of primitive int values. IntStream replace traditional for (int i=0;...) loop.

There are several ways of creating an IntStream:

Let's start by looking at the "of" function.

IntStream.of(1, 2, 3); // > 1, 2, 3 
"of" just takes an arbitrary number of ints, creating an IntStream based on them.

Usually we don't want to list up all the ints like this, so let's instead continue by looking at two functions that probably will be used most of the time:
IntStream.range(1, 3); 
// > 1, 2 
IntStream.rangeClosed(1, 3); 
// > 1, 2, 3 

With "range" and "rangeClosed", we define a range of ints that we want to create a stream of.
As you probably guessed from the resulting streams, the "rangeClosed" function includes the ending int, while "range" excludes it.

Now what if we don't want all the ints within a range? What if we just want every even number?
Then we could use the iterator function.
IntStream.iterate(0, i -> i + 2).limit(3); 
// > 0, 2, 4 
Try it

With "iterator" we can define a start value and a function that will calculate the next ints based on the previous element.

"iterator" creates an infinite stream, so I've used "limit()" to create a stream containing just three elements.

Note: In the code "Magic number" the infinite stream was interrupted by the findFirst() method instead of the limit() method.

findFirst(), getAsInt(), chars()

The findFirst() method finds the first element in a Stream. Obviously, this method is used when you specifically want the first element from a sequence.

FindFirst returns an OptionalInt, getAsInt() method returns the int represented by the OptionalInt instance.

With chars() method we creating IntStream which contains an integer representation of the characters from the String object.

map()

Once you have a Stream object, you can use a variety of methods to transform it into another Streamobject. The first such method we’re going to look at is the map() method. 
It takes a lambda expression as its only argument, and uses it to change every individual element in the stream. Its return value is a new Stream object containing the changed elements.

To give you a realistic example, let me show you how you can use map to convert all elements in an array of strings to uppercase.

String[] myArray = new String[]{"bob", "alice", "paul", "ellie"};  
//You start by converting the array into a Stream:String[] myNewArray = Arrays.stream(myArray)
//Then you call the map method, passing a lambda expression, one which can convert a string to uppercase, as its sole argument:
    .map(s -> s.toUpperCase())
//The Stream object returned contains the changed strings. To convert it into an array, you use its toArray method:
    .toArray(String[]::new);
//At this point, you have an array of strings, all of which are in uppercase:
// [ BOB, ALICE, PAUL, ELLIE ]

Try it

filter()

Sometimes, you might want to work with only a subset of the elements. To do so, you can use the filter() method. 
Just like the map method, the filter method expects a lambda expression as its argument. However, the lambda expression passed to it must always return a boolean value, which determines whether or not the processed element should belong to the resulting Streamobject.

For example, if you have an array of strings, and you want to create a subset of it which contains only those strings whose length is more than four characters, you would have to write the following code:
String[] myNewArray1 = Arrays.stream(myArray).filter(s -> s.length() > 4).toArray(String[]::new);
// [ alice, ellie ]
Try it

sum()

A reduction operation is one which allows you to compute a result using all the elements present in a stream. 
Reduction operations are also called terminal operations because they are always present at the end of a chain of Stream methods. 

Java 8 includes several reduction methods, such as sum, average and count, which allow to perform arithmetic operations on Streamobjects and get numbers as results.

For example, if you want to find the sum of an array of integers, you can use the following code:
int myIntArray[] = { 1, 5, 8 }; 
int sum = Arrays.stream(myIntArray).sum();
// 14 
Try it

Explanation of code "Magic number"

Now, let we see the code with explanation:
import java.util.stream.IntStream;
import java.util.Scanner;
public class MagicNumber{
static int n,sum;
public static void main(String...mgc){
    // geting number from user who will be tested whether is magic number or not:
    n=new Scanner(System.in). nextInt();
    // Display result using printf() which has "format string" and 2 argument specified with string specifiers : %d (number) will be replaced with first argument (given number "n"), and %s (String) will be replaced with second argument (with "" in case that sum of digits become 1, otherwise with " not"):
    System.out.printf("%d is%s magic number",n,
    // here we start loking at value of second argument ("" in case that sum of digits become 1, otherwise value will be " not")
    // Since we do not know how much iteration will be needed to get a single digit as sum of digits, we will set infinite Streams (with iterate(0,j->j+1)) that we will interrupt with the findFirst () method. This means that if the result of the iteration is a single digit (single digit will pass filter(i->i<10)), the stream is interrupted.
    IntStream.iterate(1,j->j+1)
    // in the map we will store the sum of digits until the sum of digits is less than 10 (single digits). If that sum is less than 10, the filter will miss this value further to findFirst (), which will stop the iteration. The method getAsInt () returns the value returned as the int type.
    // in the case of a sum of digits => 10, the iteration is repeated.
    // in each iteration, the value n is changed and assumes the value sum of digits for the next iteration
    // the sum of the digit n will be obtained by converting the number n into a string (String.valueOf(n)), then using the method chars() store each digit to the map (char convert to the integer-> Character::getNumericValue), and use the sum method() to get a sum of digits
    /* Here how that looks in case that input is n=199 :
        1. iteration (n=199)
       .map( "199".chars().map(store: 1,9 and 9).sum() -> store 19 and n=19)
       .filter(19 no pass because 19 less than 10 is false)
       .findFirst(no found anything) -> go to 2.iteration
       
        2. iteration (n=19)
       .map( "19".chars().map(store: 1 and 9).sum() -> store 10 and n=10)
       .filter(10 no pass because 10 less than 10 is false)
       .findFirst(no found anything) -> go to 3.iteration
       
        3. iteration (n=10)
       .map( "10".chars().map(store: 1 and 0).sum() -> store 1 and n=1)
       .filter(1 pass because 1 less than 10 is true)
       .findFirst(found OptionalInt 1) -> stop the iteration
       .getAsInt(return OptionalInt value as int value) -> return 1
    */
    .map(i->(n=String.valueOf(n). chars().map(Character::getNumericValue).sum()))
    .filter(i->i<10)
    .findFirst()
    // if value (sum) == 1, return string "". Otherwise, return string " not"
    .getAsInt()==1?"":" not");     
}
}

Try it 


That's it!
I hope you enjoyed in journey through the code "Magic number" 😉

Good luck and keep coding! 💻⌨️🖱️

Created by: