API stands for Application Programming Interface, a standardized mechanism for enabling interaction between software components. For instance, the weather data displayed on your mobile device is typically sourced through an API. Services such as Weatherstack provide real-time meteorological data accessible via API requests. An API specifies the methods and data types for facilitating communication between software systems. In the technical world, there are many kinds of API.

Here’s a detailed technical overview of how weather data is retrieved and displayed on a mobile device through an API call:

1. Application Initialization: The user launches the weather application or utilizes an integrated weather service on the mobile device.
2. API Request: The application constructs and sends an API request to the weather service, querying for the current weather conditions at the user’s location.
3. API Response: The weather service processes the request and returns a response containing the weather data for the specified location.
4. Data Presentation: The application processes the API response and renders the weather information in a user-friendly format on the device’s interface.

What is the Web API?

Again, it’s same as I explained API. Here I will go through another example.

In simple terms, Web API is like a bridge that allows to communicate with different software components with each other over the internet. Just imagine below real-world example.

Imagine you want to order a pizza using a food delivery app on your phone. Here is how a web API helps make that happen:

1. Placing an Order: You open the food delivery app and choose your pizza.
2. Sending a Request: When you press the “Order” button, the app sends a request to the pizza restaurant’s online system. This request is like a message saying, “Please prepare a pizza with these specifications for this delivery address.”
3. Restaurant’s Response: The pizza restaurant’s system receives the request, prepares the pizza, and sends back a response to the app. This response might include details like the order confirmation, estimated delivery time, and tracking information.
4. Showing the Details: The app then displays this information to you, letting you know that your pizza is being made and giving you updates about the delivery.

In above example, your mobile app and restaurant system are the two different software components. So, the bridge will be the API call that carries your order details to the restaurant.

There are many kinds of bridges (APIs). Below are the main APIs that are using in the worldwide application.

- REST APIs — This API stands for HTTP methods like put, post get and delete etc. these methods are stateless which means API will return all the required information needed to fulfill request.

- SOAP APIs — Simple Object Access Protocol APIs uses XML based message protocol. This is mainly using in ERP level bank applications.

- Private APIs — The APIs use only within an organization like HR system connect to payroll system.

- Open APIs — These are available for any developer to use like Google map API, Twitter API etc.

- Streaming APIs — continues flow of real time data. Twitter, Facebook streaming APIs are the example for this.

- GraphQL APIs — one of best alternative for REST APIs. It provides exactly what client expect from the server.

What is the REST API?

REST stands for representational state transfer. In technical world, this type of APIs introduces as RESTful API, RESTful web API. It is a type of Web API.

There are different methods, functions that client can access server data using http protocol. Put, get, delete post are the main functions that are using in rest APIs. This provides a flexible and lightweight way to integrate between client and server applications.

Specially, response for the REST APIs calls is plain text. No graphical rendering to the client side. This is calling statelessness which is main feature of REST API.

There are six main principles in REST API as below.

Client server decoupling

Server and client applications must be independent. Client application is directly representing the presentation layer and UI while sever or backend application representing the business logic and process the requests from the client.

Statelessness

Statelessness means each API requests should contain all the data for processing the requests like API token, headers etc. REST APIs do not require to store any server-side sessions. The REST API ensures that each request is self-sufficient and not dependent on server-side session management.

Catchability

This principle is mainly used where the same response should be expected from the client. There are some certain scenarios where we can use catchability.

o Cacheable response.

o HTTP caching headers

o Caching request and sub requests.

The main goal is doing the caching is to improve the performance, reduce the load and improve the efficient of data retrieval.

Layered system architecture

This is a system design architect where we can implement with the RESTful APIs. There are few main layers as below.

• Presentation layer: this is the client-side application where the client or user interact with UI.
• API layer: handle the API request and response.
• Service layer (business logic): handle the business logics, authentication and data validation etc.
• Data access layer: manage the data revival and storage including perform CRUD operations.
• Database layer: The actual database or data store where the persistent data resides.

This is one of most important principle in REST APIs and it has many benefits like modularity, reusability, scalability, flexibility, code readability, testability etc.

Code on demand

This is an optional principle in REST API. Servers can extend the client’s functionality by transferring executable code (e.g., JavaScript).

Uniform interface –

Below points are the main breakdown of uniform interface.

1. Identify the resource

• You must use unique URI (uniform resource identifier) to identify the exact resource (user/423). This means that the structure of URIs is consistent across the API, making it predictable and easier to use.

2. Manipulation of resources through representations.

• Use the http standards communication methods like put, post with the help of unique URI.

3. Self-descriptive messages

• Each message (request or response) includes enough information for the client or server to understand how to process it. For example, HTTP headers provide metadata about the request or response, like content type or caching directives.

4. Hypermedia as the engine of the application (HATEOAS)

• HATEOAS is a constraint where the API provides hypermedia links within responses. These links guide clients on how to interact with the API further, allowing clients to navigate the API dynamically based on the responses they receive.

Key Differences Of WEB & REST API

• Scope: “Web API” is a broad term encompassing any API accessed via the web. “REST API” refers specifically to APIs that follow REST architectural principles.
• Design Constraints: REST APIs adhere to specific constraints and principles (e.g., statelessness, uniform interface), while web APIs may not follow these constraints and can vary widely in design and implementation.
• Use Cases: REST APIs are commonly used for web and mobile applications due to their simplicity and ease of integration. Web APIs can be used for various purposes and may not always follow REST principles.

In summary, while all REST APIs are web APIs, not all web APIs are RESTful (like SOAP request). REST is a subset of web APIs that follows a specific set of guidelines and principles designed to standardize and simplify web interactions.

Jump search is an algorithm used for searching in a sorted array. It is faster than linear search but simpler than the binary search. It is designed to jump a fix number of steps and perform a linear search withing a small array segment. This can be used where you want to apply simplicity of linear search and efficiency of binary search.

Here are the main steps that we can see in the jump search.

1. Get the array length and calculate the fixed step.

2. Start at the beginning and jump ahead then check if the value we are looking for is inside the array.

3. One we found the array segment (less than or equal to target element) perform linear search within specific array segment.

4. Once we found the target element return it or if the element does not exist return minus value.

Let’s checkout simple code block in java. Below is the complete code that we are going to go through. Do not worry, I will explain each line of code later this blog. Just check the below code and scroll down.

public class JumpSearch {

    public static int jumpSearch(int[] arr, int x) {
        int n = arr.length;

        // Set block size to be jumped
        int step = (int) Math.floor(Math.sqrt(n)); // step will be 3

        /*
         * Math.floor - will round number to the nearest integer
         * Math.sqrt - will return square root of a value
         * Math.min - will return minimum value
         */

        // Set the block where element is present (if it is present)
        int previouseValue = 0;
        for (int minStep = Math.min(step, n) - 1; arr[minStep] < x; minStep = Math.min(step, n) - 1) {
            
            previouseValue = step;
            step += (int) Math.floor(Math.sqrt(n));

            if (previouseValue >= n)
                return -1;
        }

        // Doing a linear search for x in block
        // beginning with previouseValue.
        while (arr[previouseValue] < x) {
            previouseValue++;

            // If we reached next block or end of array, element is not present.
            if (previouseValue == Math.min(step, n))
                return -1;
        }

        // If element is found in the array
        if (arr[previouseValue] == x)
            return previouseValue;

        return -1;
    }

    // Driver program to test function
    public static void main(String[] args) {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int x = 6;

        // Find the index of 'x' using Jump Search
        int index = jumpSearch(arr, x);

        // Print the index where 'x' is located
        System.out.println("Number " + x + " is at index " + index);
    }
}

Let’s examine the main method in detail.

We have an array called ‘arr’ that keeps sorted list of numbers. X is the target value that we are going the find the index. Once we called the jumpSearch method, it will return the index where the target value is in. If not, it will return -1. Finally, output will be printed on the console.

Let’s move to the jumpSearch method. In there we are accepting array and target value as parameter.

public static int jumpSearch(int[] arr, int x) {
        int n = arr.length; // get the array lenght

        // Set block size to be jumped
        int step = (int) Math.floor(Math.sqrt(n)); // step will be 3

        /*
         * Math.floor - will round number to the nearest integer
         * Math.sqrt - will return square root of a value
         * Math.min - will return minimum value
         */

int n: store the array length. In our case, length is 10.

int step: store the block size to be jumped through the array.

Hope you are aware about the Math functions. If not, please check the comment in above code segment.

Let’s get a clear idea about the for loop,

// Set the block where element is present (if it is present)
        int previouseValue = 0;
        for (int minStep = Math.min(step, n) - 1; arr[minStep] < x; minStep = Math.min(step, n) - 1) {
            
            previouseValue = step;
            step += (int) Math.floor(Math.sqrt(n));

            if (previouseValue >= n)
                return -1;
        }

minStep: will be 2. (step =3 and n = 10, therefore Math.min will return 3. so, after -1 it will be 2)

previouseValue: will be 3

step: will be 6 (this is because addition assignment operator).

Finally, there is a condition that checks previouseValue is greater than or equal to n. Surely, this is false because n is 10 and previouseValue is 3. So, as you know, for loop keep recurring until its condition gets false. Check the below figure which helps you to get an idea.

Loop will be executing for the second time and the loop condition will be false.

The second execution in the loop, condition will be false as it checks minStep value in the array is less than out target value (x). So, condition will be false as in the above image.

It is clear now value of both arr[minStep] and X is 6. Therefore, condition will be false as it checks arr[minStep] less than X. So program will exit from the for loop and will start the while loop.

   // Doing a linear search for x in block
        // beginning with previouseValue.
        while (arr[previouseValue] < x) {
            previouseValue++;

            // If we reached next block or end of array, element is not present.
            if (previouseValue == Math.min(step, n))
                return -1;
        }

While loop will be performed below steps.

Step 01: first execution of while loop

The value of previouseValue is 3.

arr[previouseValue] = 4

X = 6

arr[previouseValue] < X is true. Therefore, 1 will be added to previouseValue. Then value of previouseValue is 4.

Next, if condition will be false as min function returns 6 and previouseValue is 4.

Step 02: second execution of while loop

The value of previouseValue is 4.

arr[previouseValue] = 5

X = 6

arr[previouseValue] < X is true. Therefore, 1 will be added to previouseValue. Hence value of previouseValue is 5.

Next, if condition will be false as min function returns 6 and previouseValue is 5.

Step 03: third execution of while loop

The value of previouseValue is 5.

arr[previouseValue] = 6

X = 6

arr[previouseValue] < X is false now as both values are equal. Therefore, program will exit from the while loop and move into next code lines where we get if condition as below.

// If element is found in the array
        if (arr[previouseValue] == x)
            return previouseValue;

Look at the above if condition carefully, we already know that X is our target and 6 is the value of X.

Check the few lines above, you will find the value of arr[previouseValue]. It is 6. So finally, our target value exists at index 5.

So, final output will be ‘Number 6 is at index 5’.

Jump search is most effective when dealing with large, sorted arrays where binary search might be too complex to implement or when you want a balance between simple linear search and more complex algorithms like binary search.

In summary, jump search is a practical algorithm that can offer a good balance between the simplicity of linear search and the efficiency of binary search, especially when working with sorted data.

In this article, we will delve into several core concepts of Node.js, including:

• Asynchronous Programming
• Synchronous Programming
• Call Stack
• Callback Queue
• Event Loop

Whether you are a developer or an IT student, you are likely familiar with terms such as “stack,” “queue,” and “loop” from the context of data structures and algorithms. These concepts are not only fundamental to computer science but also play a crucial role in application development. Let’s explore these concepts in the context of NodeJS.

Why is This Important?

When developing web applications, it is essential to understand various components, such as functions, APIs, and architectural layers. Equally important is a deep understanding of application performance and event behavior. A solid grasp of the “call stack” is vital for optimizing application performance.

The call stack is a powerful tool for managing function calls and improving application efficiency. Each call stack can operate independently, handling simultaneous function calls until the program terminates. Understanding how the call stack functions allow developers to write more efficient and responsive code.

Before diving into the call stack, will have a quick overview about async and sync programming.

Synchronous Programming

Synchronous programming means that tasks are executed one after another. Each task must complete before the next one starts. This model is straightforward but can lead to blocking behavior, where the program must wait for each operation to finish before continuing.

• Will be blocked the code.
• Sequential execution

Good For:

Tasks where each operation must complete before the next begins, and blocking behavior is acceptable or desired.

Asynchronous Programming

Asynchronous programming allows tasks to be executed independently of the main program flow. This means that tasks can start and finish at different times without blocking the execution of other tasks. Asynchronous operations are often handled through callbacks, promises, or async/await syntax.

• Non-blocking.
• Concurrent execution

Good For:

Tasks like I/O operations, network requests, or any situation where you want to avoid blocking the main thread and improve performance and responsiveness.

Hey, Stay focused, we are diving into deeper.. 💡

What is Call Stack?

In simple terms, the call stack is a mechanism used by interpreters, such as JavaScript or Python, to manage script execution and keep track of the currently running functions.

To dive a bit deeper, the call stack operates on the Last In, First Out (LIFO) principle, similar to the stack structure used in data structures and algorithms (DSA). When a program begins execution, the script may call functions. Each function call is pushed onto the top of the call stack, where it is executed. Once the function completes its execution, it is removed, or “popped,” from the stack by the interpreter.

The mechanism becomes more complex when considering Web API level executions. In such cases, understanding the “callback queue” and “event loop” is crucial for grasping how asynchronous (non-blocking) execution works.

To fully understand these concepts, it will be helpful to explore some simple examples. Before diving into those, it’s important to grasp a few foundational concepts.

Let’s take below code lines.

console.log('START');
setTimeout(()=>{
console.log('1 second timer');
},1000);
console.log('END');

Output:
START
END
1 second timer

How this is possible? It is a simple answer that setTimeout function has one second delay therefore, program will take 1 second to print the ‘1 second timer’ text. Specially, java script interpreter is keep running the code and print last log line while waiting for the 1 second. This is called NON-BLOCKING in NodeJS.

Line 01 print ‘START’ as it is a synchronous code.

Line 02 will start setTimeout function and wait for one second meanwhile program will be moving on for the next lines of code as this is an asynchronous function.

Line 05 prints ‘END’ as it is a synchronous code.

After once second, program will print as ‘1 second timer’.

As I explained above, this is one of simplest examples that we can give for non-blocking program. Now, let’s move deeper and see how this is going to handle by the java script interpreter. You will get idea for call stack, node API, callback queue, event loop etc. I will use below simple program from here onwards.

Look at below code lines, how simple that is.

console.log('program started');

setTimeout(()=>{
console.log('1 second passed');
},1000);

console.log('Hi UDARA');

setTimeout(()=>{
console.log('2 seconds passed');
},2000);

console.log('program ended');

Step 01:

Now let’s see what happens behind the above code. Firstly, the main function will be added to the call stack and then the “program started” string will be printed on the console and the function will be removed from the stack.

Have a look on below image. Do not forget, all the methods are in the program will be loaded into call stack.

console.log('program started');

As you can see, first log() function is in the call stack and it is done the duty as ‘program started’ is already printed in the output. Hence, log() function will be popped off from the call stack and next function will be loaded.

Step 02:

Next, the first setTimeout function will be called which must wait for one second to be executed. therefore, it will be moved into node API and next function will be loaded into the call stack.

console.log('1 second passed');
},1000);

Step 03

First setTimeout function will wait for one second and program will be executing. As a result, “Hi UDARA” text will be printed which is next log function’s task.

console.log('Hi UDARA');

Step 04

As next step, second setTimeout function will be loaded into call stack and move to Node API as it is having 2 seconds waiting time.

setTimeout(()=>{
console.log('2 seconds passed');
},2000);

Now you can guess the next step. It will be last log function. You will see ‘program ended’ text in the console. Log and main functions will be popped off from the call stack.

Step 05

All the log functions has been finished except setTimeout functions.Hence, Call back queue and event loop are going to start their task resulting first time out function is moved into call back queue which was waiting for one second to be executed.

Step 06

Event loop is always looking into call stack and if the call stack is empty, setTimeout function will be loaded into the call stack as below.

Once first setTimeout function moved to call stack, second function will move into call back queue, and it will be picked by the event loop then move into the call stack.

Let’s have an overview

1. Call Stack: The call stack is a data structure that keeps track of function calls in a JavaScript application. When a function is called, it gets pushed onto the stack, and when the function returns, it is popped off. In Node.js, the call stack helps manage the execution of synchronous code.
2. Node API: The Node API (or Node.js API) refers to the set of built-in libraries and modules provided by Node.js for performing various tasks such as file operations, networking, and more. These APIs are designed to handle asynchronous operations and interact with the underlying system.
3. Event Loop: The event loop is a fundamental part of Node.js’s architecture. It continuously checks the call stack and the callback queue to determine if there are any functions ready to be executed. The event loop allows Node.js to perform non-blocking I/O operations by processing events and callbacks asynchronously.
4. Callback Queue: The callback queue (or task queue) is where functions that are ready to be executed asynchronously are placed. When the call stack is empty, the event loop takes functions from the callback queue and pushes them onto the call stack to be executed.

In summary, the call stack manages synchronous execution, while the event loop and callback queue handle asynchronous operations in Node.js.

Thank you.

The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). This works by repeatedly dividing the search interval in half until the target value is found or the interval is empty. The main task is finding a target value in a sorted array.

Without further delay, we will jump into a code example with clear explanations

I will explain the algorithm using example in Java. Before moving to the complete code, we will look into the main method.

 public static void main(String[] args) {
        // create sorted array
        int arr[] = { 2, 4, 6, 8, 10, 12, 14 };
        // get the array lenght
        int lenght = arr.length;
        // set the target value for search
        int target = 12;
        // call searchIndex method and assign the return result
        int result = searchIndex(arr, 0, lenght - 1, target);
        // show the result based on the return result
        if (result == -1) {
            System.out.println("Unable to fine the given element");
        } else {
            System.out.println("Given element is present at index " + result);
        }
    }

Here we have an array named in arr which is having seven numbers. Hence, length will be 7.

Number 12 is the one which we are going to find out from the array. So, our target value will be 12.

In the code, we are passing array, low value, high value and target value into searchIndex method then method will return the index where our target value is located else it will return the -1 if the target value is not found.

int result = searchIndex(arr, 0, lenght - 1, target);

Before moving into the searchIndex method, we should have clear idea on above code line. Here, we are passing 4 parameters into searchIndex method.

parameters of searchIndex Method

arr: array name (need to perform the search).

0 : lowest index of the array (first index is always 0 in array).

length -1: this is to set the highest index. (Array length is 7. In our case, largest index is 6 since counting from 0).

target: pass the value to find out the index which we are looking for.

Let’s move to the searchIndex method. As per the below method, we are accepting the four parameters. Hope there is no doubt about it.

public static int searchIndex(int arr[], int low, int high, int target) {
        while (high >= low) {
            // setup the mid value
            int mid = low + (high - low) / 2;
            // if the mid is equal to target value, then return particular index
            if (arr[mid] == target) {
                return mid;
            }
            // If x greater, ignore left half
            if (arr[mid] < target) {
                low = mid + 1;
            } else {
                // If x is smaller, ignore right half
                high = mid - 1;
            }
        }
        // If the programme reach here, it means element is not exist
        return -1;
    }

At first, we are setting up the mid index.

int mid = low + (high - low) / 2;

mid = 0 + (6–0) / 2

mid = 3

As explained earlier this algorithm repeatedly dividing the search interval in half, therefore we are using while loop.

// if the mid is equal to target value, then return particular index
            if (arr[mid] == target) {
                return mid;
            }

Here is one of my favorite parts in the binary search. As soon as set the mid index, it is checking the array mid index whether is it equal to our target value or not. If it is match, then will simply return the mid index which is holding our target value. This will reduce searching time significantly and making easier to reach out the target value.

In our case, arr[mid] = 8 do not forget that mid is equal to 3.

Let’s move to the next part

 // If target greater, set new low value
            if (arr[mid] < target) {
                low = mid + 1;
            }

Now you can understand what we are doing in above code bloc. It is a simple process. if the middle value of array is less than our target value (12) then will set the low value as mid + 1.

It means, algorithm will ignore the left part of the array since those values are less than our target value (12). (note: we cannot do this in unsorted array).

low = mid + 1 (0 = 3 + 1)

Now low value is 4.

In our case, below part will not be executed because our target value (12) is greater than array middle value.

        else {
                // If target is smaller, set new high value
                high = mid - 1;
             }

Therefore, program will repeat the same process again until our target value is found. Loop condition still true. So, it will calculate the middle value again.

while (high >= low) {
            // setup the mid value
            int mid = low + (high - low) / 2;

mid = low + (high — low) / 2

mid = 4 + (6–4) / 2

mid = 5

Now, mid value is 5.

So look at the below code part which is going to execute in next millisecond.

// if the mid is equal to target value, then return particular index
            if (arr[mid] == target) {
                return mid;
            }

As per the above figure, our target value (12) is located at our mid index. Therefore, mid will be returned by the program.

At last, result variable value will be 5 and output will be “Given element is present at index 5”

int result = searchIndex(arr, 0, lenght - 1, target);
        // show the result based on the return result
        if (result == -1) {
            System.out.println("Unable to fine the given element");
        } else {
            System.out.println("Given element is present at index " + result);
        }

Have a rest and check below key points

Below are the key points of the Binary Search

1. Initialization: Start with two pointers, one at the beginning (low) and one at the end (high) of the array.

2. Calculate Middle: Compute the middle index mid of the current range:
mid=low + (high-low) / 2

3. Comparison: Compare the target value with the middle element of the array:

• If the target value equals the middle element, the search is successful, and the index of the middle element is returned.
• If the target value is less than the middle element, adjust the high pointer to mid - 1 to search in the left half.
• If the target value is greater than the middle element, adjust the low pointer to mid + 1 to search in the right half.

4. Repeat: Continue the process of recalculating the middle and adjusting the pointers until the low pointer exceeds the high pointer or the target value is found.

5. Termination: If the target value is not found by the time low exceeds high, the target is not present in the array.

We can introduce Linear search algorithm as one of the most elementary searching techniques. Operating in a sequential manner, it systematically traverses through each element of a given list when tasked with finding a specified value. Beginning from the first element and progressing linearly to the end, it diligently inspects each element until the desired value is found.

Now, let’s delineate the step-by-step procedure of linear search utilizing the following array.

Consider value of N is 3. As per the below array, our matching condition will be array[2]=3

We are going to search 3. Based on the above given array, it’s located in index 2. Below are the steps how linear search is looking for 3.

Step 01

In the first case, algorithm is looking for the index 0 where the value is 8. So that will not make our condition true.

Step 02

Therefore, Algorithm will be switched to the first index where the value is 15. Step two is also not match with our condition. Do not forget that we are looking for the number 3.

Step 03

Algorithm will continue the search in second index where the condition is matched. Please check the below steps so that you can have a clear picture of all the steps.

Java Code

below code will be doing

• Pass the array and target value into linearSearch method.
• Get the array length.
• Traverse the array element using a for loop until find the target value.
• Return the index if found.
• Return minus one if there is no target value.

Code should be written within the LinearSearch class

public static void main(String[] args) {
        int array[] = { 8, 15, 3, 20, 7, 2 }; // array
        int n = 3; // target value

        int result = linearSearch(array, n); // stores the result
        System.out.println("Value found in index: " + result); // prints the result
    }

 public static int linearSearch(int array[], int target) {
        int len = array.length; // stores the length of the array
        // check if the traget value is matching with the array values
        for (int i = 0; i < len; i++) {
            if (array[i] == target) {
                return i; // returns the index
            }
        }
        return -1; // if value not found
    }

Let’s have a look into another example

Based on the above array

Number of index = 5 (counting from zero).

Array length = 6 (total number of element in the array).

Remember our target value is 12 which is at index two. That means, simply we are going to find out whether number twelve is exist or not in the above array. If exist, return the index of target value.

45 is the zeroth index value and it does not match with our target value which is twelve. As the next step looping to next iterator. As I mentioned earlier, it traverses indexes linearly.

Actually this point is the first iteration where zero becomes one. Check the our condition. It is still not matched. 78 is the value of index one. So we are looking for number twelve. Let’s go ahead.

This is the point we were looking for. See the array after second iteration. We found the number twelve at the index two. Now the program should return the index where target value is exist. Let’s see the coding example.

class LinearSearch {
    public static int findTargetValue(int arr[], int targetValue) {
        int n = arr.length; // get array lenght
        for (int i = 0; i < n; i++) {
            if (arr[i] == targetValue) // check the condition
            {
                return i; // return the found index
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int arr[] = { 45, 78, 12, 6, 89, 24 };
        int targetValue = arr[2]; // 2nd value is twelve 

        int result = findTargetValue(arr, targetValue); // pass array and target value into method

        if (result != -1) {
            System.out.println("Target value is found at index " + result + ".");
        } else {
            System.out.println(  "Target value is not found.");
        }
    }
}

Hope you enjoy the blog and got some knowledge about linear search.

අද කතා කරන්න යන්නේ ජාවා operators ගැන. කවුරුත් දන්නවා operators නැතුව programming කරන්නනම් බැරි බව. Operators කියන්නේ java වල විතරක් නෙවෙයි ඕනිම පරිගනක භාෂාවක අත්‍යවශ්‍ය අංගයක්. අපි කෙලින්ම note එකට යමු. ජාවා වල operators කොටස් කිහිපයකටම බෙදෙනවා. අපි බලමු ඒ මොනවද කියලා.

Category

Operators

Arithmetic

+, -, *, %, ++, — , /,

Logical operator

&&, ||, !

Relational operator

<, >, <=, >=, ==, !=

Assignment operator

=, +=. -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>=

Shit operator

<<, >>, >>>

Ternary operator

?, :

Bitwise operator

&, ^, |

මේ විදිහට ජාවා operators වර්ග කරනවා. අද බලපොරොත්තු වෙන්නේ programming වලදී ගොඩක්ම භාවිතාවන operators වර්ග කීපයක් ගැන.

Arithmetic operator.

මේ arithmetical operators ඕනි වෙන්නේ ගණිතමය සංයුතියක් තියන programming part එකක් coding කිරීමේදියි. මම මෙහෙම දෙයක් කරන්නම් තේරුම් ගන්න ලේසි විදිහකට මේ operators ටික table එකකට උදාහරණත් එක්කම පෙන්නලා දෙන්නම්. මේකට ඕනිවෙනවා integer type එකේ අගයන් දෙකක්. මම int X = 10 ලෙසත් int Y=5 ලෙසත් ගන්නම්. දැන් මේ table එක හොඳට අධ්‍යයන කරන්න.

Operator

විස්තරය

උදාහරණය

+ (Addition)

අගයන් දෙකක් එකතු කිරීමට මෙම operator එක භාවිතා කරනවා.

X+Y = 15

- ( Subtraction)

අගයන් දෙකක් අඩු කිරීමට මෙම operator එක භාවිතා කරනවා.

X-Y=5

* (Multiplication)

අගයන් ගුණ කිරීම සඳහා මෙම operator එක භාවිතා කරනවා.

X*Y=50

/ (Division)

අගයන් බෙදීම සඳහා මෙම operator එක භාවිතා කරනවා.

X/Y=2

% (Module)

යම් අගයක් තවත් අගයකින් බෙදා ඉතිරිය ලබාගැනීමට මෙමෙ operator එක භාවිතා කරනවා.

X%Y=0

++ (increment)

මේ operator එකෙන් කරන්නේ තියන අගයට එකක් එකතු කරන එක. **

X++ = 11

— (Decrement)

මේ operator එකෙන් කරන්නේ තියන අගයෙන් එකක් අඩු කරන එක. **

X — = 9

අපි දැන් මේ operators භවිතා කරලා sample program එකක් බලමු.

public class BasicOperatorsOne {

public static void main(String[] args) {

int x = 10;

int y = 5;

System.out.println(x+y);

}

}

Output: 15

මේ program එක code කරලා run කරලා බලන්න. අනිත් operators add කරලත් (x-y, x%y, x/y ආදී වශයෙන්) run කරල බලන්න.

** මේ increment සහ decrement operators වල කොටස් දෙකක් තියනවා.

Increment :

• Post increment operator (10++) (අගයට පසු post operator භාවිතා වේ.)
• pre increment operator (++10) (අගයට පෙර pre operator භාවිතා වේ.)

public class BasicOperatorsOne {

public static void main(String[] args) {

int x = 10;

int y = 5;

System.out.println(++x); //try y++, x++, ++x

}

}

Output: 11

උඩ දීලා තියන program එකට (post increment) x++ හා y++ දාල run කරලා බැලුවොත් පිලිතුරේ වෙනසක් නැතිවෙයි. දැන් අපි බලමු එකට හේතුව මොකක්ද කියලා. Post increment operators යම් අගයකට එකතු කරහම එක වැඩ කරන්නේ දෙවෙනි වතාවට ඒ operator එක තියන line එක run වෙනකොටයි. මේකටත් අපි උදාහරණයක් බලමු.

public class BasicOperatorsOne {
public static void main(String[] args) {
for(int i =0; i > 10 ; i++)
System.out.println(i);
 }
}

Output: 0,1,2,3,4,5,6,7,8,9

මේ program එකේ තියෙන්නෙ for loop එකක්. දැන් (i++) කියල තියන operator එකට අවධානය යොමු කරන්න. මේ Program එක run කරලා බැලුවොත් out put එක විදිහට 0,1,2,3,4,5,6,7,8,9 පිලිවලින් print වෙයි. මේ program එකෙන් බලගන්න පුලුවන් post increment එක භවිතාකරලා එකින් එක වැඩි වෙලා දීලා තියන condition (i>10) එක false වෙනකල් වැඩකරලා තියන හැටි. ඉතින් මේකෙන් තේරුම් ගන්න ඕනි දේ තමයි pre increment operator (++x) භාවිතා කරහම පලවෙනි පාර program එක run වෙනකොටම එකක් එකතු වෙන බවත්. Post increment operator (x++) භවිතා කරහම දෙවෙනි වතාවට post increment operator එක තියන line එක run වෙනකොට එකක් එකතු වෙන බවත්.

Decrement:

• Post decrement operator (10 — ) (අගයට පසු operator භාවිතා වේ.)
• Pre decrement operator ( — 10) (අගයට පෙර operator භාවිතා වේ.)

public class BasicOperatorsOne {
public static void main(String[] args) {
int x = 10;
int y = 5;
System.out.println( - y); //try y - , x - 
System.out.println( - x);
  }
}

Output: 4, 9

මේකෙත් කලින් විස්තර කරපු operator එක වගේමයි. වෙනස තියෙන්නේ මේක decrement එක වීමයි. Post decrement operator එක තේරුම් ගන්නනම් යට දීල තියන program එක run කරල බලන්න.

public class BasicOperatorsOne {
public static void main(String[] args) {
for(int i =10; i > 0 ; i - )
System.out.println(i);
  }
}

Output: 10,9,8,7,6,5,4,3,2,1

මේ image ටික බලලා for loop එකත් increment operator එකත් වැඩකරන ආකාරය පිලිබද අදහසක් ගන්න. පලවෙනියටම i අගය 0 නිසා output එක 0 වෙනවා. දෙවෙනි පාර compile වෙනකොට i අගය 1 වෙනවා. ඒක වෙන්නේ, පලවෙනිපාර 0 ලෙස output එක ආවට පස්සේ ඊලගට compile වෙන්න පටන් ගන්නේ (i++) increment operator එක ලග ඉදන්. ඒ වෙනකොට i ගේ අගය බින්දුවයි increment එක මගින් බින්දුවට එකක් එකතුවෙනව එතකොට i ගෙ අගය එකක් වෙනවා. ඊටපස්සේ අපි දීල තියන condition එක check කරනවා (i<10). එක හරිනම් ආයෙත් i ගෙ අගය output එකක් විදිහට දෙනවා. මේ රටාවටම අපි දීලා තියන condition එක වරදිනකන්ම (false) output දෙනවා.

post decrement operator එකට example විදිහට දීලා තියන program එකෙත් වෙන්නේ මේ සිද්ධියමයි. වෙනස වෙන්නේ decrement නිසා 10 ඉදන් 1 ට print වෙනඑකයි.

අවුලක් තියනවනම් comment කරන්න. ඊලග කොටසින් හම්බෙමු එහෙනම්… ස්තූතියි ඈ.

Class variables are variables declared within a class, outside any method, with the static keyword.

Static key word එක භාවිතා කරලා, class එකක් ඇතුලේ, method එකකින් පිටතදී declare හා initialize කරන variables වලට අපි කියනවා class variables එහෙමත් නැත්නම් satatic variables කියලා. Static key word එක use කරලා variable එකක හැදුවොත් ඒක ඒ class එක ඇතුලේ තියන සියලුම method වලට access කරන්න පුලුවන්. ඒ වගේම variable එකේ අගයත් වෙනස් කරන්න පුලුවන් එනවා. අපි මේකටත් example program එකක් බලමු.

public class StaticVariableDemo {
  public static String myClassVar="this is static variabale";
  public static void main(String args[]){
    StaticVariableDemo obj = new StaticVariableDemo();
    StaticVariableDemo obj2 = new StaticVariableDemo();
    //All three will display "class or static variable"
    System.out.println(obj.myClassVar);
    System.out.println(obj2.myClassVar);
    //changing the value of static variable using obj2
    obj.myClassVar = "Changed Value";
    //All three will display "Changed Text"
    System.out.println(obj.myClassVar);
    System.out.println(obj2.myClassVar);
  }
}

output

හරි අපි බලමු මේ program එකත් මොකද මේකෙන් වෙන්නේ කියලා.

public static String myClassVar=”this is static variabale”;

මේ line එකේ තියන myClassVar word එක තමා class variable එකේ එහෙමත් නැත්නම් static variable එකේ name එක වෙන්නේ. Main method එක ඇතුලේ මොකද කරලා තියෙන්නෙ කියලා බලමු අපි. StaticVariableDemo කියන class එකෙන් object දෙකක් හදලා තියනවා “obj” සහ “obj2” කියන නම්වලින්. ඊට පස්සේ කරලා තියෙන්නේ අර class variable එක object දෙකම භාවිතා කරලා print කරගන්නවා. Out put එක විදිහට “this is static variabale” දෙපාරක් print වෙනවා.

obj.myClassVar = “Changed Value”;

මේ line එකෙන් කරලා තියෙන්නේ, පලවෙනි object name එක භාවිතා කරලා static variable එකට “change value” කියන text එක assign කරන එක. ඊට පස්සෙත් කලින් වගේම object දෙක භවිතාකරලා class variable එක print කරගන්නවා. එතකොට output එක විදිහට ලැබෙන්නේ Changed Value කියන text එකම දෙපාරක් print වෙලා.

මේකට හේතුව තම මෙ variable එක static key word එක සමග declare කර තිබීම. මේ class එක ඇතුලේ වගෙම වෙනත් class තුලත් access කරන්න පුලුවන් හැබැයි මේ static variable එක තියන class එක extend කරන්න ඕනි.

Instance variable (Non-static variable)

Instance variables are variables within a class but outside any method.

මේ variable type එකත් උඩින්කිව්ව එක වගේමයි හැබැයි මෙතන static key word එකක් නෑ. Declare කරන්නෙත් initialize කරන්නෙත් methods වලින් පිට හැබැයි class එකක් ඇතුලේ. මේ variables class එකේ ඕනිම method එකක් ඇතුලෙ access කරන්න පුලුවන්. මේ instance variable වල විශේෂ ලක්ෂණයක් තමයි, අපි variable එක වෙන තැනකදී access කරනකොට කලින් එකෙ copy එකක් තමා access වෙන්නේ. අපි sample program එකකුත් එක්ක බලමු එතකොට හොදටම තෙරෙයි.

public class InstanceVariable {
  String myInstanceVar = "instance variable";
    public static void main(String args[]) {

      InstanceVariable object1 = new InstanceVariable();
      InstanceVariable object2 = new InstanceVariable();

      System.out.println(object1.myInstanceVar);
      System.out.println(object2.myInstanceVar);

      object1.myInstanceVar = "java programmer";

      System.out.println(object1.myInstanceVar);
      System.out.println(object2.myInstanceVar);
  }
}

output

String myInstanceVar = “instance variable”;

මේකත් අර විදිහමයි හැබැයි static key word එක නෑ. මෙකෙත් object දෙකක් තියනවා. Object1, object2 කියලා. පලවෙනි පාර object දෙක භාවිතා කරලා myInstanceVar කියල variable එක print කරනකොට print වෙන්නෙ “instance variable” කියලා.

object1.myInstanceVar = “java programmer”;

මේ line එකේදී object1 එකෙන් variable value එක java programmer කියල change කරනවා. ඊට පස්සෙත් උඩින් වගේම object දෙක use කරලා myInstanceVar කියන variable එක print කරනවා. මෙතනදී, object1 එකට අදාලව print line එකේ output එක වෙන්නේ “java programmer” කියන එක. Object2 එකට අදාල print line එකේ output එක වෙන්නේ කලින් එකමයි ඒ කියන්නෙ instance variable කියන එක. Class variable එකේදී මේ variable දෙකම වෙනස් වුනා ඒත් මේකේ එහෙම නෑ, ඒක තමා මේ variable type දෙක අතරේ තියන ප්‍රධානම වෙනස. මේ ගෙන මම ගොඩක් කියන්න යන්නෙ නෑ මොකද local variable ගෙන කියනකොටත් අපි මේ ගෙන කතා කරා. හරි එහෙනම් දැනට නවතිනවා මේ programs අරගෙන compile කරලා බලන්න.

ස්තූතියි….

මේකනම් ගොඩක් වැදගත් ලිපියක්. එහෙමයි කියලා අනිත් ඒවා වැඩක් නෑ කියනවා නෙවෙයි. මේ ලිපියෙන් කියන්නෙ java වල programming part වලට ගොඩක්ම වැදගත් වෙන තොරතුරු ටිකක්. Normally කියනවනම් variable එකක් කියන්නේ කුමක් හෝ data type එකක data එකක් store කරගන්න ram එකේ හදගන්න space එකක්. අපි බලමු variable එකක් ලියන්නෙ කොහොමද කියලා.

Variable declaration

int i;

initializing variable

i = 10;

variable එකක් ලිවීමෙදී අපි මේ methods අනුගමනය කලයුතුයි. Variable declaration කියන එකෙන් කරන්නෙ variable එකේ data type එකයි, variable name එකයි දෙන එක. Variable initialize කිරීමේදී අපි කරන්නේ declare කරගත්ත variable එකට අගයක් assign කරන එක. මේ වැඩ දෙකම අපිට එක් line එකකදී කරන්න පුලුවන් මේ විදිහට.

int i = 10;

හරි අපි දැන් බලමු මොනවද java වල තියන variable types. ප්‍රධාන වශයෙන් කොටස් තුනක් තියනවා.

• Local variable.
• Class variable (static variable).
• Instance variable (Non-static variable).

Local variable

Variables defined inside methods, constructors or blocks are called local variables.

Local variable කියන්නේ ඇත්තටම class එකක method එකක් හෝ constructor එකක් ඇතුලේ declare හා initialize කරන variables වලට. ඒ variable එක ඕනේම data type එකකින් යුක්ත විය හැකියි. ඒ variables method එකෙන් බාහිරව access කිරීමට හැකියාවක් නෑ. ඒ වගේම තමා ඒ method එකෙන් පිටතදී මේ type එකේ variables වල අගයන් වෙනස් කරන්නත් බෑ. අපි උදාහරණයක් අරගෙනම බලමු.

public class LocalVariableText {
  public String myVar="instance variable";
    public void myMethod(){
    // local variable
    String myVar = "Inside Method, local variable";
    System.out.println(myVar);
    }
  public static void main (String args[]){
    // Creating object
    LocalVariableText obj = new LocalVariableText();
    obj.myMethod();
    System.out.println(obj.myVar);
  }
}

හරි අපි දැන් අපි බලමු මේ code එකෙන් මොකද වෙන්නේ කියලා. මේ program එකේ තියන class එකේ name එක LocalVariableText කියන එක , method name එක වෙන්නේ myMethod කියන එක. ඊට අමතරව main method එකත් තියනවා.

public String myVar = “instance variable”;

මේ line එකේ තියෙන්නේ string type එකේ instance variable එකක්. ඒ variable එක භාවිතා කරලා තියෙන්නෙ program එක පැහැදිලිවෙන්න. හරි දැන් අපි බලමු main method එක ඇතුලේ මොකද වෙන්නේ කියලා. Main method එක ගැන කියන්න දෙයක් නැනේ. එකත් අව්ල් වගේනම් blog එකේ තියනවා බලාගන්න පුලුවන්. පලවෙනියටම අපි කරලා තියෙන්නේ class එකෙන් object එකක් හදගන්න එක. Object name එක තමයි “obj” කියන්නේ. එතනට ඔයාට ඕනේ name එකක් දාගන්න පුලුවන්. ඊලගට කරලා තියෙන්නේ object එක මගින් method එකට call කරනවා. දැන් myMethod() එකෙ body එක බලන්න. එකේ තියනවා string type එකේ myVar කියන variable එක. “Inside Method, local variable” කියන text එක ඒ variable එකට assign කරලා තියනවා.

String myVar = “Inside Method, local variable”;

මෙතන තියන variable එක තමා local variable එක වෙන්නේ. ඒකට හේතුව තමා මේ method එක තියෙන්නේ myMethod කියන method එක ඇතුලේ නිසා. මේ local variable එකේ scope එක එහෙමත් නැත්නම් access කලහැකි පරාසය වෙන්නේ මේ method එක ඇතුලත විතරයි.

System.out.println(myVar);

මේ විදියට ඊලගට අපි local variable එක print කරගන්නවා. Output එක වෙන්නේ “Inside Method, local variable” කියන text එක. මොකද myVar variable එකේ value එක ඒක නිසා. ඊලගට instance variable කියලත් මේ program එකේදි print වෙනවා. හොදට main method එක බලන්න්න.

System.out.println(obj.myVar);

මේ line එකත් main method එකේ අවසානෙට තියනවා. එකත් class object එක මගින් myVar කියන variable එක තමා access කරලා තියෙන්නේ. හොදට බලන්න myMethod() එක ඇතුලේ තියන string variable එකත් ඒකට උඩින්, method එකෙන් පිට තියන string variable එකත් එකම name එකෙන් තමා තියෙන්නේ.

System.out.println(obj.myVar)

main method එකෙ අවසානෙට තියන මේ line එකේ myVar variable එකට assign කරලා තියෙන්නේ “instance variable” කියන text එක. ඒ නිසා value එක විදිහට print වෙන්නේ “instance variable” කියලා. ඒකට හේතුව තමා local variable එකේ scope එක method එක ඇතුලට විතරක් සීමා වෙන නිසා. අනිත් හෙතුව තමා instance variable එකේ scope එක සම්පූර්ණ class එක පුරාවටම තියන නිසා. මේ හේතු හින්දා තමා එකම නමින් variable දෙකම තිබ්බත් print වෙන අගයන් වෙනස් වෙන්නේ. මෙතනදී print වෙන්නේ local variable එක නෙවෙයි. Program එක අරගෙන run කරලා බලන්න.

output

Class variable හා instance variable වලින් හම්බෙමු එහෙනම්. ස්තූතියි….

Relational operators

අද කතකාරන්න යන්නේ relational හා ternary operators ගෙන. මේ relational operators වල ප්‍රධාන කාර්ය වෙන්නේ numbers දෙකක් එහෙමත් නැත්නම් අගයන් දෙකක් සංසන්දනය (compare) කරලා Boolean අගයක් (true or false) return කරන එක. ජාවා වල මේ type එකේ operators හයක් තියනවා.

< less than ( x < y , x කුඩයි y ට වඩා).

> greater than ( x > y , x විශාලයි y ට වඩා).

<= less than or equal ( x <= y , x කුඩයි හෝ සමානයි y ට).

>= greater than or equal ( x >= y , x විශාලයි හෝ සමානයි y ට).

== equal ( x == y , x සමානයි y ට).

!= not equal ( x != y , x අසමානයි y ට).

මේ operators ටික නම් බැලූ බැල්මටම ලේසි තේරුම් ගන්න. මේ operators හයටම අපි එක program එකක් බලමු. ඊට පස්සෙ ටිකක් කතාකරමු.

public static void main(String[] args) {
int x = 10;
int y = 15;
  System.out.println("x less than y :" + (x < y));
  System.out.println("x greater than y :" + (x > y));
  System.out.println("x less than or equal to y :" + (x <= y));
  System.out.println("x greater than or equal to y :" + (x >= y));
  System.out.println("x equal to y :" + (x == y));
  System.out.println("x not equal to y :" + (x != y));
}

ඔයාලට පෙන්නව මේ program එකේ මම x වල අගය විදිහට දීල තියෙන්නේ 10 ඒ වගේම y වල අගය දීල තියෙන්නේ 15. අපි මේක relational operators භාවිතාකරලා කියනවනම් මෙහෙමයි ( x < y ) x කුඩයි y ට වඩා. මේක තමා එතකොට හරි condition එක. මම දීල තියන program එකේ මේ condition එක භාවිතාකරලා තියෙන්නේ පලවෙනි print line එකේ.

“ System.out.println(“x less than y :” + (x < y)); “

බැලූ බැල්මට එහෙම පෙනුනට මේ program එකේ condition තුනක් හරි. අපි බලමු ඒ මොනවද කියලා.

1. System.out.println(“x less than y :” + (x < y));

2. System.out.println(“x not equal to y :” + (x != y));

3. System.out.println(“x less than or equal to y :” + (x <= y));

මේ line තුනම හොදට බලන්න. එක, x කුඩයි y ට වඩා. දෙක, x අසමානයි y ට. තුන, x කුඩයි හෝ සමානයි y ට. එහෙනම් මේ condition තුනම හරි. මෙන්න output එක.

මේ program එක run කරල බලන්න උඩින් කියපු condition තුන තියන lines වලට අදාලව ture කියල එයි ඉතුරු ඔක්කොම lines වලට අදාලව false print වෙයි. අපි තවත් program එකක් if else use කරලා බලමු තේරුම්ගන්න ලේසි වෙන්න.

public static void main(String[] args) {
int x = 10;
int y = 15;
  if (x == y) {
    System.out.println("X equal to Y.");
  } else if (x > y) {
    System.out.println("X greater than Y.");
  } else if (x <= y) {
    System.out.println("X less than or equal to Y");
  } else if (x >= y) {
    System.out.println("X greater than or equal to Y");
  } else if (x != y) {
    System.out.println("X not equal to Y");
  } else if (x < y) {
    System.out.println("X less than Y.");
  }
}

If else දන්නැත්නම් ඒකට අවුල්ක් ගන්න එපා. මේකෙන් කරන්නේ if , else if එකේ වරහන් ඇතුලේ තියන condition එක check කරලා output එකක් දෙන එක. මේක වැඩකරන්නේ මෙහෙමයි. පලවෙනියටම if එක ඇතුලෙ තියන condition එක check කරනවා. ඒක වැරදිනම් ඊලගට තියන else if එක ඇතුලට ගිහින් එකේ තියන condition එක check කරනවා. එකත් වැරදිනම් ඊලගට තියන else if එකේ condition එක check කරනවා. හැබැයි if එකෙ condition එක හරිනම් ඒක ඇතුලට ගිහින් එකේ තියන “X equal to Y.” කියන line එක print කරනවා. එතනින් ඉවරයි. එක condition එකක් වැරදිනම් විතරයි අනිත් එකට යන්නේ. Output එක මෙන්න.

ඉතින් මේ program එකේ තුන් වෙනියට තියන condition එක බලන්න. ඒක තමා පලවෙනියටම true වෙන condition එක. ඉතින් ඒ line එක print කරලා program එක නතර වෙනවා. Program එක compile කරලා බලන්න. If else ගෙන වැඩිය කතාකරන්නේ නෑ ඒක වෙනම අපි කතා කරමු.

Ternary Operator

අපි ternary operator විදියට operators දෙකක් හදුනගත්තා පලවෙනි lesson එකේදී. ( ? , : ) මේ operator දෙක තමා java වල ternary operator වෙන්නේ. දැන් අපි බලමු ඒවා කොහොමද භාවිතා වෙන්නේ කියලා. මේ operator දෙකම අපිට if else වෙනුවට භාවිතා කරන්නපුලුවන්. අපි බලමු කොහොමද ඒක වෙන්නේ කියලා. If else වැඩකරනහැටි උඩ විස්තරේදී පොඩ්ඩක් දැන ගත්ත නිසා මේ program එක බලන්න.

public static void main(String[] args) {
int number = -5;
  if (number > 0) {
    System.out.println(number + " is positive");
  } else {
    System.out.println(number + " is not positive");
  }
}

int variable එකක් තියනවා number කියලා අපි එකට -5 කියන අගය සමාන කරලා තියනවා. If condition එක ඇතුලෙදි number variable එකේ අගය 0 ට වඩා වැඩීනම් ඒක positive අගයක් ලෙසත්, එහෙම නැත්නම් ඒ අගය positive නොවන අගයක් ලෙසත් print කරන්න කියල තමා මේ program එකෙන් code කරලා තියෙන්නේ. දැන් අපි බලමු ternary operators භාවිතාකරලා කොහොමද මේ program එක code කරන්නේ කියලා.

public static void main(String[] args) {
int number = -5;
String result;
result = (number > 0) ? "positive" : "not positive";
  System.out.println(number + " is " + result);
}

මේ program එකේත් උඩින් එකේ තිබුන int variable එකයි, තව string type එකේ variable එකක් තියනවා result කියන name එකෙන්. මේ String කියන්නේ character values store කරලා තියගන්න පුලුවන් data type එකක් කියල දැනට මතක තියාගන්න. මේ program එක කියවන්නේ මෙහෙමයි.

number කියන variable එකෙ තියන අගය බිංදුවට වඩා විශාලයිනම් result කියන String variable එකට සමාන කරන්නලු “positive” කියලා. එහෙම නැත්නම් සමාන කරන්නලු “not positive” කියලා. මේ program එක අරගෙන run කරලා බලන්න. If else එක භාවිතා කරල කරපුදේමයි මේකෙනුත් කරල හියෙන්නේ. “?” (question mark) එකෙන් if condition එක ඇතුලෙදි කරන දේත් “:” (colon) එකෙන් else part එකත් සම්පූර්න වෙනවා. “for each” loop එකට එහෙමත් මේ operator එක භාවිතා වෙනවා.

System.out.println(number + “ is “ + result);

මේ line එකේදී කරලා තියෙන්නේ number කියන variable එකයි, “is” කියන word එකයි, result කියන variable එකයි print කරනඑක. Plus mark (+) එකෙන් කරලා තියෙන්නේ මේ අගයන්,ඒ වගේම is කියන word එක එකිනෙකට සම්බන්ධ කරනඑක. Variable එකක් print කර ගන්න ඕනිනම් double quotes (“”) භාවිතා නොකර නිකම්ම print කරගන්නවා මේ විදිහට.

System.out.println(number);

Variable දෙකක් හෝ ඊට වඩා print කරගන්න ඕනිනම් මෙහෙමයි.

System.out.println(number + result);

// System.out.println(number + result + number);

හැබැයි අපිට වෙන මොකක් හරි වචනයක්, වාක්‍යක් මේ අතරට දාගන්න ඕනිනම් වරහන් භාවිතා කරන්න වෙනවා. මේ වගේ.

System.out.println(number + “ is “ + result);

ඔන්න ඒ ටිකත් එතනදිම කිව්වා එහෙනම් තවත් පාඩමකින් හම්බෙමු.

ස්තූතියී…..

අද කතාකරන්න යන්නේ logical operators ගැන.

&& = logical AND operator

|| = logical OR operator

! = logical NOT operator

ජාවා වලදී ප්‍රධානවශයෙන් logical operators තුනක් භාවිතාවෙනවා. මේ operators තුනම බොහෝ දුරට භවිතාවෙන්නේ conditions check කිරීමේදීයි.

අපි && (AND) operator එක අරන් බලමු.

මේකෙන් කරන්නේ condition දෙකක් පරීක්ෂා කරනඑකයි. අපි check කරන condition දෙකෙන් එකක් හරි false නම් අපිට උත්තරේ දෙන්නේ false කියලා. අපි මේකට උදාහරණයක් බලමු.

public static void main(String[] args) {
int x=10;
int y=5;
int z=15;
  System.out.println(y<x && x>z);
  System.out.println(y<x && z>x);
}

මේ program එක බලමු.

X අගය 10 යි, Y අගය 5යි, Z අගය 15 යි.

ඊට පස්සේ එක line එකක් print කරනවා. ඒකෙදී condition දෙකක් check කරනවා && (AND) operator එක මගින්. පලවෙනි condition එක වෙන්නේ Y කුඩයි X ට වඩා ( Y<X ) ඒ condition එකනම් හරි. AND (&&) operator එක තියන නිසා ඊලග condition එකත් check කරනවා. දෙවෙනි condition එක වෙන්නේ ( X>Z ) X විශාලයි Z ට වඩා. ඒකනම් වැරදියී මොකද X අගය 10 යි, Z අගය 15 යි එහෙනම් X විශාල වෙන්න විදිහක් නෑ.

එහෙනම් පලවෙනි print line එකේ output එක වෙන්නේ FALSE. හේතුව තමා condition දෙකෙන් එකක් වැරදි වීම.

දෙවෙනි print line එකත් හොදට බලන්න. එකේ condition දෙකම හරි ඒ කියන්නේ output එක TRUE.

මේ program එකත් run කරලා බලන්න.

public static void main(String[] args) {
int x = 10;
int y = 5;
int z = 15;
  if(x < z && x < y){
    System.out.println("Both conditions are true");
  }else{
    System.out.println("FALSE");
  }
}

ඊලගට අපි || (OR) operator එක බලමු.

මේ operator එකෙන් කරන්නෙත් condition දෙකක් check කරන එක. Check කරන condition දෙකෙන් එකක් හරි හරිනම් output එක වෙන්නේ TRUE. අපි කලින් ගත්ත program එකම අරගෙන බලමු.

public static void main(String[] args) {
int x = 10;
int y = 5;
int z = 15;
  System.out.println(y < x || x > z);
  System.out.println(y > x || z < x);
}

පලවෙනි print line එක කියවන්නේ මෙහෙමයි “y කුඩයි x ට වඩා හෝ x විශාලයි z ට වඩා”. ඉතින් මේ condition දෙකෙන් දෙවෙනි condition එක වැරදි නමුත් එක condition එකක් හරි නිසා මේකේ output එක වෙන්නේ TRUE. මොකද මේකේ හෝ කියලා තියනවා පලවෙනි එක නැත්නම් දෙවෙනි එක. දෙවෙනි print line එකේ condition දෙකම වැරදි ඒ නිසා output එක වෙන්නේ FALSE.

මේ program එකත් check කරලා බලන්න.

public static void main(String[] args) {
int x = 10;
int y = 5;
int z = 15;
  if(x<z || x<y){
    System.out.println("TRUE");
  }else {
    System.out.println("FALSE");
  }
}

! (NOT) operator

අගයන් දෙකක් එකිනෙකට අසමානයි නම් ඒ අසමානතාවය අගයන් දෙක සංසන්දනය කර එය සත්‍ය හෝ අසත්‍ය බව පෙන්නුම් කිරීමට මේ operator එක භාවිතා කරනවා.

public static void main(String[] args) {
int x,y,z;
x=10;
y=5;
z=15;
  System.out.println(x>z);
  System.out.println(!(x>z));
}

මේ program එක අපි බලමු. කලින් program වල තිබුනු අගයන්මයි මේ program එකෙත් තියෙන්නේ. මේකේ පලවෙනි print line එකේ දීල තියන condition එක false. මොකද x අගය z අගයට වඩා කුඩා නිසා. දෙවෙනි condition එකත් ඒ විදිහමයි. ඒ උනාට ඒකට අපි ! (not) operator එක භාවිතා කරලාතියනවා. ඒ නිසා එකේ output එක true වෙනවා. හේතුව තමයි ! (not) operator එක මගින් දීලාතියන condition එක මොකක් උනත් ඒක අනිත්පැත්ත හරවනවා. True එකක් තිබුනොත් false කරනවා. False එකක් තිබුනොත් true කරනවා. අපි තවත් program එකක් බලමු.

public static void main(String[] args) {
int x, y, z;
x = 10;
y = 5;
z = 15;
    System.out.println(x > z);
    System.out.println(!(x > z));
  if (z > x && z > y) {
    System.out.println("Z is the largest value.");
  }
  if (x == y || y == z) {
    System.out.println("There are same values.");
  } else {
    System.out.println("There are no similar numbers.");
  }
  if (!(x < y)) {
    System.out.println("x is greater than y. ");
  }
}

මේ program එක code කරලා run කරල බලන්න. Values වගේම operators මාරුකරලා run කරලත් බලන්න.

Login system එකක database එකෙන් ගන්න user name, password check කරනකොට මේ && (AND) operator එක භාවිතා වෙනවා. ඒ වගේම තමයි system එකක user level පරීක්ෂා කරනකොට ! (NOT) operator එක භවිතාවෙනවා. ඒ වගේම තමා condition කිහිපයක් භවිතාවෙන තැනක || (OR) operator භවිතා වෙනවා. උදාහරණයක් විදිහට ගත්තොත් system එකක එකම feature එකක් user level දෙකකට පොදුයිනම් ඒ user level දෙක check කිරීමට මේ || (OR) operator එක භාවිතා කරන්න පුලුවන්.

• මේ logical operators නිතරම condition එකක් check කරලා එලියට දෙන්නේ Boolean අගයක්, ඒ කියන්නේ true හෝ false කියන දෙකෙන් එකක්.
• · ! (not operator) මේ operator එක සමහර තැන්වලදී unary operator එකක් විදිහටත් හදුන්වනවා. අපි ඒ ගෙන වෙනම කතාකරමු.

එහෙනම් ස්තූතියි…