tutorial AndroidSketchpad

Home tutorial

Tuesday, August 28, 2018

Dependency Injection with KOIN to Androidx Jetpack

Author : Shudipto Trafder August 28, 2018

August 28, 2018

Welcome to this post.

A few months ago google launch jetpack. This library includes some new component, like Work Manager. The problem is if you want to use dependency injection, then you can not do easily. If you heard about dependency injection then the first library coming in our mind is Dagger. But the problem is Dagger still not support androidx.

A few days ago I work with a new project, and I decide to use Work manger. But the problem arises because I am used Dagger. I search and waste a couple of hours but the solution is not in the satisfaction level. Then I decide to move to KOIN.

This is the first time I use KOIN. And the problem is gone. And I found KOIN is very handy. I don't have to write a lot of code. Just a simple line configuration. Declaring module is also very easy.
you will see that too in this post.

So let's start KOIN
First, add dependencies of KOIN

implementation 'org.koin:koin-android:0.9.3'
implementation "org.koin:koin-androidx-viewmodel:1.0.0-beta-3"

Note: Don't forget to add room, viewmodel, and livedata dependencies.

Let's Create a database.
I use room.

I skipping this part. you probably know how to create database using room. (This post is about some advanced topics).

Code snippet:
Create a table, such as WordTable

@Entity
class WordTable(
        @PrimaryKey(autoGenerate = true)
        var id: Int = 0,
        var word: String = "",
        var des: String = "",
        var bookmark: Boolean = false,
        var addByUser: Boolean = false,
        var uploaded:Boolean = false
)

Now Data Accessing object(Dao), exp: WordTableDao

@Dao
interface WordTableDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun add(table: WordTable): Long

    @Update
    fun update(table: WordTable): Int

    @Delete
    fun delete(pageTable: WordTable): Int


    @Query("Select * From WordTable")
    fun getAllList(): List<WordTable>
}

All set, create the database class.

@Database(entities = [WordTable::class], version = 1,
        exportSchema = false)
abstract class MyDatabase:RoomDatabase(){
    abstract val wordTableDao: WordTableDao
}

So our class database is ready, but still, we don't create the database. We will create the database in the KOIN module declaration time.

Now create a ViewModel class.
we need only Dao. it will provide by KOIN. We ViewModel Class as the parent class.
In the class just create a method called getData() and load data from the database and return.

class MainVM(private val wordTableDao: WordTableDao):ViewModel(){

    fun getData() = wordTableDao.getRandomData()

}

Now time for module declaration. See the code first, then I discussing code.
we have two module. The first one is dbModule

val dbModule = module {

    single {
        Room.databaseBuilder(androidContext(), MyDatabase::class.java,
                "SS").build()
    }

    single { get<MyDatabase>().wordTableDao }

}

code -
1. keyword: module, it's just a function that creating a koin module
2. To create an instance you have to use single (from this new version, in the old version, use been keyword)
3. in a single, create the database
4. another single, call get function and type MyDatabase and access the Dao.

The second module is vmModule,
Same as this module but this time use viewmodel instead of single.

val vmModule = module {
    viewModel {
        MainVM(get() as WordTableDao)
    }
}

Note: if you don't use the androidx version of KOIN then you get an error, in this module declaration

we finished all declaration. Now we are ready for using KOIN. But before using KOIN, we have to start KOIN. To start KOIN declare an application class.
and write a simple line of code-

startKoin(this, listOf(module_list)

See code-

class MyApp:Application(){

    override fun onCreate() {
        super.onCreate()
        startKoin(this, listOf(dbModule, vmModule))
    }
}

All set. Now inject the ViewModel in the Main activity.
Now hard here, just declare a variable type MainVM and use by keyword (for lazy injection) and call viewModel() function.

private val viewModel: MainVM by viewModel()

See code-

class MainActivity : AppCompatActivity() {

    private val viewModel: MainVM by viewModel()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        setSupportActionBar(toolbar)


        viewModel.getData().observe(this, Observer {
            //observe data
        })
    }

}

Now the most desired one-
we are going to inject in the worker class. Create a worker class. But this time you are injecting KOIN not supported class. Don't worry. KOIN has already built an option to solve this problem. You have to implement KoinComponent.
After that same, declare a variable and lazy injection call inject() function
val wordTableDao: WordTableDao by inject()

See the code-

class MyWorker : Worker(), KoinComponent {

    val wordTableDao: WordTableDao by inject()

    override fun doWork(): Result {

        val table = WordTable()

        wordTableDao.add(table)
        
        return Result.SUCCESS
    }


}

That's it. We are done. We finished our goal.

If you check all of those code in Gist also. Click here.

So by using KOIN, you can easily inject on the Androidx component. But for the dagger case, it's not so easy as this.

So, it's your choice, to use dagger or koin.

Thanks for reading.
Hope this articles help you a lot.

Happy coding

By Shudipto Trafder

Dart: Json Parsing

dart tutorial

Author : Shudipto Trafder July 14, 2018

July 14, 2018

Welcome to this post.

In this post, I am going to cover about JSON parsing in Dart.

What I will do on this project?
1. Get data from Rest API.
2. Parse the JSON Data

Let's Start-

First, take look at the data source. I will get the data from this link.

https://swapi.co/api/starships/

JSON sample.
This response you will find that link

{
    "count": 37, 
    "next": "https://swapi.co/api/starships/?page=2", 
    "previous": null, 
    "results": [
        {
            "name": "Executor", 
            "model": "Executor-class star dreadnought", 
            "manufacturer": "Kuat Drive Yards, Fondor Shipyards", 
            "cost_in_credits": "1143350000", 
            "length": "19000", 
            "max_atmosphering_speed": "n/a", 
            "crew": "279144", 
            "passengers": "38000", 
            "cargo_capacity": "250000000", 
            "consumables": "6 years", 
            "hyperdrive_rating": "2.0", 
            "MGLT": "40", 
            "starship_class": "Star dreadnought", 
            "pilots": [], 
            "films": [
                "https://swapi.co/api/films/2/", 
                "https://swapi.co/api/films/3/"
            ], 
            "created": "2014-12-15T12:31:42.547000Z", 
            "edited": "2017-04-19T10:56:06.685592Z", 
            "url": "https://swapi.co/api/starships/15/"
        },
      ...
    ]
}

This is the json Sample. I just take only results data. It's a collection of the result. SO create the model class first.

Model Class

We have so many things on the JSON result.
so you have to create all the field.
Note: If you don't need some field, simply skip those.

  final String name;
  final String model;
  final String manufacturer;
  final String cost_in_credits;
  final String length;
  final String max_atmosphering_speed;
  final String crew;
  final String passengers;
  final String cargo_capacity;
  final String consumables;
  final String hyperdrive_rating;
  final String MGLT;
  final String starship_class;
  final List films;
  final List pilots;
  final String created;
  final String edited;
  final String url;

Note: here films and pilots are Lists, not String.

Now create the constructor-

RestModel(
      {this.name,
      this.model,
      this.manufacturer,
      this.cost_in_credits,
      this.length,
      this.max_atmosphering_speed,
      this.crew,
      this.passengers,
      this.cargo_capacity,
      this.consumables,
      this.hyperdrive_rating,
      this.MGLT,
      this.starship_class,
      this.films,
      this.pilots,
      this.created,
      this.edited,
      this.url});

Now create a factory method-
take a map and return a new RestModel.

factory RestModel.fromJson(Map<String, dynamic> json) {
      return new RestModel(
          name: json["name"] as String,
          model: json["model"] as String,
          manufacturer: json["manufacturer"] as String,
          cost_in_credits: json["cost_in_credits"] as String,
          max_atmosphering_speed: json["max_atmosphering_speed"] as String,
          crew: json["crew"] as String,
          passengers: json["passengers"] as String,
          cargo_capacity: json["cargo_capacity"] as String,
          consumables: json["consumables"] as String,
          hyperdrive_rating: json["hyperdrive_rating"] as String,
          MGLT: json["MGLT"] as String,
          starship_class: json["starship_class"] as String,
          films: json["films"] as List,
          pilots: json["pilots"] as List,
          created: json["created"] as String,
          edited: json["edited"] as String,
          url: json["url"] as String,
      );
  }

See the full class code of RestModel in Github.

Parse JSON

Now time for getting data from the internet-
Create the main function

void main() async{
}

Save the link in a String.

final link = "https://swapi.co/api/starships/";

Create a new list. And the subtype of this list will be RestModel

List<RestModel> list = new List();

import HTTP package and make a request

var res = await http.get(Uri.encodeFull(link), headers: {"Accept": "application/json"});

next steps-
1. if the response code is 200 then the response is successful
2. decode the response code with the help of json class that include in the package 'dart:convert'
3. after decode it return a map.
4. take only 'result' from the map and save in a new variable.
5. loop this list and for every entry and return a new RestModel

See the code-

if (res.statusCode == 200) {
    var data = json.decode(res.body);
    var rest = data["results"] as List;
    for (var json in rest) {
	var model = new RestModel.fromJson(json);
	list.add(model);
	}
}

print the list

print("List Size: ${list.length}");

Output:

List Size: 10

Full code-

import 'package:http/http.dart' as http;
import 'dart:convert';
import 'RestModel.dart';


void main() async{

	final link = "https://swapi.co/api/starships/";

	List<RestModel> list = new List();

	var res = await http
			.get(Uri.encodeFull(link), headers: {"Accept": "application/json"});

	if (res.statusCode == 200) {
		var data = json.decode(res.body);
		var rest = data["results"] as List;
		for (var json in rest) {
			var model = new RestModel.fromJson(json);
			list.add(model);
		}
		print("List Size: ${list.length}");
	}
}

That's it.
If you have any quires then use the comment section. Feel free to put comments.
you can easily parse json.
Happy Coding.

By Shudipto Trafder

Searching Algorithms: Linear Search

data-structure_algorithm kotlin tutorial

Author : Shudipto Trafder June 30, 2018

June 30, 2018

welcome to this post.

Today I am going to talk about Searching Algorithms.
In this tutorial, I will cover 3 Searching Algorithms

Linear Search
Binary Search
Interpolation Search

So Let start with Linear Search

Linear Search:
From the name, you can get an idea. It searches linearly. One by one.
This algorithm starts the search from the beginning and continues until finding the
desired search index.

For example,
Assume an array from 0 to 10. and you are searching for10. so what will happen?

First, it checks
if 10 is equal to 0 => nope, then
if 10 is equal to 1 => nope, then
.................................................
continue this
if 10 is equal to 10 => yes.

Now it's finding the number.

So it starts from the beginning and continues until it's done.

Let's jump into the code
Create a class and it's constructor take the array size.

class DataK(size:int){
}

create two variable,

one is an array that holds the data set
other is numberOfTry: an int type variable that will give information,

how many tries need to find the value.

val array: Array<Int> = Array(size,{i -> i})
var numberOfTry = 0

Now Just run a for loop from 1 to the given size and put the data into the array.

init {
    for (i in 1 until size){
         array[i-1] = i
     }
}

The complete Class code in GitHub
Note: This class is used in every searching Algorithms.

Now create the main method and initialize the data and give the size 100000.

val data = DataK(100000)

we want to find 9999

val search = 99999

Set the initial number of try to zero

var numberOfTry = 0

And the last declare a new variable, named it to result and this will hold the result.
everything is set, now I am ready for the main action

To search run a for loop from 0 to the data size and compare the index value with our searching number if find the break the loop and at the end increase the number of tries.

That's is the idea.
See code

for (i in 0 until (data.array.size - 1)) {
    val number = data.array[i]
    if (number == search) {
        result = number as Int
        break
    }

    numberOfTry++
}

Now result:
from the linear search if the result is -1 then the value does not exist and that means data is not found.

so, we print the number of tries to see it actually search or not if the result is not -1 then
we find the data.
print number of trials, to see how much try need to find our data

if (result != -1)
    println("Data found on: $numberOfTry")
else
    println("Data not found try: $numberOfTry")

Output:

Data found on: 99998

so, it takes 99998 try to find 99999.

Check the full source code in Github

Note: If you are from java. Check this on Github.

That is all about the Linear search algorithm.

It is a very simple algorithm. It is not widely used.

we will compare all of the searching algorithms after completing all of those.

In the next part, I will discuss Binary search.

Thank you for reading.
If you have any suggestion or any queries use the comment section.

Happy coding

By Shudipto Trafder

Dart: Variable

dart tutorial

Author : Shudipto Trafder June 20, 2018

June 20, 2018

Welcome to the series post.
The is the first post about Dart

From today I am starting Dart language tutorial.
I already posted a brief introduction about dart and I also try to answer why you choose the dart programming. Check this Dart Introduction

In the previous post, I write about some important concept about dart. Before starting I recommend for taking a look.

Main method:
First, see the code:

void main(List<String> lists) {
}

In the code, you see that the parameter of the main method is a list of string. I think this is as usual of other programming languages. But most interesting part is that you can also create the main method without this parameter.

void main() {
}

So, That's so simple.
Now write a hello world program, to print something on the console, use print() function.

void main(List<String> lists) {
  print("Hello world");
}

Output:

Hello world

That's is the hello world program.
Now you can modify this program as yourself.

Variables:
Var:
To declare any variable you can use var keyword.

var v = 10;

you can put any type of data, like, Int, Double, String or anything

var string = "String";
var int = 10;
var double  = 30.0;
var boolean = false;

If you don't specify the value by default it considers as null

var value; //value is null

dynamic
You can use another keyword available name dynamic.

dynamic s = "s";

this dynamic type of variables can also hold any type of data, like var

dynamic string = "String";
dynamic int = 10;
dynamic double  = 30.0;
dynamic boolean = false;

You can also specify the data type of the data

String value;
int number;
double number2;
bool status;

Multiple variables:
You can also initialize multiple variables at the same time.

var a,b,c,d,e;

also, you can specify the value

var a1 = 10,b2 = 20,c2 = 30;

final and const:
If you need a variable that's value is not change after the declaration, use final keyword

final name = "Shudipto";

also the option for specific variables

final String type = "Student"; //explicitly

If you need runtime constant variables, then use const keyword

const value = 1000;

specific variable

const String data = "data:$value";

Lest see an example-

var foo = const [];
final bar = const [];
const baz = const [];

Here, [] create an empty list. and const[] creates an empty immutable list, it's denoted as (EIL)
In the above code,
foo => foo is currently an EIL.
bar => bar will always be an EIL.
baz => baz is a compile-time constant EIL.

It is possible to change the value of a non-final, non-const variable,
even if it used to have a const value.

foo = [];

It is not possible to change the value of a final or const variable.

// bar = []; // Unhandled exception.
// baz = []; // Unhandled exception.

that's it of the variable.

Comments:
single line comment: as usual like other languages. use '//'

//single line comment

multiline comment:

/*
* multi line comment
*/

That's the ending of today post.
Today in this article, I covered Hello world program and variable and Comments.

Thank you for reading.

Happy coding.

By Shudipto Trafder

Dart: Introduction

dart tutorial

Author : Shudipto Trafder June 03, 2018

June 03, 2018

Welcome to this post.
Recently I start to learn Dart programming language.

From today, I will post about dart programming language.

Src: Dartlang

What is dart?
Dart is an object-oriented programming language, developed by Google. It is used to build web, server, and mobile applications(Flutter).

Before Learning darts, some important concept, we have to understand.
Concepts:

Everything in darts is object and object is an instance of Class.
Even variable, function and null are object too.
Type annotation is optional because it is strongly typed. So we can special type or dynamic
Dart support generic type (for example a list of integers: List
Top level function is supported, we also used functions that tied to an object or a class. And another cool thing is it supports nested function
It also supports top-level variable and tied variables. The instance variable, sometimes known as fields or properties.
Like Java, Dart has no keyword like public, protected, private, If variables start with underscore (_) that consider as package private.
Dart tools can report only two kinds of problems. The first one is warnings that just indications of your code might not work, but they don’t prevent your program from executing. The second one is errors, it can be either compile-time or run-time and finally, it prevents the code from executing at all

That's the concept of dart. Now come where we can use this language.
Application of Dart
Dart is a scalable language. SO we write a simple script or full-featured app. we use this mainly 3 areas. Like-

Flutter - we can write a mobile app, that will run both Android and Ios.
Web - we can write an app that can run in modern web browser.
Dart VM - we can write command line app or server.

I think that's enough introduction about dart. So we can start learning.
In this blog, I will try to cover the basic of Dart.

So, Let's create a list of learning path of Dart programming Language.

What I will cover in this series tutorial -

Tutorial

Hello word
Variable
Data type
Function
Operators
String operation
Collection
Control flow statement
Classes
Methods
Enumerated types
Generics
Library and visibility
Asynchrony support

This is the learning path about dart. I will go through every topic.

That's the deal.
Stay connected with my blog.

By Shudipto Trafder

Kotlin Data Structure: Circular Queue

data-structure_algorithm kotlin kotlin-advance tutorial

Author : Shudipto Trafder June 02, 2018

June 02, 2018

Welcome to this post.
In this post, we are going to learn about the Circular queue.

If you don't know the queue data structure, please check this post Queue.

In the previous post of Queue, I discuss the problem about the queue. So today we learn about the circular queue.

In queue, to data in the queue, the method is called enqueue()
and to get data from the queue, the method is dequeue()

Let's jump in the programming:

circular queue

In the above picture, you can see that data inserted in the back or last position and then the position move one row. and the same thing happens when we access data.
So we have to track

Top position
Last position

First, create a class with a constructor. In the constructor take an int type data. It will use for initializing the circular queue with size.

class CircularQueueK(size: Int){
}

Create an array with size and also create 2 variable that mentions above.

private val list:Array<Any> = Array(size,{ i: Int -> i })
private var head = 0
private var tail = 0

we have to implement 2 additional method

isFull() -> this will return true if the queue is full, so we don't allow to insert more data.
isEmpty() -> this will return true if the queue is empty, so we don't allow dequeue the data.

Let's implement those-

fun isFull() = (tail + 1) % list.size == head
fun isEmpty() = head == tail

Code review of isFull():
In this method, we increase of tail with one the modules with list size and if the result is same as head then it is full. For example, At first, the head is 0, so insert data and tail are increasing, assume that our list size is 5, so at the 4 index it will be filled and the tail is now 4.
Now, when this method is called then first increase tail, and modulus with the list size. Increase the tail to 5 and list size is 5, then the modulus is zero, and it is equal to the head. So it's now empty. because it's come back to the start position.

enqueue():
First, check the circular queue is full or not, If full the return.
Insert data in the list at the tail position
Insert the value in the tail as we did on the if full method

fun enqueue(value: Any){
    if (isFull()){
        return
    }

    list[tail] = value
    tail = (tail+1) % list.size
}

dequeue():
First, check the circular queue is empty or not. if empty return
Get data from the head position
assign new value of the read same as enqueue()

fun dequeue():Any{

    var a:Any = ""

    if (!isEmpty()){
        a = list[head]
        head = (head +1) % list.size
    }

    return a
}

Code analysis:

head = (head +1) % list.size

what is actually happening under the hood?
For example, assume the list size is 5 and head position is now 4.
Now if we want to access data from the list then it is the last position of the list. so we don't access next data.
This is the main problem in the queue. But in the circular queue head and tail position is circled from zero to list position.
so now our goal is to initialize head position to again start point.
If the head is 4 then with increase 1 and modules with the list size, and the result is zero.
So, it's back again.
In the circular queue, at least one position is to remain blank for this purpose.

Ok, one more extra method to go-

fun iterator() = list.withIndex()

Now time for testing
Create the main method-

fun main(args: Array<String>) {
}

Create an instance of the circular queue.

val queue = CircularQueueK(5)

enqueue():
run a while loop until the circular queue is full

var s = 0

while (!queue.isFull()){
    queue.enqueue(s)
    s++
}

Check the list:
run a for loop with the help of iterator() function that we created earlier.

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Output:

Index:0 and value:0
Index:1 and value:1
Index:2 and value:2
Index:3 and value:3
Index:4 and value:4

dequeue():
just call dequeue method for 3 times and print the value

println("\nGet value1:${queue.dequeue()}")
println("Get value2:${queue.dequeue()}")
println("Get value3:${queue.dequeue()}")

Output:

Get value1:0
Get value2:1
Get value3:2

now enqueue() again:

var d = 10
while (!queue.isFull()){
     queue.enqueue(d)
     d++
}

Compare this list with the previous result-
print all data from the circular queue

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Output:

Index:0 and value:11
Index:1 and value:12
Index:2 and value:2
Index:3 and value:3
Index:4 and value:10

Result analysis:
If you compare this output with the previous output you will see the changes.
we call dequeue() function for 3times, that means we get 3 data from the circular queue. So 3 position is empty now.
We enqueue() again, and only 3 data is inserted on the position of the array is 4, 1, 2 and now the head position is 3. so circulated.

That's the ending of the circular queue()
Thank you, for reading.
Happy coding.

By Shudipto Trafder

Kotlin Data Structure: Queue

data-structure_algorithm kotlin kotlin-advance tutorial

Author : Shudipto Trafder June 01, 2018

June 01, 2018

Welcome to this post.
This is the second post about data Structure.
In this post, we are going to learn about Queue data structure.

In the previous post, we discuss Stack. Stack is FILO type data structure.
But Queue is the FIFO data structure, that means the data enter first that also come first.

Src: Wikipedia

In queue, to data in the queue, the method is called enqueue()
and to get data from queue, the method is dequeue()

Implementation of Queue:
In the above picture, you can see that data inserted in the back or last position and then the position move one row. and the same thing happens when we access data.
So we have to track

Top position
Last position

Create an array of Int' and also create 2 variable that mentions above.

var ints = IntArray(10)
var head = 0
var tail = 0

Methods:
enqueue():
insert data in the tail position and increase the tail

fun enqueue(n: Int) {
    ints[tail] = n
    tail += 1
    println("Input:" + n)
}

dequeue():
get data from head position index from the array and increase the head

fun dequeue(): Int {
    val n = ints[head]
    head += 1
    return n
}

Empty check:
if head and tail is same then the stack is empty

val isEmpty: Boolean
        get() = head == tail

Now time for access data:
First, create the main method:

fun main(arg: Array<String>) {
}

enqueue():
just run a for loop from 0 to 10 and insert data

for (i in 0..9) {
     enqueue(i)
}

Output:

Input:0
Input:1
Input:2
Input:3
Input:4
Input:5
Input:6
Input:7
Input:8
Input:9

works fine.
dequeue()
run a while loop until the queue is empty

while (!isEmpty) {
    println("value: " + dequeue())
}

Output:

value: 0
value: 1
value: 2
value: 3
value: 4
value: 5
value: 6
value: 7
value: 8
value: 9

It's work fine.
That's is the basic queue implementation.
You can check this out on Github

Discussion about queue:
The uses of the basic queue are not huge. It has a very limited use.
Because it wastes memory.
For example, if the queue has the capacity of 100. Then at the beginning data inserted from zero, when we access data from one we can get that data from the zero position. After the head is also increased and the tail already increased. Imagine by this way at 99 position data is filled and we access data from the 99 potions. If we want to insert new data into the queue it shows you a warning, "hey! I am full, I can not take any new data". But already the previous position is empty and there is no way to insert new data in the queue. we can use the previous position. But it allocates the memory. This is obviously the waste of memory. see the picture for the more clear concept.

Queue Data structure

To fix this problem we use the circular queue

Circular Queue

In circular queue top position and the last position move around a circle. I will discuss circular queue in the next post.

Until then, stay happy and keep practicing.
Thank you for reading this post.
Happy coding

By Shudipto Trafder

Kotlin Data Structure: Stack

data-structure_algorithm kotlin kotlin-advance tutorial

Author : Shudipto Trafder May 29, 2018

May 29, 2018

Welcome to this post.
This is going to be a series post about data structure and algorithm, In this series, I use kotlin as a default language.

Let's start with stack data structure-

Stack is a simple data structure.
The implementation of this data structure is also called LIFO that means Last in Fast out.
Basically, in this data structure, the last data will come in first.

Src: Wikipedia

In this picture, the First A block moves into C. Now if we want to get a block from C then we must take the green block first that insert in the last. And this is the basic concept of Stack.

You check Wikipedia for more.

Now come in programming-

To put data in Stack there is a function called push()

and to access data called pop() and this function also removes the first element of Stack.

Src: Wikipedia

To implement sack we always think about the top position. For example, after a successful push top position will change and also in the pop operation.

So, create a class, (you can make an inner class) and create two variable,

one is for top position
other is a list to store data.

we are using kotlin so mutable list will be perfect.

initialize top as -1 and an empty list

class Stack<T> {
    private var top = -1
    private val array:MutableList<T> = mutableListOf()
}

push() function
now our top position is -1. so in the push method, we just increase the top position. Just add plus one in every push. and insert data in the array at this index.

fun push(value: T) {
    top += 1
    array.add(top,value)
}

pop() function:

when we create the class we initialize top position as -1. basically, array stary from zero indexes. so -1 index does not exist. so first check the value of the top position. if the position is -1 the stack has no data yet. If you called pop() function you are trying to get data from the empty stack. For this case, if the stack is empty we throw an exception.

if (top == -1) {
    throw Exception("Stack is empty")
}

now take the value from array and array index will be top value. And finally, reduce the top position.

fun pop(): T {

    if (top == -1) {
         throw Exception("Stack is empty")
    }

    val value = array[top]
    top -= 1
    return value
}

now create a variable that will show the length of this stack. we use get method of kotlin.
If the top is -1 then the length will be 0 and is not then length will be top + 1

val length:Int get() {
     return if (top == -1) 0
     else top + 1
}

Now time for put data and access data from this stack

create the main function-

fun main(args: Array<String>) {
}

create an instance of stack and type will be Int

val stack = Stack<Int>()

push():
run a for loop and the number range will be 0 to 10. And insert the date in the stack

for (i in 0 until 10){
    stack.push(i)
}

Now print the length of Stack-

println("Stack length:${stack.length}")

Output:

Stack length:10

so the data inserted successfully. Now get the data

pop()
we run a while loop until the stack length is zero

while (stack.length > 0){
    println("Stack: value:${stack.pop()} length:${stack.length}")
}

Output:

Stack: value:9 length:9
Stack: value:8 length:8
Stack: value:7 length:7
Stack: value:6 length:6
Stack: value:5 length:5
Stack: value:4 length:4
Stack: value:3 length:3
Stack: value:2 length:2
Stack: value:1 length:1
Stack: value:0 length:0

see the first value is 9 and but we start to insert data from 0. We find zero in the last.
at the last, the value is zero and the length is zero.
So now our stack is zero.

If we try to get data from stack then see what will happen-

println("Stack ${stack.pop()}")

Output:

Exception in thread "main" java.lang.Exception: Stack is empty
    at dataStructure.stack.Stack.pop(StackDemo.kt:33)
    at dataStructure.stack.StackDemoKt.main(StackDemo.kt:18)

we will get an exception.

That's it, we finished the implementation of stack and do push and pop operation.

In case you miss something, check the full code on Github

Thank you very much for reading. Hope this will help you.
Keep practicing

Happy coding

By Shudipto Trafder

Subscribe to: Posts ( Atom )

AndroidSketchpad

Tuesday, August 28, 2018

Dependency Injection with KOIN to Androidx Jetpack

Saturday, July 14, 2018

Dart: Json Parsing

Saturday, June 30, 2018

Searching Algorithms: Linear Search

Wednesday, June 20, 2018

Dart: Variable

Sunday, June 3, 2018

Dart: Introduction

Saturday, June 2, 2018

Kotlin Data Structure: Circular Queue

Friday, June 1, 2018

Kotlin Data Structure: Queue

Tuesday, May 29, 2018

Kotlin Data Structure: Stack

Find me on Social Media:

Popular Posts

Featured Post

Kotlin Series

All labels

Blog Archive

Total Blog Views

Recent posts