Blogger, Engineer & Entrepreneur
Increment and Decrement operators
public class Incdec {
public static void main(String[] args) {
int a1 = 5;
--a1; //predecrement
int a2 = 10;
++a2; //preincrement
int b1 = 15;
b1--; //postdecrement
int b2 = 20;
b2++; //postincrement
System.out.println(a1);
System.out.println(a2);
System.out.println(b1);
System.out.println(b2);
}
}
OUTPUT
4
11
14
21
Java program to perform basic operations
public class Operator{
public static void main(String[] args) {
int a = 10;
int b = 5;
int add = a+b;
int sub = a-b;
int mul = a*b;
int div = a/b;
int mod = a%b;
System.out.println(add);
System.out.println(sub);
System.out.println(mul);
System.out.println(div);
System.out.println(mod);
}
}
An array is a collection of variables which are of similar type. Arrays can be accessed with their indexes.
Arrays can be used to store numbers, list of values and other variables.
Consider the following example below :
int[ ] Bitcoin = new int[5];
Here, we are defining an array Bitcoin of integer datatype consisting of 5 Bitcoins.
We can reference each element in the array with an index, say the elements of the array are {5,50,85,22,78}. We can access the 2nd element by using Bitcoin[1]. Note indexing in Java starts at 0.
Let us look into a program to access arrays by referencing:
public class Cryptocurrency {
public static void main(String[] args) {
String[ ] Blockchain = { “Amsterdam”, “Berlin”, “Capetown”, “Delhi”};
System.out.println(Blockchain[2]);
}
}
Program to calculate length of an array.
public class Coins {
public static void main(String[] args) {
int[ ] Bitcoin = new int[5];
System.out.println(Bitcoin.length);
}
}
Program to find sum of an array.
public class Coins {
public static void main(String[] args) {
int [ ] Bitcoin = {5,50,85,22,78};
int sum=0;
for(int k=0; k<Bitcoin.length; k++) {
sum += Bitcoin[k];
}
System.out.println(sum);
}
}
In this code, the variable sum stores all the variables by adding all the elements of array. Initially the sum is assigned a value of zero. A for loop traverses through the array list because of the expression k<Bitcoin.length, that is the number of elements will be equivalent to a value less than length of the array. Remember, the indexing starts at [0] for arrays.
Printing values of an Array.
public class Coins {
public static void main(String[] args) {
int[ ] values = {5,50,85,22,78};
for (int P: values) {
System.out.println(P);
}
}
}
2D and 3D Arrays
Accessing 2D Array
public class Coins {
public static void main(String[] args) {
int[ ][ ] Bitpart = { {77, 55, 34}, {41, 54, 63} };
int j = Bitpart[1][0];
System.out.println(j);
}
}
Accessing 3D Array
public class Coins {
public static void main(String[] args) {
int[ ][ ] Bitpart = { {17, 21, 32}, {41,70,44}, {51, 62, 75} };
Bitpart[0][2] = 32;
int m = Bitpart[1][0];
System.out.println(m);
}
}
Similarly, N dimensional arrays can also be accessed.
Source:1)THE Java™ Programming Language, Fourth Edition By Ken Arnold, James Gosling, David Holmes 2) SoloLearn Online Platform.
| Process | Thread |
|---|---|
| 1) Part of Concurrent Programming. | 1) Integral part of Concurrent Programming. |
| 2) A process has a self-contained execution environment. | 2) A thread is a lightweight process. |
| 3) Process has its own memory space. | 3) Threads share the process's resources, including memory and open files. |
| 4) Processes are synonymous with programs or applications. | 4) Threads do things such as memory management and signal handling. |
| 5) A Java application can create additional processes using a ProcessBuilder object. | 5) A Main thread has the ability to create additional threads. |
| 6) To facilitate communication between processes, most operating systems support Inter Process Communication (IPC) resources, such as pipes and sockets. | 6) Threads exist within a process. This makes for efficient, but potentially problematic, communication. |
Processing time for a single core is shared among processes and threads through an OS feature called time slicing.
Time Slice or Preemption : A technique to implement multitasking in operating systems. The period of time for which a process is allowed to run in a preemptive multitasking system is generally called the time slice or quantum. The scheduler is run once every time slice to choose the next process to run.
Source: 1) The Java™ Tutorials 2) Wikipedia
OOP is based on “objects“. An object can perform a set of functions. The functions that the object performs defines the object’s behavior.
For example, the Batsman(object) can play shots or a Bowler(object) can Bowl.
Languages that support object-oriented programming have four important aspects:
1. Abstraction
2. Encapsulation
3. Inheritance
4. Polymorphism
Abstraction involves the process to define objects that represent abstract actions which can perform work,
report on and change their state, and interact with other objects in the system.
Encapsulation is the process of enclosing data and functions into a single element.
Inheritance is when an object or class is based on another object,
using parent objects properties to maintain the same behavior in the child object.
Polymorphism is the method of having a single interface to objects of different types.
Object-oriented programming (OOP) is a programming paradigm
Objects — > data — > fields — > attributes — > methods(code)
Some of the popular languages that support Object-Oriented Programming
Java, Python, C++, C#, Perl, Ruby , Objective-C, PHP, et al.
Most algorithms in Java operate on list instances and subsequently with other collection instances. The different algorithms used in Java are:
Sorting
The sort algorithm reorders a List so that its elements are in ascending order according to an ordering relationship. Two forms of the operation are provided.
FORM 1
The simple form takes a List and sorts it according to its elements’ natural ordering.
The sort operation uses a optimized merge sort algorithm which is fast and stable:
FORM 2
The second form of sort takes a Comparator in addition to a List and sorts the elements with the Comparator.
Shuffling
The shuffle algorithm does the opposite of what sort does, destroying any trace of order that may have been present in a List. That is, this algorithm reorders the List based on input from a source of randomness such that all possible permutations occur with equal likelihood, assuming a fair source of randomness. This algorithm is useful in implementing games of chance.
This operation has two forms:
One takes a List and uses a default source of randomness, and the other requires the caller to provide a Random object to use as a source of randomness.
Routine Data Manipulation
The Collections class provides five algorithms for doing routine data manipulation on List objects, as listed below:
Searching
The binarySearch algorithm searches for a specified element in a sorted List. This algorithm has two forms.
The return value is the same for both forms.
Composition
The frequency and disjoint algorithms test some aspect of the composition of one or more Collections:
Finding Extreme Values
The min and the max algorithms return, respectively, the minimum and maximum element contained in a specified Collection. Both of these operations come in two forms.
The simple form takes only a Collection and returns the minimum (or maximum) element according to the elements’ natural ordering.
The second form takes a Comparator in addition to the Collection and returns the minimum (or maximum) element according to the specified Comparator.
Source: The Java™ Tutorials
A collection or container is an object that groups multiple elements into a single unit, they are used to store, retrieve, manipulate and aggregate data.
A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:
Interfaces
The collection interfaces encapsulate different types of collections. These interfaces allow collections to be manipulated independently of the details of their representation.
Queues usually order elements in a FIFO (first-in, first-out) manner.
If an unsupported operation is invoked, a collection throws an UnsupportedOperationException.
Note: All core collection interfaces are generic.
Source: The Java™ Tutorials