Android Application හදමු - Introduction Part III

If you missed the very first tutorial please visit this link - Android Tutorial Part I
If you missed the second  tutorial please visit this link  - Android Tutorial Part II

In this part we are trying to familiar you with Emulator creating and Running the created application On the Emulator

 දැන් ඔයාලා හදාගත්ත Android Application එක run කරන විදිය බලමු.ඒකට අපිට emulator එකක් create කරගන්න වෙනවා. පහත රූපයේ පරිදි Android Virtual Device Manager open කරගන්න.
 නැත්නම් මේ විදියට open කරගන්න

Tools->Android->AVD Manager

 දැන් new button එක click කරන්න එවිට පහත window එක ලැබෙයි

 Give any name to AVD Name then select your most interested and preffered Device as the emulator. Target means that the Operating System contain in the Device . Select Any skin you need and set RAM to 512 and SD card size to 100. These are the normal settings we need to configure to run our application .
Then Press Ok

දැන් ඔයාලට දකින්න පුලුවන් ඔයාලා හදපු Device එක

 දැන් මෙහෙමයි අපිට පුලුවන් ආකාර දෙකකට මෙම emulator එක run කරන්න .මෙහිදී මම භාවිතා කරන්නේ වඩාත් කාර්යක්ෂම විදියයි.

 
click on the Start Button. Then you will pop up a window like below

 No need to do any changes and click on the Launch button

Then you will see below window and wait for untill progress bar reach the end

දැන් ඔබට පහත window එක දකින්නට ලැබේවි.

තිරය මත Android ලෙස පවතිනුයේ තවමත් emulator එක load වෙන බැවිනි.

පහත තිරය එනතෙක් සිටින්න.

Now you emulator has fully loaded and it is ready to run you applications . So you need to go back to the Android project view and Click Run button which appear in green color in the top center .

After you click run it will popup below window and you need to press ok

It's saying you have a emulator already started and you can you that emulator to run you application

දැන් ඔයාලට Android Project එකේ වෙනස්කම් සිදුවෙනවා දකින්න පුලුවන් වේවි.

මෙම process එක සිදුවුනාට පස්සෙ ඔයාගෙ emulator එකේ හදපු app එක ‍run වෙයි.

ඉතින් හරි ලේසියි මේ විදියට emulator එක හදන් app එක run කරගන්න.
මතකද මන් කලින් කිව්වා මං emulator එක run කරන්න use කරන්නෙ කාර්යක්ෂම විදිය කියල‍ා. දැන් ඔයාලට හැමවෙලේම මුල ඉදන් emulator එක run කරන්න ඒන නැහැ. කරන්න තියන වෙනස් කම් code එකේ කරලා run button එක press කරාම ඉක්මනින්ම emulator එකේ app එක run වෙනවා.

අපි ඊලග tutorial වලින් බලමු code කරලා button click event එකක් හදා ගන්න විදිය.
ඔබට මේ සම්බන්දව ගැටලු තිබේනම් ඒවි ඉදිරිපත් කරන්න.

Android Application හදමු - Introduction Part II

If you missed the very first tutorial please visit this link - Android Tutorial Part I

දැන් කට්ටියම Android Studio Install කරගෙන ඇති කියලා මං හිතනවා.ඔයාලගෙ පහසුවට මම steps by steps Images විදියට කියලා දෙන්නම්.

1. ඉස්‍සලම New Project ගිහින් ඔයා හදන App එකේ නම දෙන්න

2.ඊට පස්සෙ App එකේ icon එකේ size එක හදාගන්න

3. දැන් හදන App එක Blank Activity කියලා දෙන්න

4.Main Activity එකට කැමති නමක්. දීලා next යන්න

5.දැන් මේ වගෙ Window එකක් එයි.

6.ඒකෙ අපි දැන් configure කරපු settings වලට අදාල view එක ගන්න right side එකේ පේන path එක expand කරන්න. එතකොට designing view එකට අදාල xml file එක open වෙයි.

දැන් මේ window එකේ hello world කියන text එකේ color එක වෙනස් කරමු අපි
<TextView තැන android:textColor="@android:color/holo_blue_dark" කියලා type කරන්න
ඔයාලගෙ පහසුවට CTRL+SPACE use කරලා suggestions ගන්න

දැන් හොදට බලන්න text එක blue පාටින් පෙනෙවි.

Noe lets move to design view click on the bottom tab Design and go to design view

After that we will try to add a button for our app,

දැන් අපි button එක add කරමු, Phone view එ‍කට right side එකේ තියන palette එකෙන් button එක Drag and Drop කරන්න. දැන් නැවතත් Text View එකට යන්න (Text view is on the Bottom right of the palette)

දැන් දකින්න පුලුවන් වේවි
<Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="New Button"
        android:id="@+id/button"
        android:layout_marginTop="87dp"
        android:layout_below="@+id/textView"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true" />
කියලා.....

ඒකෙත් කැමති විදියකට text and color change කරන්න පුලුවන්
 android:text="Submit"

ඔය විදියට Try කරලා interface එක පුරුදු වෙන්න .....


අපි ඊලග tutorial එකෙන් බලමු App එක run කරන්නයි Java File එක edit කරලා button එක press කරාම message එකක් එන විදියයි. මං හිතනව මුල ඉදන්ම android පටන් ගන්න අයට මේ tutorial එක ගොඩක් වැදගත් වෙයි කියලා.

ප්‍රශ්න තියනවනම් comment කරන්න ඊලග tuto එකෙන් හමුවෙමු .

Data Structures and Algorithms with Java - Part I (Data Structures)

#DSA  ගැන Google එකේ search කරලම එපා වෙලාද? තමන් හොයපු හරි උත්තරේ තාම හම්බුන් නැද්ද? මෙන්න සරලව ගවේෂකගෙන් DSA ඉගන ගන්න.

ඔන්න ගවේෂක DSA Javaත් එක්ක ප‍ටන් ගන්නවා කට්ටියටම මුල ඉදන් සරලව

මොකක්ද DSA කියන්නෙ?

There are some sub topics under DSA .Let’s see what are they and I will describe them one by one to you

Actually what is an Algorithm?

In a simple way Algorithm is a set of steps to achieve a goal in a particular order.

ඇත්තටම ඇල්ගොරිදම් එකකින් කරන්න පුලුවන් මොනාද?

**********

ඉස්සෙලම බලමු මොනද මේ problem solving steps කියලා

1. Identifying the problem

2. Understanding

3. Identifying alternative solutions

4. Select best solution

5. List down the instruction to solve the problem

6. Checking the result as it was suggested

Let’s categorize the data structures,

We are come with several DSA such as Array, Stack, Queue, Linked List, and Tree.

Array

In array ,

·       Random Access

·       Both can limited and not limited size

Array Implementation,

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package arraystack;

/**
 *
 * @author lahiru dananjaya
 */
public class array {
    
    
    
    
    
    public static void main(String[] args) {
        /**
         * can add any number of elements
         */
        int array_unlimited[]={2,1,6,4,8,7,8,7,8}; 
        
        for (int i = 0; i < array_unlimited.length; i++) {
            System.out.println("Index ["+i+"] is "+array_unlimited[i]);
        }
        /****************************************************************/
        System.out.println();
        /**
         * can add limited number of elements
         */
        
        int array_limited []=new int[4];
        array_limited[0]=4;
        array_limited[1]=6;
        array_limited[2]=5;
        array_limited[3]=1;
    
        for (int i = 0; i < array_limited.length; i++) {
            System.out.println("Index ["+i+"] is "+array_limited[i]);
        }
        
    }
}

         

Stack

          In stack ,

·       Using LIFO(Last In First Out) method

·       Can access only top index

·       Based on array structure

·       Push-insertion

·       Pop-deletion

·       Peek-reading top value

·       IsEmpty/IsFull- check whether empty or full

·       Can use for Recursion, Reverse a word and for Balance parenthesis

Stack Implementation,

package queue;

import java.util.Scanner;

/**
 *
 * @author lahiru dananjaya
 */
public class Stack {
    
    private int top=-1;
    private int size;
    private int pop;
    private char data[];
    
    public void push(char val){
        this.data[++top]=val;
    }
    
    public Stack(int  size){
        this.size=size;
        this.data=new char[size];
    }
    
    public char pop(){
        return data[top--];
     
    }
    
    public boolean isFull(){
        return (top==size-1);
    }
    
    public boolean isEmpty(){
        return (top==-1);
    }
    
    public static void main(String[] args) {
       Scanner c=new Scanner(System.in);
       System.out.println("Enter word");
       
        
        String test=c.next();
        
        Stack s=new Stack(test.length());
        for (int i = 0; i < test.length(); i++) {
           s.push(test.charAt(i));
        }
        
        for (int i = 0; i < test.length(); i++) {
           
            System.out.println(s.pop());
        }
        
                
    }
  
}

Queue

·       First In First Out

Queue Implementation,

import java.util.Scanner;

/**
 *
 * @author lahiru dananjaya
 */
public class Queue {

    private int maxsize;
    private int[] data;
    private int rear=-1;
    private int front=0;
    private int nItem=0;
  /**
   * 
   * @return 
   */
    Queue(int size){
        this.maxsize=size;
        data=new int[maxsize];
    }
       
    public boolean isFull(){
        
        if(nItem==maxsize){
            return true;
        }else{
            return false;
        }
    }
    
    public boolean isEmpty(){
        if(nItem==0){
            return true;
        }else{
            return false;
        }
    }
    
    public void insert(int data){
        this.data[++rear]=data;
        nItem++;
    }
    
    public int remove(){
        nItem--;
        return data[front++];
    }
    
    
    
    public static void main(String[] args) {
        System.out.println("Enter Queue size");
        Scanner s=new Scanner(System.in);
        Queue a=new Queue(s.nextInt());
        
        while(!a.isFull()){
            System.out.println("Enter Data :");
            a.insert(s.nextInt());
        }
        
        while(!a.isEmpty()){
            System.out.println(a.remove());
        }
    }
}

Linked List

·      Ordered sequence

·       No random access

·       Forward and Backward

Linked List Implementation(Refere Code),

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package arraystack;

/**
 *
 * @author lahiru dananjaya
 * This is a referenced code for linked list
 */
class Node {
    Node next;
    int num;
    public Node(int val) {
        num = val;
        next = null;
    }
}

class LinkedList {

    private Node head = null;

    public void append(int val) {
        Node lastNode = getLastNode();
        if (lastNode == null) {
            head = new Node(val);
        } else {
            lastNode.next = new Node(val);
        }
    }

    public void delete(int val) {
        if(head == null){
            return;
        }

        Node prevNode = null;
        Node currNode = head;
        while (currNode != null && currNode.num != val) {
            prevNode = currNode;
            currNode = currNode.next;
        }
        if(prevNode == null){
            head = head.next;
            return;
        }
        if (currNode == null) {
            System.out.println("A node with that value does not exist.");
            return;
        }
        prevNode.next = currNode.next;
    }

    public void print() {
        System.out.println("");
        if(head == null){
            System.out.print("EMPTY");
            return;
        }
        Node tmpNode = head;
        while (tmpNode != null) {
            System.out.print(tmpNode.num + " -> ");
            tmpNode = tmpNode.next;
        }
    }

    private Node getLastNode() {
        if (head == null) {
            return null;
        }
        Node tmpNode = head;
        while (tmpNode.next != null) {
            tmpNode = tmpNode.next;
        }
        return tmpNode;
    }

    public static void main(String[] args) {
        LinkedList myList = new LinkedList();
        myList.print();
        myList.append(35);
        myList.append(33);
        myList.print();
        myList.delete(33);
        myList.delete(35);
        myList.delete(35);
        myList.print();
    }
}