DEV Community: Ricardo Caselati

Exploring While and DoWhile in Java: Master Loop Structures with Practical Examples

Ricardo Caselati — Sat, 28 Dec 2024 13:46:06 +0000

This article will delve into two of Java's most fundamental programming structures: While and DoWhile loops. Understanding when and how to use them is essential for writing efficient code, solving dynamic problems, and manipulating data intelligently. Let’s explore their applications with practical examples.

Previously in this series, we learned how to use the For loop in Java. Today, we will focus on While and DoWhile loops. How should you choose between these options in your daily programming tasks? Here's a tip: “Use the For loop when you know the required number of iterations. Use While when the number of iterations is unknown.”

Let's get started with some code!

While Loop

The following example demonstrates how a While loop iterates until a condition is satisfied. This is particularly useful when the exact number of iterations is not predetermined.

public class WhileExample {
    public static void main(String[] args) {
        int totalSubscribers = 100; // Example data
        int availableCoupons = 50;
        int currentSubscriber = 1;

        while (currentSubscriber <= availableCoupons) {
            // Print message that the subscriber won a coupon
            printMessage("Subscriber number " + currentSubscriber + " won a coupon!");
            // Increment the number of processed subscribers
            currentSubscriber++;
        }
    }

    static void printMessage(String message) {
        System.out.println(message);
    }
}

In the above code, we simulate a promotion where only the first 50 subscribers receive a discount coupon for a product. As long as currentSubscriber is less than or equal to the number of coupons, a message is printed in the terminal, and currentSubscriber is incremented by 1. This process continues until the condition is no longer met.

DoWhile Loop

The logic for the DoWhile loop is similar to While but with one significant difference: the validation is performed at the end of the loop. In other words, the block of code executes first, and then the condition is checked. Here’s an example:

public class WhileExample {
    public static void main(String[] args) {
        int totalSubscribers = 100; // Example data
        int availableCoupons = 50;
        int currentSubscriber = 1;

        while (currentSubscriber <= availableCoupons) {
            // Print message that the subscriber won a coupon
            printMessage("Subscriber number " + currentSubscriber + " won a coupon!");
            // Increment the number of processed subscribers
            currentSubscriber++;
        }
    }

    static void printMessage(String message) {
        System.out.println(message);
    }
}

In this example, a school tries to contact selected candidates for a course, with a maximum of three contact attempts. The line answered = new Random().ints(0, 2).findFirst().getAsInt(); generates a random number using the Random class. This number falls between 0 (inclusive) and 2 (exclusive), effectively simulating whether the candidate answered the call (1) or not (0). The process repeats until the candidate answers or the maximum attempts are reached.

Both While and DoWhile loops are essential for scenarios such as validating user input, batch data processing, or algorithms requiring iteration until a specific condition is met. Examples include the school scenario above or loops for validating user inputs.

We hope this article clarified the differences between While and DoWhile loops. How do you use these structures in your code? Share your experiences or questions in the comments! If you enjoyed this content, follow me for more articles in this series and other Java topics. See you next week—before the New Year—with more Java concepts!

Streamlining Restaurant Inventory Management: Challenges and Solutions

Ricardo Caselati — Tue, 24 Dec 2024 18:48:54 +0000

Since September, I have been fully committed to this project, and one of the main challenges I encountered was: “How can we manage inventory more efficiently?"

At first glance, this might seem straightforward. For example, if we’re talking about items like pens, it’s pretty simple: I have 10 pens, sell 2, and I’m left with 8. However, when it comes to running a restaurant, things get significantly more complex.

Consider beans, for example. When I purchase 5 kg of beans, I also incorporate ingredients such as water, onions, garlic, and oil during the preparation. Moreover, we must factor in the portions served on-site compared to those prepared for takeout.

To address these challenges, I developed a streamlined and functional workflow that starts with supplier registration.

Next comes the manufacturer registration process, allowing users to track which manufacturers offer the best quality or cost efficiency.

Following that is a critical feature of the application: purchase list creation. This step links market and manufacturer data to purchased products. For items without a specific manufacturer (like bulk potatoes, onions, etc.), the system is pre-configured with a "default manufacturer" labeled as "unknown/bulk." At this stage, we record details such as the purchase date, market, product, and manufacturer (when applicable).

I'm returning to the initial challenge: how do you track ingredient usage while preparing dishes? The solution was to introduce a feature for recipe registration, enabling the system to calculate the average yield for each recipe automatically.

When a recipe is created, it generates an item called a “Prepared Meal.” Based on configurations set in the "Settings" section, portion allocations are defined for each type of meal: dine-in or takeout. This way, one portion is deducted from the “Prepared Meals” inventory when a sale occurs.

There’s still plenty to refine, add, and improve, but this represents the progress so far.

I welcome suggestions and constructive feedback! Wishing you all a Merry Christmas and a prosperous New Year!

Exploring the for Loop in Java

Ricardo Caselati — Mon, 16 Dec 2024 18:10:45 +0000

The for loop is one of the most popular structures for creating repetitions in Java. Unlike while, which continues as long as a condition is true, the for loop is ideal when you know exactly how many times the loop will run. This predictability makes managing counters and other conditions much easier. Let’s explore some practical examples together!

Here’s a classic example: a simple counter that goes from 1 to 10, printing each number to the console.

for (int number = 1; number <= 10; number++) {
    System.out.println("Current number is: " + number);
}

In this case, the loop starts with the value 1, continues as long as the number is less than or equal to 10, and increments the value with each iteration. It’s a straightforward and efficient way to handle repetitions!

Beyond counters, the for loop is perfect for navigating arrays. Imagine you need to print the names of students in a class:

String[] students = { "Marc", "John", "Layla", "Peter" };
for (int i = 0; i < students.length; i++) {
    System.out.println("Student " + (i + 1) + ": " + students[i]);
}

Here, the loop goes through each element in the array using the index to access their values.

You can use the 'for-each' loop for an even more elegant and readable way to iterate through arrays. This is perfect when you want to access each element directly without worrying about indices.

String[] students = { "Marc", "John", "Layla", "Peter" };
for (String student : students) {
    System.out.println("Student: " + student);
}

In this case, the code automatically iterates through all array elements, assigning each to the student variable.

Fun fact: there are multiple ways to declare and initialize arrays in Java. Here are two common approaches:

Declaration with predefined values:

String[] names = { "Annie", "Buck", "Charlie" };

Declaration with a fixed size, adding values later:

int[] numbers = new int[5];
numbers[0] = 10;
numbers[1] = 20;

If you already know the values, use the first approach. If the data will be defined later, the second option is more flexible!

The for loop is a powerful ally in Java development. With it, you can create efficient loops and navigate arrays with ease. Practice using it in different scenarios and discover its potential!

Bonus Tip: Experiment with various conditions and observe how they affect the loop's behavior. Practice makes perfect in programming!

Exploring Conditional Structures in Java

Ricardo Caselati — Fri, 13 Dec 2024 17:21:50 +0000

Today, let’s dive into conditional structures in Java, like IF / ELSE. These are used to define different execution paths based on boolean conditions. To make it practical, we’ll explore an example of a system that evaluates a student’s final grade and determines whether they are APPROVED or FAILED. Oh, I’ll only show code snippets here without the complete class, so take this opportunity to practice creating classes (organized into packages) and main methods to run the examples. If you’re unsure, refer to previous lessons.

Example 1: Simple approval or failure

double finalGrade = 7.5;
String result = "UNDEFINED";

if (finalGrade >= 7) {
    result = "APPROVED";
} else {
    result = "FAILED";
}

In this example, the program checks if the grade is greater than or equal to 7.0. If true, it outputs "APPROVED"; otherwise, "FAILED."

Example 2: Adding an intermediate condition
What if we want to include a third scenario, like the possibility of an extra exam for students with grades between 6.0 and 6.9? We can use else if:

double finalGrade = 6.0;
String result = "UNDEFINED";

if (finalGrade >= 7) {
    result = "APPROVED";
} else if (finalGrade >= 6.0) {
    result = "EXTRA EXAM REQUIRED";
} else {
    result = "FAILED";
}

Here, the program identifies three scenarios: approved students, those who need to take an extra exam, and those who fail. This type of structure is beneficial for systems requiring decisions based on multiple conditions.

Conclusion
Practicing conditional structures is essential for anyone learning Java. They form the foundation of many logic-based solutions in everyday development. So, roll up your sleeves and explore various scenarios with if, else if, and else! Happy coding!

Understanding Strings and Arrays in Java

Ricardo Caselati — Wed, 11 Dec 2024 12:49:12 +0000

Strings in Java

In this guide, we’ll explore how to handle text in Java using the String class. Contrary to what one might assume, String is not a primitive data type but a specialized class designed to work with text, offering unique features for efficient text management.

The String class is part of the java.lang package and is in the JRE and JDK by default. A String object’s default value is null, consistent with the initialization behavior of all non-primitive types in Java.

Here’s a simple example:

public class StringObjects {
    public static void main(String[] args) {
        String text = "Learning Java!";
        String numbers = "12345";
        String character = "a";
    }
}

Key Notes:

Strings are initialized with double quotes ("), unlike the char type, which uses single quotes (').
Strings in Java are defined using the keyword String, which always starts with an uppercase "S."

To combine multiple strings, use the concatenation operator (+), as shown below:

public class StringObjects {
    public static void main(String[] args) {
        String text = "Learning Java!";
        String numbers = "12345";
        String character = "a";
        String finalText = text + " " + numbers + " " + character;

        System.out.println(finalText);
    }
}

To reassign a new value to a string, you can simply overwrite it:

public class StringObjects {
    public static void main(String[] args) {
        String text = "Learning Java!";
        text = "Now learning C#!";

        System.out.println(text);
    }
}

Arrays in Java

Arrays are data structures that store collections of elements, all of the same type. The size of an array must be defined at creation, and each element within the array is accessed via its index.

Here’s an example of an integer array:

public class Arrays {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        System.out.println(numbers[2]); // Outputs 30
    }
}

Key Notes:

Arrays in Java start at index 0 and end at length - 1.
If you try to access an index beyond the array’s bounds (e.g., numbers[5] in the example above), you’ll encounter an ArrayIndexOutOfBoundsException.

Multidimensional Arrays and More

Java also supports multidimensional arrays, often referred to as matrices. Here’s an example:

public class MultiDimensionalArrays {
    public static void main(String[] args) {
        int[][] matrix = new int[2][3];
        matrix[0][0] = 5;
        matrix[1][2] = 15;

        String[] words = {"Learning", "Java", "is", "fun!"};

        System.out.println(matrix[0][0]); // Outputs 5
        System.out.println(matrix[1][2]); // Outputs 15
        System.out.println(words[0] + " " + words[1]); // Outputs "Learning Java"
    }
}

Exploring Non-Primitive Types in Java: A Dive into Object-Oriented Programming

Ricardo Caselati — Tue, 10 Dec 2024 15:12:28 +0000

If you've ever dived into Java, you’re probably familiar with primitive types—they're like the simple building blocks of the language: straightforward, efficient, and perfect for storing basic values like numbers and true/false statements. But what if you're looking to create something a bit more intricate, like a banking system or a fun game? That’s where non-primitive types come into play, bringing a wonderful extra layer of complexity and creativity to your projects!

What Are Non-Primitive Types?

Non-primitive types, also known as reference types, are used to create objects, arrays, or even custom classes. Unlike primitive types, they are not limited to storing data—they can encapsulate methods and properties, allowing for more dynamic and realistic programming.

For example, consider a BankAccount class. It might include attributes like balance and methods for depositing money or converting currencies. To use this class, you instantiate it with the new keyword, creating an object ready for use in your program.

Here’s an example:

public class Bank {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
    }
}

In this case, the BankAccount object is initialized with a balance of $1000, and $500 is added using the class's deposit method.

The Role of Constructors

Constructors are special methods in Java designed to initialize objects. They prepare an instance of a class for use, and they can even accept parameters to customize how objects are initialized:

public class BankAccount {
    double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
}

By using a constructor, you ensure that every object is properly set up right from the start.

Why Use Non-Primitive Types?

Non-primitive types open the door to powerful programming possibilities, including:

Organizing and structuring data efficiently;
Representing complex, real-world concepts;
Reusing code and enhancing the scalability of your applications.

By understanding and utilizing non-primitive types, you’ll be ready to harness the full potential of Object-Oriented Programming and build solutions that are both elegant and functional.

So, why wait? The Java ecosystem is brimming with opportunities to bring your ideas to life!

Types: char and boolean

Ricardo Caselati — Mon, 09 Dec 2024 12:31:53 +0000

After learning about the double and float types, it’s time to dive into two other essential primitive types in Java: char and boolean. Ready to explore?

The `char` Type

The char type is ideal for representing a single Unicode character. This means you can store any character—letters, numbers, or symbols—using it. There are two ways to assign a value to a char variable:

Using single quotes, like 'A', 'Ω', or 'B'.
Using a numeric value, corresponding to the character in the Unicode table. For example, the code below stores the letter "A" using its Unicode value:

char letterA = 65;

Want to see char in action? Check out this example:

public class PrimitiveTypes {
    public static void main(String[] args) {
        char letterA = 'a';
        char capitalA = 'A';
        System.out.println(letterA); // a
        System.out.println(capitalA); // A
    }
}

The `boolean` Type

The boolean type is one of the simplest—and most useful! It represents only two possible values:

true
false

This variable type is essential for making decisions and controlling the program's flow, especially with conditionals like if and while. In Java, unlike some other languages where 0 and 1 are used to represent false and true, we explicitly use true and false.

An interesting detail is that boolean variables often have names that resemble questions. Internationally, they typically start with "is," while in some contexts, prefixes like "eh" might be used. Examples:

public class PrimitiveTypes {
    public static void main(String[] args) {
        boolean isJavaFun = true; // Examples: isRunning, isActive
        boolean isAdult = false; // Examples: isTrue, isReady
    }
}

Now that you know how these types work, you can use them to make your code more intuitive and functional!

Understanding float and double in Java

Ricardo Caselati — Sat, 07 Dec 2024 13:29:19 +0000

When diving deeper into Java’s data types, it's essential to understand float and double. These are floating-point data types used for real numbers, allowing for precision in handling both tiny and massive values.

float: Compact and efficient, perfect for lightweight tasks. It requires adding an f at the end of the number to explicitly mark it as a float.
double: As the name suggests, it has double the precision of float, making it ideal for complex calculations and scenarios where precision matters.

Key Points:

Java interprets a number like 1.5 as double by default. To use a float, append an f (e.g., 1.5f).
float stores fewer decimal places than double, which is better for high-precision needs.

Example with float:

public class FloatExample {
    public static void main(String[] args) {
        float numA = -101.23f;
        float numB = 2.356f;
        System.out.println(numA + numB); // Output: -98.874
    }
}

Example with double:

public class DoubleExample {
    public static void main(String[] args) {
        double valueOne = 0.5; // Implicitly a double
        double valueTwo = 0.5d; // Explicitly a double
        double valueThree = 0.123456789; // High precision
        System.out.println(valueOne);    // Output: 0.5
        System.out.println(valueTwo);    // Output: 0.5
        System.out.println(valueThree);  // Output: 0.123456789
    }
}

Why Choose One Over the Other?

Choose float when memory is limited and calculations are less precise.
Choose double for scientific calculations or applications needing high precision.

New Features in React 19: Transforming the Development Experience

Ricardo Caselati — Fri, 06 Dec 2024 16:14:16 +0000

Learn more on the official site

React 19 arrives with a series of innovations that make development faster and smarter. Among the key changes are Actions, which automate common tasks such as managing pending states, optimistic updates, and error handling in forms. Additionally, the introduction of new hooks and APIs, such as useActionState, useOptimistic, and the groundbreaking use, provides greater control and simplification in application development.

Actions: Simplifying Data Mutation

Before React 19, handling pending states and errors required manual implementations. Now, with Actions, this process has been simplified. Asynchronous functions can automatically manage states, whether during form submissions or optimistic updates. The new useActionState hook encapsulates errors, pending states, and actions into a single function. Additionally, native support for the <form> element makes form submission and automatic reset easier.

Optimistic Updates with `useOptimistic`

To make interfaces more responsive, the useOptimistic hook allows provisional results to be shown while asynchronous requests are pending. This enhances the user experience by displaying immediate changes and automatically reverting them in case of failure.

`use`: Unprecedented Flexibility

The new use API introduces an innovative approach to consume promises and contexts directly in the render. Unlike traditional hooks, use can be called conditionally, making it a powerful tool for handling dynamic resources and data.

React Server Components and Server Actions

React Server Components allow components to be processed on the server before sending them to the client, optimizing performance and resource usage. Complementing this, Server Actions enable client-side components to trigger asynchronous functions on the server, fostering smoother integration between the front-end and back-end.

Static APIs for Site Generation

New APIs, such as prerender and prerenderToNodeStream, increase efficiency in generating static HTML by waiting for data to be fully loaded before rendering.

These changes solidify React 19 as one of the most powerful frameworks for web development, balancing simplicity with robustness.

Other New Features in React 19:

Ref as a Prop: You can now pass a ref as a property directly to functional components, simplifying the code and eliminating the need for forwardRef. An automatic migration tool will be available to assist with this change.
Improvements in Hydration Errors: React has enhanced hydration error detection, offering detailed messages and clear diffs between the content rendered on the server and the client, making it easier to diagnose incompatibilities.
**<Context>** as a Provider: You can now use <Context> directly as a provider, simplifying the use of contexts without the need for <Context.Provider>. A migration tool will also be available.
Cleanup Functions for Refs: Ref callbacks can now return a cleanup function, allowing you to manage references when the component is unmounted.
Initial Value in useDeferredValue: The useDeferredValue hook now supports an initial value, useful for scenarios like search, improving the experience during initial renders and updates.
Native Support for Document Metadata: React now allows metadata tags like <title>, <meta>, and <link> to be managed directly within components, simplifying the management of these tags in the document’s <head>.
Styles and Stylesheets: React has introduced integrated control for stylesheets, allowing precise management of loading order and precedence, ensuring stylesheets are loaded before dependent content.
Support for Asynchronous Scripts: Asynchronous scripts can now be rendered directly within components. React handles deduplication and loading, even across multiple script renders.
Resource Preloading APIs: New APIs such as prefetchDNS, preconnect, preload, and preinit optimize the initial loading and updates on the client, improving user experience.
Compatibility with Third-Party Scripts and Extensions: React now ignores unexpected tags inserted into the <head> or <body> by scripts and extensions, preventing hydration errors.
Improved Error Reporting: Errors captured by error boundaries are now reported only once, with detailed information about their origin, eliminating log duplication.

Variables and Data Types in Java

Ricardo Caselati — Thu, 05 Dec 2024 17:10:37 +0000

In Java, a strongly-typed and statically-typed language, the data we use in code has well-defined types. This means you must declare the data type when creating a variable.
For example:

int answerToEverything = 42;
System.out.println(answerToEverything);

Here, the variable answerToEverything is of type int, meaning it can only store integer values.

Primitive and Non-Primitive Types

Java data types are categorized into primitive and non-primitive types. Primitive types include int, byte, and boolean, while non-primitive types are used to represent objects and more complex structures, such as classes and arrays.
An important distinction is that primitive types store values directly, while non-primitive types store references to the data.

Details of Primitive Types

Primitive types are essential for storing simple data and performing fast operations. Each has a specific size and range:

They are ideal for numerical calculations and manipulations. A practical example of using byte is:

byte age = 25;
System.out.println(age);

Usage Tips

Use consistent types in operations (e.g., avoid mixing int with short).
For numbers larger than int, use long with the suffix L at the end:

long population = 7_900_000_000L;
System.out.println(population);

Java allows underscores (_) to improve the readability of large numbers, as shown above. This feature was introduced in Java 7 and does not affect the actual value of the number.

Pro Tip

Always prefer an uppercase L for long suffixes to avoid confusion with the number 1, especially in fonts where the two characters look similar.

This practical and structured approach to data types helps create more efficient and readable programs!

Exploring Class Organization with Packages in Java

Ricardo Caselati — Tue, 03 Dec 2024 16:05:42 +0000

In the Java world, organization is key, and packages play a vital role in achieving it. Packages act as virtual directories that group classes, making your projects more structured and scalable.

When you create a class without specifying a package, it resides in the default package. However, by using named packages like com.example.project, you not only improve your code organization but also adhere to Java’s common best practices. The package name reflects the directory structure—for instance, com.example.project indicates that the class is located in src/com/example/project/.

How to Access Classes from Other Packages?

This is where the import statement comes in. It allows you to use external classes in your code, either broadly (import package.*) or specifically (import package.Class).

Here’s an example:

package com.myProject.helloworld;  
import java.lang.*;  
import java.lang.Math;  

public class SquareRootOfTwentyFive {  
    public static void main(String[] args) {  
        System.out.println("The square root of twenty-five is:");  
        System.out.println(Math.sqrt(25));  
    }  
}

In this example, to use mathematical methods like Math.sqrt(25), you simply need to import the java.lang.Math class, one of Java's many utility classes. This functionality enhances modularity and reusability, which are crucial for building robust and collaborative projects.

Let Java's package system guide your project structure toward clean, scalable, and professional code.

Exploring Classes and the Main Method in Java

Ricardo Caselati — Mon, 02 Dec 2024 13:55:24 +0000

If you're new to Java, it's important to know that classes and the special method public static void main are key to creating any program. Let’s dive into how they work in a practical and straightforward way!

What Are Classes in Java?

Classes are the building blocks of Java programs. They act as blueprints containing methods (or functions) that perform specific tasks. Imagine you're building a house: the blueprint represents the class, and the functional rooms are the methods that bring the house to life.

For example, a library system class might include methods for borrowing and returning books. However, to use these methods, you first need to create an object based on the class—just like you need to build the house before living in it.

Creating a class is simple. Use the class keyword, like this:

public class HelloWorld {

}

Keep in mind that in most cases, the class name should match the filename, as shown in the example above.

The Starting Point: `public static void main`

Every Java program begins with the main method, which acts as the program’s entry point. This special method is required (except in libraries) and must be included within a class. Here's how it looks in the HelloWorld class:

public class HelloWorld {

  public static void main(String[] args) {
    // The program starts executing here
  }

}

You can have multiple classes, each with its own main method. This allows the program to start from different points, depending on your IDE settings.

Displaying Messages in the Console

To output messages in the console, you can use the System.out.println() or System.out.print() commands. What’s the difference? println adds a new line after the message, while print keeps the cursor on the same line.

Here’s an example using println:

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("First Line");
    System.out.println("Second Line");
  }
}

And an example using print:

public class HelloWorld {

  public static void main(String[] args) {
    System.out.print("First Line");
    System.out.print("This will also appear on the first line");
  }
}

These tools are essential for beginners, helping you test and understand how your code behaves. So, roll up your sleeves, create a project in IntelliJ, try these examples, and watch the magic happen! 🚀

DEV Community: Ricardo Caselati

Exploring While and DoWhile in Java: Master Loop Structures with Practical Examples

While Loop

DoWhile Loop

Streamlining Restaurant Inventory Management: Challenges and Solutions

Exploring the for Loop in Java

Exploring Conditional Structures in Java

Understanding Strings and Arrays in Java

Strings in Java

Key Notes:

Arrays in Java

Key Notes:

Multidimensional Arrays and More

Exploring Non-Primitive Types in Java: A Dive into Object-Oriented Programming

What Are Non-Primitive Types?

The Role of Constructors

Why Use Non-Primitive Types?

Types: char and boolean

The char Type

The boolean Type

Understanding float and double in Java

Key Points:

Example with float:

Example with double:

Why Choose One Over the Other?

New Features in React 19: Transforming the Development Experience

Actions: Simplifying Data Mutation

Optimistic Updates with useOptimistic

use: Unprecedented Flexibility

React Server Components and Server Actions

Static APIs for Site Generation

Other New Features in React 19:

Variables and Data Types in Java

Primitive and Non-Primitive Types

Details of Primitive Types

Usage Tips

Pro Tip

Exploring Class Organization with Packages in Java

How to Access Classes from Other Packages?

Exploring Classes and the Main Method in Java

What Are Classes in Java?

The Starting Point: public static void main

Displaying Messages in the Console

The `char` Type

The `boolean` Type

Optimistic Updates with `useOptimistic`

`use`: Unprecedented Flexibility

The Starting Point: `public static void main`