Print 1 to 100 Without Loop in Java

Printing numbers without a loop in Java often involves alternative techniques, such as recursion or stream processing. In this section, we will discuss the methods to print numbers from 1 to 100 without using a traditional loop in Java. Both recursion and Java Streams offer alternative approaches, showcasing the flexibility and expressive power of the Java programming language.

Using Recursion

Recursion is a programming technique where a function calls itself, breaking down a problem into smaller subproblems. In this case, we will create a recursive function to print numbers from a specified start to end.

PrintNumbers.java

public class PrintNumbers {
    // Recursive method to print numbers from 'start' to 'end'
    public static void printNumbers(int start, int end) {
        if (start <= end) {
            System.out.print(start+"\t");
            printNumbers(start + 1, end);
        }
    }
    public static void main(String[] args) {
        int start = 1;
        int end = 100;
        System.out.println("Printing numbers from " + start + " to " + end + " using recursion:");
        printNumbers(start, end);
    }
}

Output:

Printing numbers from 1 to 100 using recursion:
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95	96	97	98	99	100

Using Java Streams

Java Streams provide a functional approach to process sequences of elements. We can use the IntStream class to generate a range of numbers and then apply the forEach() method to print each element.

PrintNumbers.java

import java.util.stream.IntStream;
public class PrintNumbers {
    public static void main(String[] args) {
        int start = 1;
        int end = 100;
        System.out.println("Printing numbers from " + start + " to " + end + " without a loop using Java Streams:");
        IntStream.rangeClosed(start, end)
            .forEach(System.out::println);
    }
}

Output:

Printing numbers from 1 to 100 using Java stream:
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95	96	97	98	99	100

Recursion, with its ability to break down a problem into simpler subproblems, provides an elegant solution. On the other hand, Java Streams leverage functional programming concepts, making the code concise and expressive.

Printing Numbers Within a Range

Let's expand the program by adding user input to specify the range of numbers to print. Here is a complete program with input and output.

PrintNumbers.java

import java.util.stream.IntStream;
import java.util.Scanner;
public class PrintNumbers {
    // Recursive method to print numbers from 'start' to 'end'
    public static void printNumbers(int start, int end) {
        if (start <= end) {
            System.out.println(start);
            printNumbers(start + 1, end);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // Get user input for the range of numbers
        System.out.print("Enter the starting number: ");
        int start = scanner.nextInt();
        System.out.print("Enter the ending number: ");
        int end = scanner.nextInt();
        // Print numbers using recursion
        System.out.println("Printing numbers from " + start + " to " + end + " without a loop:");
        printNumbers(start, end);
        // Print numbers using Java Streams
        System.out.println("\nPrinting numbers from " + start + " to " + end + " using Java Streams:");
        IntStream.rangeClosed(start, end)
                .forEach(System.out::println);
        scanner.close();
    }
}

Output:

Enter the starting number: 1
Enter the ending number: 100
Printing numbers from 1 to 100 without a loop:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
Printing numbers from 1 to 100 using Java Streams:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

The choice between recursion and Java Streams depends on factors such as project requirements, readability, and performance considerations. Recursion is well-suited for problems with a clear recursive structure, while Java Streams offer a functional and parallelizable approach for working with sequences.

Developers should weigh the advantages and considerations of each approach and choose the one that aligns with the specific needs of their project. Understanding both techniques enhances a programmer's toolkit, enabling them to tackle diverse challenges in a variety of contexts.

Next TopicRemove elements from a List that satisfy given predicate in Java

← prev next →