Практика 4й урок

Java4L4HW/src/alexrm84/Entry.java

@@ -0,0 +1,45 @@
+package alexrm84;
+
+import java.util.Objects;
+
+public class Entry<E> {
+
+    private final E value;
+    private Entry<E> next;
+
+    public Entry(E value) {
+        this.value = value;
+    }
+
+    public E getValue() {
+        return value;
+    }
+
+    public Entry<E> getNext() {
+        return next;
+    }
+
+    public void setNext(Entry<E> next) {
+        this.next = next;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Entry<?> entry = (Entry<?>) o;
+        return Objects.equals(value, entry.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+
+    @Override
+    public String toString() {
+        return "Entry{" +
+                "value=" + value +
+                '}';
+    }
+}

Java4L4HW/src/alexrm84/LinkedList.java

@@ -0,0 +1,21 @@
+package alexrm84;
+
+public interface LinkedList<E> {
+
+    void insert(E value);
+    E remove();
+    boolean remove(E value);
+
+    boolean isEmpty();
+    int getSize();
+    void setSize(int value);
+
+    boolean find(E value);
+
+    void display();
+
+    E getFirstElement();
+
+    Entry<E> getFirst();
+    void  setFirst(Entry<E> value);
+}

Java4L4HW/src/alexrm84/LinkedListImplement.java

@@ -0,0 +1,133 @@
+package alexrm84;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class LinkedListImplement<E> implements LinkedList<E>, Iterable<E> {
+
+    private Entry<E> firstElement;
+    private int size;
+
+    public Iterator<E> iterator(){
+        return new LinkedListImplementIterator();
+    }
+
+    private class LinkedListImplementIterator implements Iterator<E>{
+
+        Entry<E> current;
+
+        public LinkedListImplementIterator() {
+            this.current = LinkedListImplement.this.getFirst();
+        }
+
+        @Override
+        public E next() {
+            if (!this.hasNext()){
+                throw new NoSuchElementException();
+            }
+            E value = current.getValue();
+            current=current.getNext();
+            return value;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return this.current != null;
+        }
+    }
+
+    @Override
+    public void insert(E value) {
+        Entry<E> newElement = new Entry<>(value);
+        newElement.setNext(firstElement);
+        firstElement = newElement;
+        size++;
+    }
+
+    @Override
+    public E remove() {
+        if (isEmpty()){
+            return null;
+        }
+        E temp = firstElement.getValue();
+        firstElement = firstElement.getNext();
+        size--;
+        return temp;
+    }
+
+    @Override
+    public boolean remove(E value) {
+        Entry<E> current = firstElement;
+        Entry<E> previous = null;
+        while (current != null){
+            if (current.getValue().equals(value)){
+                break;
+            }
+            previous = current;
+            current = current.getNext();
+        }
+        if (current==null){
+            return false;
+        }
+        if (current==firstElement){
+            firstElement = firstElement.getNext();
+        }else{
+            previous.setNext(current.getNext());
+        }
+        size--;
+        return true;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size==0;
+    }
+
+    @Override
+    public int getSize() {
+        return size;
+    }
+
+    @Override
+    public void setSize(int value) {
+        this.size = value;
+    }
+
+    @Override
+    public boolean find(E value) {
+        Entry<E> current = firstElement;
+        while (current != null){
+            if (current.getValue().equals(value)){
+                return true;
+            }
+            current = current.getNext();
+        }
+        return false;
+    }
+
+    @Override
+    public void display() {
+        System.out.println("display " + this.getClass().getSimpleName());
+        Entry<E> current = firstElement;
+        while (current != null){
+            System.out.print(current.getValue()+" ");
+            current = current.getNext();
+        }
+        System.out.println();
+    }
+
+    @Override
+    public E getFirstElement() {
+        return firstElement.getValue();
+    }
+
+    @Override
+    public Entry<E> getFirst() {
+        return firstElement;
+    }
+
+    @Override
+    public void setFirst(Entry<E> value) {
+        firstElement=value;
+    }
+}

Java4L4HW/src/alexrm84/LinkedStackImplement.java

@@ -0,0 +1,40 @@
+package alexrm84;
+
+public class LinkedStackImplement<E> implements Stack<E> {
+
+    private LinkedList<E> data;
+
+    public LinkedStackImplement() {
+        this.data = new LinkedListImplement<>();
+    }
+
+    @Override
+    public void push(E value) {
+        data.insert(value);
+    }
+
+    @Override
+    public E pop() {
+        return data.remove();
+    }
+
+    @Override
+    public E peek() {
+        return data.getFirstElement();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean isFool() {
+        return false;
+    }
+
+    @Override
+    public int size() {
+        return data.getSize();
+    }
+}

Java4L4HW/src/alexrm84/Main.java

@@ -0,0 +1,20 @@
+package alexrm84;
+
+public class Main {
+
+    public static void main(String[] args) {
+        LinkedListImplement<Integer> list = new LinkedListImplement<>();
+        list.insert(1);
+        list.insert(2);
+        list.insert(3);
+        list.insert(4);
+        list.insert(5);
+
+        list.display();
+        list.remove();
+        list.remove(2);
+        for (Integer e : list) {
+            System.out.print(e+" ");
+        }
+    }
+}

Java4L4HW/src/alexrm84/Stack.java

@@ -0,0 +1,12 @@
+package alexrm84;
+
+public interface Stack<E> {
+
+    void push(E value);
+    E pop();
+    E peek();
+
+    boolean isEmpty();
+    boolean isFool();
+    int size();
+}

Java4L4HW/src/alexrm84/iterator/Link.java

@@ -0,0 +1,33 @@
+package alexrm84.iterator;
+
+import java.util.Objects;
+
+public class Link {
+    public String name;
+    public int age;
+
+    public Link next;
+
+    public Link(String name, int age){
+        this.name = name;
+        this.age = age;
+    }
+
+    public void display(){
+        System.out.println("Name: "+this.name+", age: "+this.age);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Link link = (Link) o;
+        return age == link.age &&
+                Objects.equals(name, link.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, age, next);
+    }
+}

Java4L4HW/src/alexrm84/iterator/LinkIterator.java

@@ -0,0 +1,74 @@
+package alexrm84.iterator;
+
+public class LinkIterator {
+    private Link current;
+    private Link previous;
+    private LinkedList list;
+
+    public LinkIterator(LinkedList list){
+        this.list = list;
+        this.reset();
+    }
+
+    public void reset(){
+        current = list.getFirst();
+        previous = null;
+    }
+
+    public boolean atEnd(){
+        return current.next == null;
+    }
+
+    public void nextLink(){
+        previous = current;
+        current = current.next;
+    }
+
+    public Link getCurrent(){
+        return current;
+    }
+
+    public void insertAfter(String name, int age){
+        Link newLink = new Link(name, age);
+        if (list.isEmpty()){
+            list.setFirst(newLink);
+            current = newLink;
+        } else {
+            newLink.next = current.next;
+            current.next = newLink;
+            nextLink();
+        }
+    }
+
+    public void insertBefore(String name, int age){
+        Link newLink = new Link(name, age);
+        if(previous == null){
+            newLink.next = list.getFirst();
+            list.setFirst(newLink);
+            reset();
+        }
+        else{
+            newLink.next = previous.next;
+            previous.next = newLink;
+            current = newLink;
+        }
+    }
+
+    public String deleteCurrent(){
+        String name = current.name;
+        if (previous == null){
+            list.setFirst(current.next);
+            reset();
+        } else {
+            previous.next = current.next;
+            if (atEnd()){
+                reset();
+            } else {
+                current = current.next;
+            }
+        }
+
+        return name;
+    }
+
+}