DEV Community: ABHINAVA GHOSH (he/him)

Opinion needed .

ABHINAVA GHOSH (he/him) — Tue, 17 Nov 2020 09:55:13 +0000

I am in a confusion as to which software to go for next .

React Native or Flutter for android development.

Please help me choose ,and I would like to know what you think is better and why .

Thank you in advance.

intel chipsets - NOMENCLATURE demystified !

ABHINAVA GHOSH (he/him) — Sun, 11 Oct 2020 14:12:20 +0000

Have you ever wondered what are those weird naming - conventions used in machines powered by intel processors , and have just asked the salesperson for their recommendation ,just because you did not understand which one is better than the other and what difference does each number and letter make on the whole performance of the chipset !

Well , after reading this post , you will now feel much more confident on your own decision and don't have to ask for help from others. 😎

All intel chips have 3 basic parts and each of them have different roles .

🎯 Brand

The Intel naming scheme starts with the processor’s brand—the overall product line the processor was created for. Today, the most common Intel® processor names begin with Intel® Core™, Intel® Pentium®, and Intel® Celeron®. Intel® Pentium® and Intel® Celeron® processors are economical product lines created for price-conscious consumers. Intel® Core™ processors bring faster performance and additional features not available in Intel® Pentium® and Intel® Celeron® models.

🎯 Brand Modifier

Intel® Core™ processor series include a brand modifier before the remaining parts of the model number. Intel® Pentium® and Intel® Celeron® processors do not use this naming convention. Today, the Intel® Core™ processor series includes the brand modifiers i3, i5, i7, and i9

🎯 Generation Indicator

After the brand and brand modifier comes the processor’s generation indicator. Intel® processor generations are identified in the processor number in all Intel® Core™ processor brands. In a four-digit processor number, the first digit typically represents the generation. For example, a processor with the digits 9800 is a 9th gen processor, while one labeled 8800 is 8th gen technology.

🎯 SKU Numeric Digits

For the majority of Intel® processors, the final three digits of the product number are the SKU. SKUs are generally assigned in the order in which processors in that generation and product line are developed. A higher SKU within otherwise-identical processor brands and generations will generally have more features. However, SKU numbers are not recommended for comparison across different generations or product lines.

🎯 Product Line Suffix

The SKU suffix is another key indicator of the processor’s capabilities. These remaining differences are indicated by a letter-based product line suffix. For example, within the Intel® Core™ processor series, U indicates a processor that has been designed for power-efficient laptops or 2 in 1s. Meanwhile, XE indicates an “extreme edition” processor for desktops designed for maximum performance.

Now that we have a basic idea of what it means , lets have a better look into things.

🎯 The number next to the 'i' after 'Core' represents the kind ofr over-achieving performance a chip is capable of

A Core "i3" chip is on the lower end of performance that's best suited for budget computers.

A Core "i5" chip is on the mid-range of performance that's suited for casual users and power users on a budget.

A Core "i7" chip is on the higher end of performance that's suited for power users and professionals for power-hungry apps like Photoshop or video editing.

🎯 The first of the four numbers on Intel's Core chips represents the generation of the chip.

Intel's eighth and latest generation of chips will always have an "8" as the first number in the four-numbered grouping after the "iX" part.

The seventh generation will have a "7," and so on

The lower the number, the older the generation. When you're buying a new computer, you're generally avoiding those with chips that are two or more generations behind the latest generation.

🎯 The three following numbers after the generation number represent performance. The higher the numbers, the more powerful the chip

For example, an Intel Core i5 "8400" will be less powerful than a Core i5 "8600" .

The major difference is "clock speed" and "boost clock speed." The higher the clock speeds, the faster the chip can process what you want.

A casual user could opt for a cheaper computer with the Core i5 8400, while a power user on a budget could opt for computers with the slightly more expensive Core i5 8600 for an extra boost of power.

These numbers make a smaller difference than the number in the "iX" part, but they're still important.

🎯 What the letters mean after the numbers?

Intel's chips have letters like "K" and "U" after the numbers that give you an idea of what kind of purpose and performance the computer is designed for.

The "K" chips are usually the fastest, with higher clock speeds than the standard chips without a letter in Intel's mainstream chips. It also means the chip is "unlocked," where its clock speeds can be tweaked — or "overclocked — by a user to squeeze out a little extra performance than what you get out of the box. Usually, it's mostly enthusiasts who tend to overclock their chips, and they're mostly designed for desktops or high-performance laptops.

The "G" means the chip has a built-in graphics processor. Most of Intel's chips come with basic built-in graphics processors so you can display something on your monitor without an entirely separate graphics card. But Intel's "G" processors come with a more powerful graphics processor for more power-hungry apps and games. Surprisingly, the graphics processors in Intel's "G" chips come from the company's main rival, AMD.

The "T" means the chips is designed to use less power while also having less performance than the standard chips without any letters.

The "U" means the chip is designed for laptops and mobile devices, as "U" chips are Intel's "ultra-low power" models. They're "low power" because they use even less power than the "T" models and have slower clock speeds than their full-size, non "U" equivalents. By having slower clock speeds, they don't get as hot and have a lower risk of heat-related damage. That's good for thin laptops that have limited cooling compared to larger desktops and laptops.

Suffix	Meaning
G1-G7	Graphics level (processors with new integrated graphics technology only)
E	Embedded
F	Requires discrete graphi
G	Includes discrete graphics on package
H	High performance optimized for mobile
HK	High performance optimized for mobile, unlocked
HQ	High performance optimized for mobile, quad core
K	Unlocked
S	Special edition
T	Power-optimized lifestyle
U	Mobile power efficient
Y	Mobile extremely low power

For better visual understanding

Linus tech-tips
Another Linus' video

Please leave a ❤️ if you liked this post!
A 🦄 would be great!

And feel free to let me know in the discussions if you think i missed something.

HAVE A GOOD DAY!

Java 7 -> Java 8

ABHINAVA GHOSH (he/him) — Sun, 23 Aug 2020 16:42:38 +0000

We all as Java Developers will agree that Java 8 is the best upgrade that Java/Oracle pushed till now.
Although the latest version of Java is Java 14 but still the most used version of Java is Java 8.

So in this post I will be discussing the major changes that were pushed by the "Java Creators" from transitioning from Java 7 - > Java 8.

❗ [DISCLAIMER]-This will be a long post , because i wanted it to be the single core resource for Java 7 -> Java 8 transition, which will help developers in the future as they get everything in one single post and do not have to refer to any other resource .

So sit tight and enjoy !! ✨

📋 Here we mainly discuss the differences, or in other words advancements that have been included in Java 8 when compared to Java 7.
To begin with, let me give a brief introduction to Java 7. Java 7 was released in 2011. This was the first major update of Java after being acquired by Oracle from Sun Microsystems. Java 7 is the final Java version that would officially support Windows XP.

📎 There were some major features that were included in Java 7. Such as:

Compressed 64-bit pointers.
Upgraded class-loader architecture.
Multiple exception handling.
JVM support for dynamically support languages.
Upgraded Rowset 1.1 and JDBC 4.1.
String object in a switch statement.
Automatic resource management in a try statement and much more.

📒 But in this blog, our main concern will be on discussing a few advancements that happened when updating from Java 7 to Java 8.
Java 8 was released in March 2014. The most anticipated feature — Lambda Expressions, was introduced and made possible from Java 8. The use of this Lambda Expressions made Java closer to functional programming which it was not used to be. Java 8 also includes a faster and improved JVM which makes it possible to run programs more efficiently.

📎 Now it is time to point out and discuss some of the major upgrades of Java 8 when compared to Java 7.

Lambda Expressions
Lambda expressions only have a body and a parameter list.
Advantages we get by using Lambda Expressions are,
Enhanced iterative syntax.
Readability.
Code Reuse.
JAR file size reduction.
Simplified variable scope.
Encouraging Functional Programming.

Let us look at a couple of examples using lambda expressions:-

lambda expression with no arguments passed ☝️

Lambda Expression with One Arguments Passed ☝️

Lambda Expression with Two Arguments Passed ☝️

In Java, a functional interface is an interface that has only one abstract method.

🎯 Null Reference Template
We can also call it the Java Optional Class.

Advantages using the Java Optional class are,
No Null Pointer Exceptions at run-time.
Clean APIs can be developed.
Null checks are not required.

Java Optional Class Example ☝️

🎯 New Date and Time API

In java.util.Date class the years starting from 1900 and the months start from 0. So it is important to know it, as when we want to assign a year and a month it must be as (YYYY-1900) and (MM-1). This was overcome in Java 8 using the classes in java.time package.
Unlike integer or string, the Date class is mutable. Which means that the date can be changed without the owner class knowing. Java 8 has a solution for this. The LocalDate, LocalTime, LocalDateTime, etc. introduced in Java 8 are immutable (The original object is not changed. Whenever a change is done, a new object will be returned).

Use of the New Date and Time API ☝️

🎯 Unsigned Integer Arithmetic

It is not clear what Java 8 has tried to achieve by the advancement in unsigned integer arithmetic. But generally, an unsigned integer is considered to be harmful to Java. It adds complexity to the type conversion tools, type system, and library APIs.

🎯 Stream API

The main advantage that we get using the Stream API is that it clearly increases the speed and efficiency of the program. It is considered to be a powerhouse in Java.

🎯 Parallel Sorting

Parallel sorting uses multiple threads for the operation. It makes the program fast and efficient. This will not be that much visible with a small data set. But if we use large data set the efficiency and the increase in performance will be highly noticeable.

Credits-@Chinthaka Jayatilake .

🎯 New JavaScript Engine (deprecated after Java 11)

The JavaScript Engine introduced with Java 8 was named Nashorn.
With that now, we have come to the end of this section and the main aim of it was to give an idea about the updated and added features in Java 8 compared to Java 7. According to the examples provided hope you got an idea on how to use these advancements for your benefit. Most of these provide us with advantages but there are certain drawbacks as well if we look at different perspectives. It is important to remember, only to absorb the features that would help us and make our program more efficient, reliable, and stable.

Now lets go into a little deeper into some important concepts that are used very often.

Java 8 method references are the shortened versions of lambda expressions calling a specific method. For example, lambda expression (Student s) -> s.getName() which is calling a method getName() of Student class can be shortened as Student::getName using Java 8 method references. Let’s see them in detail.

🎯 Java 8 Method References :

📌 Definition:-
Java 8 method references can be defined as shortened versions of lambda expressions calling a specific method. Method references are the easiest way to refer a method than the lambdas calling a specific method. Method references will enhance the readability of your code.

📌 Syntax

📎 Method reference to static method :

ClassName::MethodName

Use this syntax when you are referring to a static method.

Integer::parseInt, Math::max

📎 Method reference to instance method of an existing object :

ReferenceVariable::MethodName

Use this syntax when you are referring to an instance method of already existing object.

s::getName

where ‘s’ is a reference variable referring to Student object which already exist.

📎 Method reference to instance method of non-existing object :

ClassName::MethodName

Use this syntax when you are referring to an instance method by passing reference variables as an argument.

(Student s) -> s.getName() can be written as
Student::getName

📌 Constructor References

You can also refer to the constructor of a class same as method references. Syntax for referring to constructor is:

ClassName::new

🎯 Java 8 Interface Changes : Default Methods And Static Methods

It has been a tough task for Java API developers to add new methods to current interfaces. Because, even if you add a single abstract method to an interface, all existing implementations of that interface have to be updated with implementation of new method. What if there exist hundreds or thousands of implementations of an interface? Even worse, What if you don’t have control over all of those implementations? To overcome such overhead, new features are introduced to interfaces from Java 8. They are default methods and static methods. In this article, we will see these new Java 8 Interface Changes.

🎯 Java 8 Interface Changes

From Java 8, interfaces can also have concrete methods i.e methods with body along with abstract methods. This is the major change introduced to interfaces in Java 8 to help Java API developers to update and maintain the interfaces. The interfaces can have concrete methods either in the form of default methods or static methods.

🎯 Default Methods

Definition With Example:-

Default methods of an interface are the concrete methods i.e methods with body for which implementing classes need not to give implementation. They inherit default implementation. Default methods start with the modifier default.

interface InterfaceWithDefaultMethod
{
    void abstractMethod();           //Abstract Method

    default void defaultMethod()
    {
        System.out.println("It is a default method");
    }
}

class AnyClass implements InterfaceWithDefaultMethod
{
    @Override
    public void abstractMethod() 
    {
        System.out.println("Abstract Method implemented");
    }

    //No need to implement defaultMethod()
}

🎯 Why Default Methods?

Default methods are introduced to add extra features to current interfaces without disrupting their existing implementations. For example, stream() is a default method which is added to Collection interface in Java 8. If stream() would have been added as abstract method, then all classes implementing Collection interface must have implemented stream() method which may have irritated existing users.

Thanks to Java 8 default method feature, now it is a default method, all implementations of Collection interface inherit default implementation of stream() method.

🎯 Three Rules To Solve Diamond Problem

In Java, a class can extend only one class but can implement multiple interfaces. With the introduction of default methods, it is possible that your class inherit multiple methods with same signature. In such scenarios, to solve the conflict, Java 8 specifies 3 rules to follow.

🎯 Static Methods

Definition With Example
From Java 8, interfaces can also have static methods. Static methods are also concrete methods but they can’t be implemented.

interface InterfaceWithDefaultAndStaticMethod
{
    void abstractMethod();           //Abstract Method

    default void defaultMethod()
    {
        System.out.println("It is a default method");
    }

    static void staticMethod()
    {
        System.out.println("It is a static method");
    }
}

class AnyClass implements InterfaceWithDefaultAndStaticMethod
{
    @Override
    public void abstractMethod() 
    {
        System.out.println("Abstract Method implemented");
    }

    //No need to implement defaultMethod()

    //Can't implement staticMethod()
}

🎯 Why Static Methods ❓

Do you know? Collection and Collections.

Collection is an interface and Collections is an utility class containing only static methods which operate on Collection objects.

Java API developers have followed this pattern of supplying an utility class along with an interface to perform basic operations on such objects. But from Java 8, they have break this pattern by introducing static methods to interfaces.

With the introduction of static methods to interface, such utility classes will disappear and methods to perform basic operations will be kept as static methods in interface itself.

🎯 Interface Vs Abstract Class After Java 8

With the introduction of concrete methods (default and static methods) to interfaces from Java 8, the gap between interface and abstract class has been reduced significantly. Now both can have concrete methods as well as abstract methods. But, still there exist some minute differences between them. In this article, we will try to list down the differences between interface Vs abstract class after Java 8.

Differences Between Interface And Abstract Class After Java 8 :
🎯 Fields
Interface fields are public, static and final by default. Interfaces still don’t support non-static and non-final variables. Interfaces can only have public, static and final variables. On the other hand, abstract class can have static as well as non-static and final as well as non-final variables. They also support private and protected variables along with public variables.

🎯 Methods
After Java 8, an interface can have default and static methods along with abstract methods. Interfaces don’t support final methods. But, abstract classes support final as well as non-final methods and static as well as non-static methods along with abstract methods.

Also note that, only interfaces can have default methods. Abstract classes can’t have default methods.

🎯 Constructors
Interfaces can’t have constructors. Abstract classes can have any number of constructors.

🎯 Member’s Accessibility
All members of interfaces are public by default. Interfaces don’t support private and protected members. But, abstract classes support all type of members – private, protected and public members.

🎯 Multiple Inheritance
A class can extend only one abstract class, but can implement multiple interfaces. Thus, a class can inherit multiple properties from multiple sources only through interfaces, not through abstract classes.

🎯 Interface Vs Abstract Class After Java 8 :
The below table and program summarizes the similarities and differences between interface and abstract class after Java 8

interface anyInterface
{
    int i = 10;            //By default, interface fields are public, static and final

    void abstractMethod();          //Interface can have abstract method

    default void defaultMethod()
    {
        System.out.println("Interface can have default method");
    }

    static void staticMethod() 
    {
        System.out.println("Interface can have static method");
    }

    //No constructors in an interface

    //No non-static and non-final variables in an interface

    //No private fields and methods in an interface

    //No protected fields and methods in an interface

    //No final methods in an interface
}

abstract class anyAbstractClass
{
    private int a;          //Abstract class can have private field

    protected int b;        //Abstract class can have protected field

    public int c;           //Abstract class can have public field

    static int d;           //Abstract class can have static field

    final int e = 10;       //Abstract class can have final field

    int f;                  //Abstract class can have non-static and non-final field

    public anyAbstractClass() 
    {
        System.out.println("Abstract class can have constructors");
    }

    abstract void abstractmethod();    //Abstract class can have abstract method

    private static void staticMethod() 
    {
        System.out.println("Abstract class can have private and static method");
    }

    public void nonStaticMethod()
    {
        System.out.println("Abstract class can have public and non-static method");
    }

    protected void protectedMethod() 
    {
        System.out.println("Abstract class can have protected method");
    }

    final void finalMethod()
    {
        System.out.println("Abstract class can have final method");
    }

    //No default method in an abstract class
}

References:

Oracle Docs

Other resources

Thank you for reading this Article. 😊

Please leave a ❤️ if you liked it.
An 🦄 will be great.

And let me know in the discussions area ,if you have any suggestions for me.

Have a Good Day! 😃

Some of my other posts:

Concept	link
Java Access Modifiers	goto Article
Java Generics	goto Article
Java Regex	goto Article
Java Streams Api	goto Article

Bit Manipulation Techniques

ABHINAVA GHOSH (he/him) — Mon, 10 Aug 2020 05:14:32 +0000

LIKE MYSELF I HAVE SEEN MANY PEOPLE SPECIALLY BEGINNERS STRUGGLING WITH BIT MANIPULATIONS IN THE BEGINNING!
SO I THOUGHT I WOULD WRITE A POST SO THAT PEOPLE CAN BENEFIT FROM IT!

THIS IS JUST THE NOTES I MADE A WHILE BACK AS A LOOKUP NOTES WHENEVER I WAS STUCK AT ANY BIT MANIPULATION QUESTIONS!

BIT HACKS:

🎯 binary numbers are 0 indexed
REMEMBER left shifting a number by i multiplies that number with 2^i
and right shifting by i divides it by 2^i

🎯 N-1 INVERTS EVERY BIT STARTING FROM RIGHTMOST ONE till INDEX ‘0’
IF N=0b00000110
N-1=0b00000101

🎯 1<< left shifts 1 by i positions
1>>i
right shifts 1 by i positions

🎯 whenever we want to toggle ,set,unset ith bit of a number we always use 1 as our helper with different operators

🎯 toggle ith bit:toggling means 1->0 and 0->1
1ST STEP: left shift 1 to the position where we want to toggle
2ND STEP: we have taken the 1 to the ith bit(remember all rest are 0s) then we need to make it a 1 if its a zero and make it 0 if its a one
3RD STEP: so we have the 1 fixed ,using this we need to make 0->1 or 1->0
if we do '&'
0&1=0(incorrect)
1&1=1(incorrect)

'|'
0|1=1(correct)
1|1=1(incorrect)

'^'
0^1=1(correct)
1^1=0(correct)

hence we could only do xor(^)

🎯 set ith bit(means make the ith bit 0->1)

we again use 1<<i to reach the ith position
then we do '|' with 1<<i
therefore if bit was 0 it becomes 1
if it was already 1 then it still remains 1
NOTE-USING XOR IS NOT RECOMMENDED ,BECAUSE IF THE ith BIT IS ALREADY SET THEN XOR WILL GIVE WRONG RESULT!

🎯 unset/clear ith bit (make 1->0)

we need again the 1< now we do a negation ~ to this 1 we took so that the 1 in our 1 initially becomes 0 and every other bit becomes 1
suppose i=3
we do 1<<3 to get
0b00000001->0b00001000
then ~ gives
0b00001000->0b11110111
so we have ith bit if our 1 as 0 and rest 1
now we just & it with the number whose ith bit is to be unset!

🎯 Checking if bit at nth position is set or unset:

Left shift ‘1’ to given position and then ‘AND'(‘&’).

Some more quick hacks:

🎯 Inverting every bit of a number/1’s complement:
If we want to invert every bit of a number i.e change bit ‘0’ to ‘1’ and bit ‘1’ to ‘0’.We can do this with the help of ‘~’ operator. For example : if number is num=00101100 (binary representation) so ‘~num’ will be ‘11010011’.

This is also the ‘1s complement of number’.

🎯 Two’s complement of the number: 2’s complement of a number is 1’s complement + 1.
So formally we can have 2’s complement by finding 1s complement and adding 1 to the result i.e (~num+1)

🎯 *Stripping off the lowest set bit *:
In many situations we want to strip off the lowest set bit for example in Binary Indexed tree data structure, counting number of set bit in a number.

We do like this:

X = X & (X-1)

Let us see this by taking an example, let X = 1100.

(X-1) inverts all the bits till it encounter lowest set ‘1’ and it also invert that lowest set ‘1’.

X-1 becomes 1011. After ‘ANDing’ X with X-1 we get lowest set bit stripped.

🎯 Getting lowest set bit of a number:
This is done by using expression ‘X &(-X)’Let us see this by taking an example:Let X = 00101100.
So ~X(1’s complement) will be ‘11010011’ and 2’s complement will be (~X+1 or -X) i.e ‘11010100’.
So if we ‘AND’ original number ‘X’ with its two’s complement which is ‘-X’, we get lowest set bit.

🎯 SOME MORE IMPORTANT HACKS:

x&1 gives the lowest bit(helps in finding whether number is even or odd i.e if last bit is 0 then it is even otherwise odd)
x & (x-1) will clear the lowest set bit of x
x & ~(x-1) extracts the lowest set bit of x (all others are clear). Pretty patterns when applied to a linear sequence.
x & (x + (1 0<< n)) = x, with the run of set bits (possibly length 0) starting at bit n cleared.
x & ~(x + (1 << n)) = the run of set bits (possibly length 0) in x, starting at bit n.
x | (x + 1) = x with the lowest cleared bit set.
x | ~(x + 1) = extracts the lowest cleared bit of x (all others are set).
x | (x - (1 << n)) = x, with the run of cleared bits (possibly length 0) starting at bit n set.
x | ~(x - (1 << n)) = the lowest run of cleared bits (possibly length 0) in x, starting at bit n are the only clear bits.

HOPE IT HELPS!

Please leave a ❤️ if you liked this article.
A 🦄 would be great.
And let me know in the discussions panel if you have any suggestions for me.

Have a Good Day! 😃

Some of my other posts:

Concept	link
Java Access Modifiers	goto Article
Java Generics	goto Article
Java Regex	goto Article
Java Streams Api	goto Article

Let's talk about STREAMS !!

ABHINAVA GHOSH (he/him) — Sat, 08 Aug 2020 09:40:02 +0000

Hey there!

In this article I will be talking about Streams in Java and how they help in writing neat and compact production codes.

But before diving into Streams let us talk a little about Functional Programming

We as Java developers are constantly grilled about Java's verbose nature and how to even print a single word we have to write about 5-8 lines of code. 😭

Well this was the scenario before JAVA 8 came into the picture.
With the inclusion of Functional Programming the JAVA code's verbosity can be reduced to around 70%. 😮

Coming back to my point lets see what is Functional Programming.

🎯 What is Functional Programming ❓

Functional programming (also called FP) is a way of thinking about software construction by creating pure functions. It avoid concepts of shared state, mutable data observed in Object Oriented Programming.

Functional languages emphasizes on expressions and declarations rather than execution of statements. Therefore, unlike other procedures which depend on a local or global state, value output in FP depends only on the arguments passed to the function.

🎯 Characteristics of Functional Programming:

Functional programming method focuses on results, not the process
Emphasis is on what is to be computed

Data is immutable
Functional programming Decompose the problem into 'functions
It is built on the concept of mathematical functions which uses conditional expressions and recursion to do perform the calculation
It does not support iteration like loop statements and conditional statements like If-Else

🎯 The benefits of functional programming:

Allows you to avoid confusing problems and errors in the code
Easier to test and execute Unit testing and debug FP Code.
Parallel processing and concurrency
Hot code deployment and fault tolerance
Offers better modularity with a shorter code
Increased productivity of the developer
Supports Nested Functions
Functional Constructs like Lazy Map & Lists, etc.
Allows effective use of Lambda Calculus.

So we have a basic idea of Functional Programming now!
Lets see how this is implemented in JAVA Streams

Simply put, streams are wrappers around a data source, allowing us to operate with that data source and making bulk processing convenient and fast.

A stream does not store data and, in that sense, is not a data structure. It also never modifies the underlying data source.

This functionality – java.util.stream – supports functional-style operations on streams of elements, such as map-reduce transformations on collections.

✅ Before beginning with Streams lets note down some important concepts :

1.Stream is a flow of data derived from a collection
2.Stream can create a pipeline of function that can be evaluated
3.Data in Stream is Lazy Evaluated
4.Stream can transform data but cannot mutate it.

🎯 [NOTE] - Stream is not a Data Structure.Also the data structure on which you are creating the stream is not changed at all.The Stream just (kinda) makes a copy of it and performs some actions on its own copy.

Well that's all fine but how to create a Stream ? 😕

🎯 Stream Creation:

✔️ Let’s first obtain a stream from an existing array:

private static Dev[] arrayOfDevs = {
    new Dev(1, "Steve Rogers", 100000.0), 
    new Dev(2, "Anthony Stark", 200000.0), 
    new Dev(3, "Bruce Wayne", 300000.0)
};

Stream.of(arrayOfDevs);

✔️ We can also obtain a stream from an existing list:

private static List<Dev> devList = Arrays.asList(arrayOfDevs);
devList.stream();

And we can create a stream from individual objects using Stream.of():

Stream.of(arrayOfDevs[0], arrayOfDevs[1], arrayOfDevs[2]);

✔️ Or simply using Stream.builder():

Stream.Builder<Dev> devStreamBuilder = Stream.builder();

devStreamBuilder.accept(arrayOfDev[0]);
devStreamBuilder.accept(arrayOfDev[1]);
devStreamBuilder.accept(arrayOfDev[2]);

Stream<Dev> devStream = devStreamBuilder.build();

Ok so now we know how to create a Stream. 😎
But whats the use of a Stream if we cant play around with it.

🎯 Stream Operations:

Let’s now see some common usages and operations we can perform on and with the help of the stream support in the language.

✔️ forEach:

forEach() is simplest and most common operation; it loops over the stream elements, calling the supplied function on each element.

The method is so common that is has been introduced directly in Iterable, Map etc:

@Test
public void whenIncrementSalaryForEachDev_thenApplyNewSalary() {    
    devList.stream().forEach(d -> d.salaryIncrement(10.0));

    assertThat(devList, contains(
      hasProperty("salary", equalTo(110000.0)),
      hasProperty("salary", equalTo(220000.0)),
      hasProperty("salary", equalTo(330000.0))
    ));
}

This will effectively call the salaryIncrement() on each element in the devList.

forEach() is a terminal operation, which means that, after the operation is performed, the stream pipeline is considered consumed, and can no longer be used.

✔️ map

map() produces a new stream after applying a function to each element of the original stream. The new stream could be of different type.

The following example converts the stream of Integers into the stream of Devs:


@Test
public void whenMapIdToDevs_thenGetDevStream() {
    Integer[] devIds = { 1, 2, 3 };

    List<Dev> devs = Stream.of(devIds)
      .map(devRepository::findById)
      .collect(Collectors.toList());

    assertEquals(devs.size(), devIds.length);
}

Here, we obtain an Integer stream of dev ids from an array. Each Integer is passed to the function devRepository::findById() – which returns the corresponding Dev object; this effectively forms an Dev stream.

✔️ collect
We saw how collect() works in the previous example; its one of the common ways to get stuff out of the stream once we are done with all the processing:

@Test
public void whenCollectStreamToList_thenGetList() {
    List<Dev> devs = devList.stream().collect(Collectors.toList());

    assertEquals(devList, devs);
}

collect() performs mutable fold operations (repackaging elements to some data structures and applying some additional logic, concatenating them, etc.) on data elements held in the Stream instance.

The strategy for this operation is provided via the Collector interface implementation. In the example above, we used the toList collector to collect all Stream elements into a List instance.

✔️ filter

Next, let’s have a look at filter(); this produces a new stream that contains elements of the original stream that pass a given test (specified by a Predicate).

Let’s have a look at how that works:

@Test
public void whenFilterDevs_thenGetFilteredStream() {
    Integer[] devIds = { 1, 2, 3, 4 };

    List<Dev> devs = Stream.of(devIds)
      .map(devRepository::findById)
      .filter(e -> e != null)
      .filter(e -> e.getSalary() > 200000)
      .collect(Collectors.toList());

    assertEquals(Arrays.asList(arrayOfDevs[2]), devs);
}

In the example above, we first filter out null references for invalid dev ids and then again apply a filter to only keep devs with salaries over a certain threshold.

✔️ toArray
We saw how we used collect() to get data out of the stream. If we need to get an array out of the stream, we can simply use toArray():

@Test
public void whenStreamToArray_thenGetArray() {
    Dev[] devs = devList.stream().toArray(Dev[]::new);

    assertThat(devList.toArray(), equalTo(devs));
}

The syntax Dev[]::new creates an empty array of Devs – which is then filled with elements from the stream.

🎯 [NOTE]

Lazy Evaluation

One of the most important characteristics of streams is that they allow for significant optimizations through lazy evaluations.

Computation on the source data is only performed when the terminal operation is initiated, and source elements are consumed only as needed.

All intermediate operations are lazy, so they’re not executed until a result of a processing is actually needed.

For example, consider the findFirst() example we saw earlier. How many times is the map() operation performed here? 4 times, since the input array contains 4 elements?

@Test
public void whenFindFirst_thenGetFirstDevInStream() {
    Integer[] devIds = { 1, 2, 3, 4 };

    Dev devs= Stream.of(devIds)
      .map(devRepository::findById)
      .filter(e -> e != null)
      .filter(e -> e.getSalary() > 100000)
      .findFirst()
      .orElse(null);

    assertEquals(devs.getSalary(), new Double(200000));
}

Stream performs the map and two filter operations, one element at a time.

It first performs all the operations on id 1. Since the salary of id 1 is not greater than 100000, the processing moves on to the next element.

Id 2 satisfies both of the filter predicates and hence the stream evaluates the terminal operation findFirst() and returns the result.

No operations are performed on id 3 and 4.

Processing streams lazily allows avoiding examining all the data when that’s not necessary. This behavior becomes even more important when the input stream is infinite and not just very large.

Java Streams Api is a very large topic and i have tried my best to fit as much as possible in this post.
Please refer to the below links for more in depth knowledge.

👇

Some of my other posts:

Concept	link
Java Access Modifiers	goto Article
Java Generics	goto Article
Java Regex	goto Article
Java Streams Api	goto Article

Please leave a ❤️ if you liked this article.
A 🦄 would be great.
And let me know in the discussions panel if you have any suggestions for me.
And do leave a link to any resource on Java Streams Api that you know of ,that can help others and i will add it to the post.

Have a Good Day! 😃

Opinion Needed !

ABHINAVA GHOSH (he/him) — Wed, 05 Aug 2020 20:25:24 +0000

With Google really pushing Kotlin with free courses and all, is Android App development really taking a new route from Java to Kotlin ?

As an novice-Android App dev , should i switch to Kotlin or stick with Java ?

Lets carry on this discussion .
Post your views and opinions in the discussions panel below.
Thank You in advance !

Let's Talk About REGEX !!

ABHINAVA GHOSH (he/him) — Wed, 05 Aug 2020 12:00:27 +0000

I think most of us would agree that :

"Regex" is one of those concepts in computer science that no matter how many times you practice , you may have to go back to your notes or google about it. 😟

What are regex/regular expressions ❓ 😕

A regular expression defines a search pattern for strings. The abbreviation for regular expression is regex. The search pattern can be anything from a simple character, a fixed string or a complex expression containing special characters describing the pattern. The pattern defined by the regex may match one or several times or not at all for a given string.

💥 Common matching symbols:

Regular Expression	Description
.	matches any character
^regex	Finds regex that must match at the beginning of the line.
regex$	Finds regex that must match at the end of the line.
[abc]	Set definition, can match the letter a or b or c.
[abc][vz]	Set definition, can match a or b or c followed by either v or z.
[^abc]	When a caret appears as the first character inside square brackets, it negates the pattern. This pattern matches any character except a or b or c.
[a-d1-7]	Ranges: matches a letter between a and d and figures from 1 to 7, but not d1.
X	Z
XZ	Finds X directly followed by Z.
$	Checks if a line end follows.

💥 Meta characters:

Regular Expression	Description
\d	Any digit, short for [0-9]
\D	A non-digit, short for [^0-9]
\s	A whitespace character, short for [ \t\n\x0b\r\f]
\S	A non-whitespace character
\w	A word character, short for [a-zA-Z_0-9]
\W	A non-word character [^\w]
\S+	Several non-whitespace characters
\b	Matches a word boundary where a word character is [a-zA-Z0-9_]

🎯 [NOTE]: These meta characters have the same first letter as their representation, e.g., digit, space, word, and boundary. Uppercase symbols define the opposite.

💥 Quantifier:

A quantifier defines how often an element can occur. The symbols ?, *, + and {} are qualifiers.

Regular Expression	Description
*	Occurs zero or more times, is short for {0,}
+	Occurs one or more times, is short for {1,}
?	Occurs no or one times, ? is short for {0,1}.
{X}	Occurs X number of times, {} describes the order of the preceding liberal
{X,Y}	Occurs between X and Y times
*?	? after a quantifier makes it a reluctant quantifier. It tries to find the smallest match. This makes the regular expression stop at the first match.

🎯 [NOTE] - The backslash \ is an escape character in Java Strings. That means backslash has a predefined meaning in Java. You have to use double backslash \ to define a single backslash. If you want to define \w, then you must be using \w in your regex. If you want to use backslash as a literal, you have to type \\ as \ is also an escape character in regular expressions.

💥 Redefined methods on String for processing regular expressions.

Regular Expression	Description
s.matches("regex")	Evaluates if "regex" matches s. Returns only true if the WHOLE string can be matched.
s.split("regex")	Creates an array with substrings of s divided at occurrence of "regex". "regex" is not included in the result.
s.replaceFirst("regex"), "replacement"	Replaces first occurance of "regex" with "replacement.
s.replaceAll("regex"), "replacement"	Replaces all occurances of "regex" with "replacement.

Practice your Regex Skills here
Cheatsheet

Some resources gathered from the discussions panel:
regex101
regexr
ihateregex.io

Thank you Madza , Jakeer for the links.

Some of my other posts:

Concept	link
Java Access Modifiers	goto Article
Java Generics	goto Article
Java Regex	goto Article
Java Streams Api	goto Article

Please leave a ❤️ if you liked this post!
A 🦄 would be great!

And feel free to let me know in the discussions if you think i missed something.

HAVE A GOOD DAY!

CASE STYLES IN PROGRAMMING !

ABHINAVA GHOSH (he/him) — Wed, 29 Jul 2020 16:31:50 +0000

have you ever came across words like camel case ,snake case and wondered what actually they mean? 😕

In this Article I will be elaborating about the different case styles available in computer programming.

The most popular ways to combine words into a single string:

🐫 camelCase: Camel case combines words by capitalizing all words following the first word and removing the space, as follows:

Raw:

the unconventional coder

Camel Case:

theUnconventionalCoder
----👆--------------👆

Use: Mainly in variable declaration.

Pascal Case : Pascal case combines words by capitalizing all words (even the first word) and removing the space, as follows:

Raw:

the unconventional coder

Pascal Case:

TheUnconventionalCoder

Use: Declaring classes

🐍 Snake Case : Snake case combines words by replacing each space with an underscore (_) and, in the all caps version, all letters are capitalized, as follows:

Raw:

the unconventional coder

Snake Case:

the_unconventional_coder

Use : Used for naming constants.

Kebab Case : Kebab case combines words by replacing each space with a dash (-), as follows:

Raw:

the unconventional coder

Kebab Case:

the-unconventional-coder

Use : Used for naming URL's.

reference

Please leave a ❤️ if you liked this article!
And feel free to leave any suggestions for me in the discussions panel.

Amortized Time Complexity

ABHINAVA GHOSH (he/him) — Sat, 25 Jul 2020 11:16:29 +0000

In computer science algorithms and data structures , most of the time we consider the Big-O complexity analysis as the benchmark.
But Big-O Analysis is not always the best option.
Here in this article I will discuss , how Amortized Complexity makes much more sense in some cases.

🎯 Amortized time is the way to express the time complexity when an algorithm has the very bad time complexity only once in a while besides the time complexity that happens most of time. Good example would be an ArrayList which is a data structure that contains an array and can be extended.

In a normal Array , the size of the array is predefined.
Hence Insertions in Array are O(1) or constant time.
But When we use ArrayList , the size is variable and can increase/decrease depending upon the input.
Every ArrayList has an initial capacity.
Mostly the initial capacity is 10.

Now , when we want to insert more than 10 elements then three steps need to be performed:
1.Create a new Array of double size(2N)
2.Copy all previous elements(N)
3.Add the new element.

When ArrayList hits the array capacity in it, then it create a new array with the doubled size of the old array and copy all the items in the old array to the new array. In ArrayList, two time complexities exist; one is O(1) and the other is O(n).

The first kind is O(1) as shown below:

The second kind is O(N) as show below:

Thus in case of Dynamic Array we can say that:

The insertion takes O(n) when the capacity has been reached, and the amortized time for each insertion is O(1).

Final Words:

In Oracle terms (which are implied tacitly) and speaking about List:

🎯 add method (synonym - "append method") always means boolean add(E)
🎯 insert method always means boolean add(int index, E)

When Oracle writes:

The add operation runs in amortized constant time, that is, adding n elements requires O(n) time.

it means:

Complexity of a single boolean add(E) operation is amortized O(1).

It cannot be just O(1) asymptotic (always) because rarely we need to grow array capacity. This single add operation which is in fact a "create new bigger array, copy old array into it, and then add one element to the end" operation is O(n) asymptotic complexity, because copying the array when increasing List capacity is O(n), complexity of growing plus adding is O(n) [calculated as O(n) + O(1) = O(n)]. Without this capacity growing operation, add complexity would have been O(1), element is always added (appended) to the end of array (max index). If we "added" (= inserted) not to array end, we would need to move rightmost elements (with bigger indexes), and complexity for single such operation would have been O(n).

Now, for a single add operation asymptotic complexity is O(1) for add-without-increasing-capacity and O(n) for add-with-increasing-capacity (which happens very rare).

Amortized complexity of a single add operation is O(1). It reflects the fact that rare O(n) grow-and-add operations get "diluted" with much more numerous O(1) add-without-grow ones, so "on the average" single operation is O(1).

"Asymptotic complexity" of n add operations is O(n). But here we speak about complexity of n operations, not complexity of one operation. It is not a strict way to put it like this ("Asymptotic complexity"), but anyway. Amortized complexity of n operations is even less sense.

Finally, boolean add(int index, E) single operation complexity is always O(n). If it triggers grows, it is O(n) + O(n) [grow + insert], but 2*O(n) is same as O(n).

So , in such cases the Amortized Analysis makes more sense.

I am providing the below links for reference and better understanding.

Gaurav Sen Theory part

Gaurav Sen Coding part

0612 TV w/ NERDfirst

Big O Cheat Sheet

If you liked this post then please leave a heart ❤️

And if you have any queries or suggestions for me , then please leave them in the discussions panel.

Java Concept of the Day.

ABHINAVA GHOSH (he/him) — Thu, 23 Jul 2020 11:01:46 +0000

Concept for today is Java Generics.

This is a continuation of the series Java Concepts
ORIGINAL POST

Now before we begin , let me tell you that Java Generics Concept will be covered in two parts

part 1 -Introduction , and basics .

part 2 -Advanced Generics.

part 1-Introduction to Generics.

First of all :

What are Generics?

well ,as a java programmer , many times you may have noticed the use of angled brackets <> in java programs mostly in Collections(ArrayList,Set,Map) etc.

Whenever you see <> , means that generics were used here.

Generics in Java were introduced in JSE 5.0(2004)

If you are a Java programmer then type-casting is one of those things which might irritate you the most.
Well Java Generics extend Java's type system to allow ‘a type or method to operate on objects of various types while providing compile-time type safety.’
Generics were introduced to reduce the pain of constantly type-casting variables to make them work correctly.

Lets start with a simple Java Example:

package generics;

public class container {
    String item1;
    String item2;

    public container(String item1, String item2) {
        this.item1 = item1;
        this.item2 = item2;
    }

    public void print()
    {
        System.out.println("container contains: ");
        System.out.println(item1);
        System.out.println(item2);
    }
}

At this stage,the container class is only able to work with String DataTypes.

package generics;
public class app {
    public static void main(String[] args) {
        container container  =new container("java","23");//only string can be passed as a parameter
        container.print();
    }
}

What if we wanted to make this class work with any data type(int,double boolean etc).
To do this we can change the String type to Object type(Because every class is a child class of Object class in Java)

So we can change the code as follows:

package generics;

public class container {
    Object item1;
    Object item2;

    public container(Object item1, Object item2) {
        this.item1 = item1;
        this.item2 = item2;
    }

    public void print()
    {
        System.out.println("container contains: ");
        System.out.println(item1);
        System.out.println(item2);
    }
}

Now we have made this class kind of "generic" i.e we dont have to worry about typecasting our variables to String before passing them.

package generics;
public class app {
    public static void main(String[] args) {
        container container  =new container(false,23);
        container.print();
    }
}

Hence we just passed an int and a boolean value and it worked flawlessly!

But wait ,there is a problem in this.

Lets introduce some getters in our container class(Shortcut for this is alt+insert).

package generics;

public class container {
    Object item1;
    Object item2;

    public container(Object item1, Object item2) {
        this.item1 = item1;
        this.item2 = item2;
    }

    public Object getItem1() {
        return item1;
    }

    public Object getItem2() {
        return item2;
    }

    public void print()
    {
        System.out.println("container contains: ");
        System.out.println(item1);
        System.out.println(item2);
    }
}

Now lets try to get item1 and item2 from our app.java class.

package generics;
public class app {
    public static void main(String[] args) {
        container container  =new container(false,23);
        container.print();
        boolean a= container.getItem1(); //compile error
        int b=container.getItem2();//compile error

    }
}

We get a compile error which says : casting required for boolean and int.
To Solve this we have to again cast them to boolean and int.

package generics;


public class app {
    public static void main(String[] args) {
        container container  =new container(false,23);
        container.print();
        boolean a= (boolean) container.getItem1();//compiled successfully
        int b= (int) container.getItem2();//compiled successfully

    }
}

Thus we still had to type cast it because the container class returns an Object whereas we are collecting it in boolean/int variable.

Remember,we boolean/int variable cannot implicitly accept an Object variable ,but the Object variable can accept ant other datatype.
errors like this will appear : error: incompatible types:

So our class is not Generic till now.
Lets make it Generic:

package generics;

public class container<i1,i2> {
   i1 item1;
    i2 item2;

    public container(i1 item1, i2 item2) {
        this.item1 = item1;
        this.item2 = item2;
    }

    public i1 getItem1() {
        return item1;
    }

    public i2 getItem2() {
        return item2;
    }

    public void print()
    {
        System.out.println("container contains: ");
        System.out.println(item1);
        System.out.println(item2);
    }
}

"i1,i2" are user defined(you can use any names).
So,Basically now we have made it possible for container class to accept any kind of object(as the user wants it to be).

Now lets see the magic!

package generics;

public class app {
    public static void main(String[] args) {

        container<Boolean,Integer> container  =new container<Boolean,Integer>(false,23);
        container.print();
        boolean a= container.getItem1();
        int b=  container.getItem2();

        container<String,Integer> container2  =new container<String,Integer>("java",23);
        container2.print();
        String a2=container2.getItem1();
        int b2=container2.getItem2();
    }
}

See, we have made two different object of the same class 'container' but both of them pass different data types to the same functions

That is the true use of Java Generics.
for every variable of container we dont have to type cast it to boolean/int.
for every variable of container2 we dont have to type cast it to String/int.
Because the java generics take care of it.

So that's it for Java Generics Part1.
Hope you have got a basic understanding of how generics work at the basic level.
In part2 we will be going much deeper into some advanced concepts of Generics.

If you liked this Article then please leave a heart .
And let me know in the comments if you have any suggestions for me.

Java Concept of the Day.

ABHINAVA GHOSH (he/him) — Tue, 21 Jul 2020 13:29:09 +0000

This is the continuation of the post where i will be discussing one core java concept every alternate day.

ORIGINAL POST

Today's concept-Java Access Modifiers.

Java ,unlike many other OOP language has 4 access modifiers.
public
protected
default
private

public: The access level of a public modifier is everywhere. It can be accessed from within the class, outside the class, within the package and outside the package.

protected : The access level of a protected modifier is within the package and outside the package through child class. If you do not make the child class, it cannot be accessed from outside the package.

default: the access level of a default modifier is only within the package. It cannot be accessed from outside the package. If you do not specify any access level, it will be the default.

private : The access level of a private modifier is only within the class. It cannot be accessed from outside the class.

The Access modifiers below are arranged in decreasing order of visibility:

public>protected>default>private

Access Modifiers on Classes:

For outer classes there is only two choices: public,default
For inner classes there is no restriction,all four can be used.

NOTE:each java file can only contain one public class,and the name of that public class has to be same as of the file name.

Access Modifiers on Member Variables and Functions:

Public data members:they are accessible for any class in any package.(No security)

Protected data members:they can be accessed from classes of the same package and also from classes of other packages who inherit them,in other words, if any class from any other package is a child class then that class can access protected data members through inheritance.

Default data members:the other name for default is package private.Thus default data members are accessible only from the same package.

Private data members:Only accessible from the class in which they are declared(Most Secure).

NOTE: If we are overriding any method, overridden method (i.e. declared in subclass) must not be more restrictive.

What this means is that while overriding the accessibility can only be increased (or the same as parent class) ,but cannot be decreased.

Thus:
public cannot be changed to private,default,protected.
protected cannot be changed to private,default
default cannot be changed to private
Methods declared private are not inherited at all, so there is no rule for them.

oracle java documentation

Please like this post if it helped you , liking this article will provide motivation for me to deliver even better articles in the future.

Thank You for taking out the time to read this article.
Please comment down any suggestions for me .
And let me know what topic i should cover next.

JAVA CONCEPTS!

ABHINAVA GHOSH (he/him) — Mon, 20 Jul 2020 17:46:36 +0000

Plan

Going to start a series on Java Concepts(both programming and core) where in every two days i will explain (or try to explain) a very fundamental concept of java and readers are encouraged to actively participate in the discussions.

Goal

The goal of this series will be to brush up the fundamentals of java , which we tend to forget easily.

For beginners: this will be a very good resource to grasp the fundamental concepts of the language .

Feel Free to suggest any improvements!

Concept	link
Java Access Modifiers	goto Article
Java Generics	goto Article
Java Regex	goto Article
Java Streams Api	goto Article