DEV Community: Tarun Kumar J

Go/Golang - Data Structures ( Arrays,Slices and Maps )

Tarun Kumar J — Wed, 29 Sep 2021 03:17:42 +0000

Arrays

An Array is a collection/sequence of values of a single type. Arrays in Go are similar to arrays in other languages.
Let's see how to declare an array in Go, Below is an example:

var value1 [5]int

var value2 [3]string

You can also initialize arrays with pre-defined values.

var value1 = [5]int { 11, 22, 33, 44, 55}

value2 := [3]string{ "This is " ,"Golang" , "Blog series"}
//Initializing with short variable declaration operator

You can access all the elements of an array using for loop. Below is a code snippet :

    var numArr = [5] int {24,76,45,33,65}

    for i:=0; i< len(numArr); i++ {
                   fmt.Println("Value is :",numArr[i])
    }

The len() function above is used to find the arrays's size.

Note: Arrays are passed as values to a function. That is we pass a copy of it.

Slices

A Slice in Go is very similar to an array. Arrays are of fixed size, But slices are dynamically sized.
Slices can double their current size to add more values. Slices store elements of similar type.

Slices are declared just as an array but they don't specify the size. Below is an example of that:

var sliceValues1 [ ]int 

var sliceValues2 [ ]string

To add values to the slice we use append() function. Let's see a code snippet where we initialize a slice and add more values to it.


var intSlice = []int {1,2,3,4,5,6,7}
intSlice = append(intSlice,8)

fmt.Println("Length : ", len(intSlice)) /*Prints length of slice*/
fmt.Println("Capacity :" ,cap(intSlice)) /*Prints capacity of slice*/

intSlice = append(intSlice,9,10,11) //You can append multiple values too
fmt.Println(intSlice) //Prints slice after appending multiple values

In the above snippet len() gives us the current length of slice cap() gives us the total capacity of it.

We can create a slice of a slice by using the below code :

sliceVal := []int{10,20,30,40,50,60}

sliceVal1 := sliceVal[0:4] // It creates a slice of 10,20,30,40 

fmt.Println(sliceVal1)

One important note is that Slices are passed by reference in Go.

Maps

Maps in Go are used to store key-value pairs and It doesn't allow any identical keys.
Let's see how to declare a map in a code snippet below:

var animals map[int]string

In the above snippet, The key is of type int and the value is of string type.

You have to initialize a map when declaring it or else it's a nil Map and you can't add elements to a nil Map. Let's see how to initialize a Map in Go.

var animals map[int]string {
       1 : "Tiger" ,
       2 : "Lion" ,
       3 : "Elephant" ,
       4 : "Giraffe", //The comma is a must after the last key
}

A Map can be created using make() function. make() function creates an initialized map, Below is a code snippet to create that:


prices := make(map[string]int)
prices["Item1"] = 240
prices["Item2"] = 350
prices["Item3"] = 150

The above prices map can be iterated as follows:

for item, price := range prices {
            fmt.Println(item , ":>" ,price)
}

You can remove a key using the built-in delete() function

delete(prices, "Item1")

A Point to Note is Maps are reference types. So when a Map is assigned to a variable, If any changes are made in the variable it also changes the Map.

That's it for this blog ✅.

For more information, You can always check out the official documentation.
This is the official site 💯.

If you are new to the Go language and you want to check out more,
Below are some resources 🔥.

Resources

Free coding exercises(Gophercises) course in Go by John Calhoun. You can check it out here.
A full video course on Go by freecodecamp.
There's a course on Codecademy on Go language. You can check it out here.

Go/Golang Basics - Pointers and Functions

Tarun Kumar J — Sat, 25 Sep 2021 03:59:23 +0000

A function is a group of statements that can be used repeatedly in a program. Below is a simple function definition in Go language :

func helloUser() {

         fmt.Println(" Hello, World!")
}

The above-defined function helloUser() has a print statement in it and It runs it when we call the function.

A function starts with the keyword func followed by the function name. Below is a function that is defined with parameters.

func addNumber(num1 int, num2 int)  int { 

         return num1 + num2

}

The above function has two parameters num1 and num2 and there's a return type specified after the parentheses. The return type here is Int. A Go function can return multiple values

Since the above function has the parameters with the same datatype we can write it as :

func addNumber(num1, num2 int)

*Note *: Go uses Pass by value to pass arguments in a function. It cannot change the arguments within the function that are being passed.

Below is an example of multiple return values in a Go function.

package main

import "fmt"

func main() {

          num1 := 20
          num2 := 30
          add, mul := addandMultiplyNum(num1,num2)
          fmt.Println("Result after adding is :", add)
          fmt.Println("Result after multiplying is :" ,mul)
}

func addandMultiplyNum(num1,num2 int) (int,int){
       result1 := num1 + num2
       result2 := num1 * num2
       return result1, result2
}

Pointers

As I said above Go uses Pass by value in functions. Go is a Pass by value language.
It means that it only passes the value of the argument and the argument itself. The changes that take place in function stay within that.

To change the values we use Pointers.

A Pointer is a variable that is used to store the memory address of another variable. Every time we use a variable we retrieve the value stored at the variable's address. To access the address of the variable we use & operator.

Below is the example for that:

var num = 55

fmt.Println(&num)  // Prints the address of num

To store the addresses we use pointers. The*operator is used to declare a pointer.
An example of that is :

var num = 55
var pointertoNum *int = &num 

fmt.Println(pointertoNum) //Prints the address of num

If we'd want to store a different value in the variable, We can access the value stored in the address by the* operator. That is also called dereferencing.

var num = 55
var pointertoNum *int = &num 

*pointertoNum = 45

fmt.Println(num) // Prints 45

To change values that are passed to function, We can use Pointers.
Below is a example for that :

package main

import "fmt"

func changeNumtoZero(numptr *int){  //The parameter here is pointer to num
*numptr = 0
}

func main() {

num := 20
fmt.Println(num) // Prints 20
changeNumtoZero(&num) //Pass the address of num
fmt.Println(num) // Prints 0

}

That's It for this blog ✅.

For more information, You can always check out the official documentation.
This is the official site 💯.

If you are new to the Go language and you want to check out more,
Below are some resources 🔥.

Resources

Free coding exercises(Gophercises) course in Go by John Calhoun. You can check it out here.
A full video course on freecodecamp.
There's a course on Codecademy on Go language. You can check it out here.

Go/Golang Basics - Variables and Data types

Tarun Kumar J — Thu, 16 Sep 2021 08:05:12 +0000

Basic data types in Go are:int, float,complex,string,bool.
Int, Float, and complex are part of the numbers.

We'll start with Integers.There are two categories, One is signed and other is unsigned integers.Signed integers can be negative but unsigned integers are always positive.Signed int is referred as int and Unsigned int as uint.

They are : int8, int16, int32, int64, uint8, uint16, uint32, uint64, int, uint.

Example:

package main

import "fmt"

function main() {

            var lengthOfWire uint16 = 36
            var numberOfChocalates int8 = 10 
            var boxlength uint = 200
            var x int =  -450
}

Next is Floating-Point Numbers. They are of two types float32 and float64.

      var ratingOfTheProduct float32 = 3.5

Finally, the next part is Complex Numbers. Complex numbers are of two types, complex64 and complex128. The in-built function creates a complex number from its imaginary and real part. Complex numbers can be initialized as:

      var x complex64 = complex( 5, 2)
      var y complex128 = complex( 7, 3)

If they are printed then, their output would be:

(5 + 2i)
(7 + 3i)

Boolean: Boolean data type contains only 1 bit of information. It's either 0 or 1. 0 denotes false and 1 denotes true.

They can be initialized as :

     var isCodingFun bool = true

The last data type is a string. A string stores sequence of characters and it must be surrounded with double-quotes. They can be initialized as:

     var text string = "Hi, Welcome to Golang Blog Series"

You can concatenate two strings by using the + operator.

     var nameOfMovie string = "Avengers Endgame "

     var concatStr string = nameOfMovie + "is one of the greatest superhero movies."

Variables

Variables in the Go language hold a value even before we assign anything to it. They are default values. All the numeric variables have 0 as default and string variables have"". Boolean variables have false as default value.

You can declare a variable without stating its type by := (short declaration operator ). For example :


         nameOfMovie := "Avengers Endgame"
         x := 15
         y:= 3.7
         isClimateChangeReal := true

Go also allows us to declare multiple variables in a single line. An Example of that is :

       var x , y = 10,20

       nameOfStreet , sure := "Abbey road" , true 
      //'nameOfStreet' is type 'string' and 'sure' is type 'bool'

That's it for this blog ✅.

For more information, You can always check out the Official documentation. This is the official site 💯.

If you are new to the Go language and you want to check out more, Below are some resources 🔥.

Resources

A full video course on freecodecamp.
There's a Course on Codecademy on Go language. You can check it out here.

Go/Golang Basics

Tarun Kumar J — Wed, 15 Sep 2021 02:51:01 +0000

Go is Open Source Programming language that is statically typed . Although it is statically typed, It's so fast that it feels like it's an Interpreted language.

So let's start with the basics. As Go is a Compiled language, Its Code has to be converted to an executable/binary file. Go has a compiler that translates the code into a binary file.

If your file's name was helloworld.go then to compile it on the terminal, The command would look like this :

go build helloworld.go

The command would create a "helloworld" file. To execute that, call ./helloworld in the terminal

./helloworld

There's a run command that both compiles and executes the code. Although the run command will not create a binary file.

For example to run the command on helloworld.go file, It would look like this:

go run helloworld.go

A Go program should have a package declaration. After the package declaration, We have import statement right below it. It looks like:

package main

import "fmt"

Note that the package name has to be enclosed in double quotes .

The functions in Go are declared with func keyword and that is followed by name of the function.
Let's see a basic program.

package main

import "fmt"

func main() {

        fmt.Println(" Hello World! ")

}

In the above program in function main we have used the fmt package which helps us call Println to print.

To run the command we use

go run main.go

This would print the message "Hello World!".

In Go language, the main package is a special package which is used with the programs that are executable and this package contains main() function. Go automatically calls the main function and there is no need to explicitly call it.

You can use go doc on the command line for more information about the packages.

go doc fmt

The above command gives us information about fmt package.
For more specific information you could use:

go doc fmt.Println

And Lastly, For more information about Go lang ,You can always check the documentation. This is the official site 💯.

If you are learning Go language and would want to know more, Below are some resources 🔥.

Resources:

Watch a video course on freecodecamp .
There's a free course on Codecademy too. You can check it out here.

ArrayList In Java.

Tarun Kumar J — Tue, 15 Sep 2020 05:52:03 +0000

Continuing my Blogs on Java Data Structures, The next topic is ArrayLists . So, Let's know about ArrayLists and how it essentially works.

ArrayList is another tool in Java to store a large number of values that are of the same type.
In a high-level context,

They are a dynamic-array implementation of List Interface.

So when we create an ArrayList, And we add or remove elements from the list, It automatically changes the size of the array by itself, that is what a dynamic array means.

ArrayList contains various methods for adding, removing, and retrieving elements from a List.
So let's first see how to declare an ArrayList.

import java.util.ArrayList;

public class ArrayListEx{
            public static void main(String[] args){
                ArrayList<String> names = new ArrayList<>();                     
       }
}

So in the above code, we import the ArrayList first by java.util.ArrayList and then we declare the ArrayList by ArrayList<String> names = new ArrayList<>(); which creates a list called names which is of type String.

The general syntax is:-

ArrayList<Type> list = new ArrayList<>();

Type is basically the type of values stored in the list such as Integer, Boolean, Double, etc.

Adding, Removing, and Retrieving values from the ArrayList.

To Add value into an Arraylist, we use the add() method. Let's see it by example.

import java.util.ArrayList;

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

            ArrayList<String> namesList = new ArrayList<String>();  //Creates a ArrayList of name "namesList"
            namesList.add("Tarun");   
            namesList.add("Jim");
            namesList.add("John");
            System.out.println("The List is: "+namesList);    //prints the list

           /*Output:
              The List is: [Tarun, Jim, John]
           */
}
}

We can add value in the list at a particular index, That is by mentioning the index value first and then the element next in the add method. Below is an example of that:-

// Note: Using the same list as above
      namesList.add(1,"Jake");   
//So now the ArrayList contains another value at index 1.
      System.out.println(namesList);

    //The Output is : [Tarun, Jake, Jim, John]

To retrieve a value from the ArrayList we use the get() method. To retrieve an element at index 2 in the "namesList" ArrayList we use namesList.get(2).

    System.out.println(namesList.get(2));   // Prints the element at index 2.
    // Output :  Jim

And To remove elements from an ArrayList, we use the remove() method. We can remove an element by giving the index or by the value itself as the parameter.
Let's see an example.

    namesList.remove("Jim");  //Removing the String Jim 
    namesList.remove(1);  //Removing the value at index 1
    System.out.println(namesList);

//Output : [Tarun, John]

Of course, these aren't the only methods in the ArrayList but they are the most used ones. There are many methods such as the clear() method, which removes all the elements from the list. contains() method, which checks if the given element is in the list.

If you wish to explore other methods, You can visit the official Documentation.

Hope you got a basic understanding of what an ArrayList is and how it works.

See you in the next article and until then, Happy Coding 🙂⚡️.

Arrays in Java.

Tarun Kumar J — Wed, 26 Aug 2020 08:16:33 +0000

Hello Everyone 💫!

So I mentioned I will write about Java in my previous article and I was thinking which topic should I choose, And I finally chose ** Data Structures ** in Java.

This article would help every beginner studying in Java and I hope this helps you understand Arrays in Java easily. Another reason being, It would help me get my understanding strong as well.
So let's start discussing Arrays in Java.

Arrays

An array is a data structure that stores elements of the same data type at contiguous(next to or adjacent) memory locations.

So lets first find out how to create an array.

The below code creates an array of 10 integers.

int[] numbers = new int[10];

To create an array to hold 100 names:-

String[] names = new String[100];

Another way of creating an array is by initiating it with values when you declare the array.
The code down creates an array with 5 integers and initiates it with values.

int[] number = { 8, 10, 26, 9, 96 };      // It creates an array of 5 integers.

We can also initialize an array of strings in the same way.

String[] names = { "Tarun", "Louis" , "John" };

In Java, the first index of an array starts with 0. So if the length of an array is 5 then the last element's index is 4.The elements are also called values.

Assigning and printing the elements

An element of an array is referred to by its index. In the below code we create an array of two numbers and assign values to the indices 0 and 1.

int[] numbers = new int[2];

numbers[0] = 18;
numbers[1] = 26;

System.out.println(numbers[0]);
System.out.println(numbers[1]);

NOTE: You can find the size of the array by length variable. We can get that by name of the array dot length, ie by ** numbers. length **
and If we print that It will give us the size of an array.

int[] numbers = new int[2];
System.out.println(numbers.length);   // It will print 2

If we write the index outside of an array ie bigger than the index size, We get an ArrayIndexOutOfBoundsException, ie It tells us that the array doesn't contain the given index.

String[] arrayOfNames = { "Hello" , "there"}; //The array contains only two elements ie index 0 and 1.

System.out.println(arrayOfNames[3]); //This will give us an ArrayIndexOutOfBoundsException.

Iterating over an Array

This means accessing each element of an array one by one. I'd help you understand that with an example below.

String[] names = new String[3];
names[0] = "Tarun";
names[1] = "Jonathan";
names[2] = "Vicky";

System.out.println("The length of the array is "+names.length+"."); 

//The below while loop prints every element of the array by iterating over it.
int index = 0;
while(index<names.length){
      System.out.println(names[index]);
      index = index + 1;
}

/* 

The Output of the program will be:
The length of the array is 3.
Tarun
Jonathan
Vicky

*/

The above code finds the length of the String array and prints it, And then it iterates over the array and prints out every string element one by one.

Finally, I'd like to say that If anyone wants to learn more in Java, There are free courses out there.You can choose whichever you like and start learning, The best ones I've found are :

Codecademy
GeeksForGeeks
Youtube channel - Alex Lee
Youtube channel - Programming with Mosh.

Thanks for reading! Hope you like it 🙂.

See you in the next article until then, Happy Coding ⚡️!

PS:
If you find any mistakes in the above article/blog, Please comment it out, So that I would make the edits.