Lesson: Java Collection Api

Problems with simple arrays:

package org.example;

public class Main {
    public static void main(String[] args) {
        String[] students = {"One", "Two", "Three", "Four"};
        for (String s : students) {
            System.out.println(s);
        }

        // yenisi elave olundu
        String[] second = new String[students.length + 1];
        for (int i = 0; i < students.length; i++) {
            second[i] = students[i];
        }
        second[second.length - 1] = "Five";
        students = second;
        for (String s : students) {
            System.out.println(s);
        }

        // biri cixdi
        students[2] = null;
        String[] third = new String[students.length - 1];
        for (int i = 0, j = 0; i < students.length; i++) {
            if (students[i] != null) {
                third[j] = students[i];
                j++;
            }
        }
        students = third;
        for (String s : students) {
            System.out.println(s);
        }
    }
}


1. Writing our own ArrayList

package org.example;

import java.util.Arrays;

public class MyArrayList<T> {
    private T[] array = (T[]) new Object[10];
    private int size = 0;

    public void add(T element) {
        check();
        array[size++] = element;
    }

    public void check() {
        if (size == array.length) {
            T[] newArray = (T[]) new Object[array.length + array.length / 2];
            for (int i = 0; i < array.length; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
    }

    public void remove(int index) {
        if (index >= 0 && index < size) {
            for (int i = index; i < size - 1; i++) {
                array[i] = array[i + 1];
            }
            size--;
        }
    }

    public void remove(T element) {
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (element.equals(array[i])) {
                index = i;
                break;
            }
        }
        if (index != -1) remove(index);
    }

    public int getSize() {
        return size;
    }

    public T get(int index) {
        if (index >= 0 && index < size)
            return array[index];
        else return null;
    }

    @Override
    public String toString() {
        return "MyArrayList{" +
                "array=" + Arrays.toString(array) +
                '}';
    }
}


2. Writing our own LinkedList

package org.example.linkedList;

public interface Linked<E> {

    void addLast(E e);

    void addFirst(E e);

    void delete(int counter);

    int size();

    E getElementByIndex(int counter);
}
package org.example.linkedList;

import java.util.Iterator;

public interface ReverseIterator<E> {
    Iterator<E> reverseIterator();
}
package org.example.linkedList;

import java.util.Iterator;

public class MyLinkedList<E> implements Linked<E>, Iterable<E>, ReverseIterator<E> {

    private class Node<E> {
        private E currentElement;
        private Node<E> nextElement;
        private Node<E> prevElement;

        public Node(E currentElement, Node<E> nextElement, Node<E> lastElement) {
            this.currentElement = currentElement;
            this.nextElement = nextElement;
            this.prevElement = lastElement;
        }

        public E getCurrentElement() {
            return currentElement;
        }

        public void setCurrentElement(E currentElement) {
            this.currentElement = currentElement;
        }

        public Node<E> getNextElement() {
            return nextElement;
        }

        public void setNextElement(Node<E> nextElement) {
            this.nextElement = nextElement;
        }

        public Node<E> getPrevElement() {
            return prevElement;
        }

        public void setPrevElement(Node<E> prevElement) {
            this.prevElement = prevElement;
        }
    }

    private Node<E> firstNode;
    private Node<E> lastNode;
    private int size;

    public Node<E> getFirstNode() {
        return firstNode;
    }

    public MyLinkedList() {
        lastNode = new Node<>(null, null, firstNode);
        firstNode = new Node<>(null, lastNode, null);
    }

    @Override
    public void addLast(E e) {
        Node<E> last = lastNode;
        last.setCurrentElement(e);
        lastNode = new Node<>(null, null, last);
        last.setNextElement(lastNode);
        size++;
    }

    @Override
    public void addFirst(E e) {
        Node<E> first = firstNode;
        first.setCurrentElement(e);
        firstNode = new Node<>(null, first, null);
        first.setPrevElement(firstNode);
        size++;
    }

    @Override
    public void delete(int counter) {
        Node<E> target = firstNode.nextElement;
        for (int i = 0; i < counter; i++) {
            target = target.getNextElement();
        }

        Node<E> targetNext = target.getNextElement();
        Node<E> targetPrevious = target.getPrevElement();
        targetNext.setPrevElement(targetPrevious);
        targetPrevious.setNextElement(targetNext);
        target.setNextElement(null);
        target.setPrevElement(null);
        size--;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public E getElementByIndex(int counter) {
        Node<E> target = firstNode.nextElement;
        for (int i = 0; i < counter; i++) {
            target = target.getNextElement();
        }
        return target.currentElement;
    }

    public void setFirstNode(Node<E> firstNode) {
        this.firstNode = firstNode;
    }

    public Node<E> getLastNode() {
        return lastNode;
    }

    public void setLastNode(Node<E> lastNode) {
        this.lastNode = lastNode;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private int count = 0;

            @Override
            public boolean hasNext() {
                return count < size;
            }

            @Override
            public E next() {
                return getElementByIndex(count++);
            }
        };
    }

    @Override
    public Iterator<E> reverseIterator() {
        return new Iterator<E>() {
            int count = size - 1;

            @Override
            public boolean hasNext() {
                return count >= 0;
            }

            @Override
            public E next() {
                return getElementByIndex(count--);
            }
        };
    }
}


3. Iterable olmadan.


package org.example;

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for(Iterator<Integer> it = list.iterator(); it.hasNext();) {
            Integer i = it.next();
            System.out.println(i);
        }

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        for (Integer i : list) {
            System.out.println(i);
        }
    }
}


Implementing Iterable:

version1:

package org.example;

import java.util.ArrayList;
import java.util.Iterator;

public class Container<T> {
    private ArrayList<T> data;

    public Container() {
        this.data = new ArrayList<>();
    }

    public void add(T t) {
        data.add(t);
    }

    @Override
    public String toString() {
        return "Container{" +
                "data=" + data +
                '}';
    }

    public class ContainerIterator<T> implements Iterator<T> {
        private int index;

        public ContainerIterator() {
            index = 0;
        }

        @Override
        public boolean hasNext() {
            return index < data.size();
        }

        @Override
        public T next() {
            return (T) data.get(index++);
        }

        @Override
        public void remove() {
            if (index > 0 && index < data.size())
                data.remove(--index);
        }
    }

    public Iterator<T> iterator() {
        return new ContainerIterator<>();
    }
}


version2:

package org.example;

import java.util.ArrayList;
import java.util.Iterator;

public class Container2<T> implements Iterable<T> {
    private ArrayList<T> data;

    public Container2() {
        this.data = new ArrayList<>();
    }

    public void add(T t) {
        data.add(t);
    }

    @Override
    public String toString() {
        return "Container2{" +
                "data=" + data +
                '}';
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < data.size();
            }

            @Override
            public T next() {
                return data.get(index);
            }

            @Override
            public void remove() {
                if (index > 0 && index < data.size()) {
                    data.remove(--index);
                }
            }
        };
    }
}


package org.example;

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        Container<Integer> container = new Container<>();
        container.add(1);
        container.add(2);
        container.add(3);
        System.out.println(container);

        for(Iterator<Integer> it = container.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }

        Iterator<Integer> it = container.iterator();
        it.next();
        it.remove();
        System.out.println(container);
    }
}


-----------------------------------------------------------------------------------------------------------------------------

https://www.techiedelight.com/why-override-equals-and-hashcode-methods-java/

Internal working of HashMap

-- adding process


package org.example;

public class Person {
    public Long id;
    public String name;

    public Person(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        return false;
    }

    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
package org.example;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        String s1 = "FB";
        String s2 = "Ea";

        HashMap<String, Integer> map = new HashMap<>();
        map.put(s1, 1);
        map.put(s2, 2);
        System.out.println(map);

        Person p = new Person(1L, "Parvin");
        Person p2 = new Person(1L, "Parvin");
        HashMap<Person, Integer> map1 = new HashMap<>();
        map1.put(p, 100);
        map1.put(p2, 200);
        System.out.println(map1);
    }
}



-----------------------------------------------------------------------------------------------------------------------------

HashSet internally uses HashMap































Комментарии

Отправить комментарий

Популярные сообщения из этого блога

Lesson1: JDK, JVM, JRE

Изображение
1. Compiler - takes the entire programming code written in high language and translates the whole of it into machine code at once. After this process the an executable file will be ready to run. The translation takes some times to be done, but after that execution is so fast. 2. Interpreter - takes each single instructions of the code translates it and then executes it on its own. The translation step is before the program runs is fast, but execution is slow. JDK = JRE + development tools JRE = JVM + library class JDK -> Java Development Kit. A kit which provides the environment to develop and execute (run) Java program. JRE -> Java Runtime Environment. Provides environment to only run. JVM -> Java Virtual Machine f * Compiled: Fortran, C, C++, Pascal, Haskell, Rust, Go * Interpreted: JavaScript, PHP, Python, Ruby Java both compiled and interpreted language. Terminalda : javac Main.java yazdiqda, source fayli(.java) bytecode(.class) faylina cevirir. Terminalda: java Main (bu z
Далее...

SE_21_Lesson_11: Inheritance, Polymorphism

->  instanceof anlayishi, misallarla izahi   package org.example.lesson_13 ; public class Ulubaba { public String ad ; public String soyad ; public Integer yash ; public void odunDogramaq () { System . out .println( "Ulubaba 50 kq odunu 1 saata dograyir" ) ; } } package org.example.lesson_13 ; public class Baba extends Ulubaba { public String hobbi ; public void otBicmek () { System . out .println( "Baba 1 hektar otu 1 gune bicir" ) ; } } package org.example.lesson_13 ; public class Main { public static void main ( String [] args ) { Baba baba = new Baba() ; System . out .println( baba instanceof Ulubaba ) ; System . out .println( baba instanceof Object ) ; } } -> Upcasting package org.example.lesson_13 ; public class Main { public static void main ( String [] args ) { Ulubaba u = new Baba() ; } } -> Downcasting Problemsiz situasiya: package org.example.lesson_13
Далее...

SE_21_Lesson_9: Initialization Blocks, Wrapper types, String class

Изображение
-> static block: package org.example.test3 ; public class Blocks { static { System . out .println( "In static block" ) ; } public static void method () { System . out .println( "In static method" ) ; } } package org.example.test3 ; public class Main { public static void main ( String [] args ) { Blocks . method () ; } } -> Class.forName() metodunu ishe salmaq: package org.example.test3 ; public class Blocks { static { System . out .println( "In static block" ) ; } } package org.example.test3 ; public class Main { public static void main ( String [] args ) throws Exception { Class . forName ( "org.example.test3.Blocks" ) ; } } -> non-static (instance) block: package org.example.test3 ; public class Blocks { static { System . out .println( "in static block" ) ; } { System . out .println( "in non static (instance) block
Далее...