diff --git a/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask1.java b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask1.java
new file mode 100644
index 00000000..ae422e8f
--- /dev/null
+++ b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask1.java
@@ -0,0 +1,80 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.tn.courses.kkulichkin.v1.task3;
+
+import java.util.ArrayList;
+import ru.tn.courses.kkulichkin.v1.task3.SubtaskUtils.MyInteger;
+
+/**
+ *
+ * @author kkulichkin
+ * Вариант 1
+ * Разработать класс Integer
+ * - класс должен содержать конструкторы Integer(), Integer(int x), Integer(String s)
+ * - Реализовать метод сравнения двух объектов класса Integer
+ * - Реализовать методы добавления значения add(Integer i), вычитания, умножения и деления
+ * - Реализовать метод возведения в степень pow(int exponent)
+ * - реализовать методы преставления числа в восьмеричной и шестнадцатеричной СС
+ */
+public class Subtask1
+{
+    public static void main(String[] arg)
+    {
+        char[] char_int = {'-','2','8','3','0','0','1'};
+        
+        MyInteger integer  = new MyInteger(char_int);
+        MyInteger integer2 = new MyInteger(-283001);
+        MyInteger integer3 = new MyInteger();
+        
+        System.out.println(integer.intValue());
+        System.out.println(integer2.intValue());
+        System.out.println(integer3.intValue());
+        
+        
+        
+        
+        System.out.println(integer.equals(integer2));
+        System.out.println(integer.equals(integer3));
+        
+        
+        
+        MyInteger integer30 = new MyInteger(10);
+        MyInteger integer23 = new MyInteger(13);
+      
+        integer30.addInt(integer23);
+        System.out.println(integer30.intValue());
+        
+        integer30.setValue(10);
+        integer30.subInt(integer23);
+        System.out.println(integer30.intValue());
+        
+        integer30.setValue(10);
+        integer30.mulInt(integer23);
+        System.out.println(integer30.intValue());
+      
+        integer30.setValue(169 *  5);
+        integer30.divInt(integer23);
+        System.out.println(integer30.intValue());
+        
+        
+        
+        
+        MyInteger integer70 = new MyInteger(2);
+        integer70.pow(10);
+        System.out.println(integer70.intValue());
+        
+        
+        
+        
+        
+        
+        MyInteger integer450 = new MyInteger(255);
+        
+        System.out.println(integer450.toHexString());
+        System.out.println(integer450.toOctalString());
+        
+    }
+}
diff --git a/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask2.java b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask2.java
new file mode 100644
index 00000000..ede43792
--- /dev/null
+++ b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/Subtask2.java
@@ -0,0 +1,81 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.tn.courses.kkulichkin.v1.task3;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import ru.tn.courses.kkulichkin.v1.task3.SubtaskUtils.MyList;
+
+/**
+ *
+ * @author kkulichkin
+ * Разработать класс ListContainer<T> для хранения дженерик списков
+ * -класс должен содержать конструктор по умолчанию и конструктор с new ListContainer<T>(T ... elements)
+ * - метод получения значения списка
+ * - метод сравнения двух контейнеров
+ * - методы добавления и удаления элемента в контейнер
+ * - методы поиска элементов по индексу или значению
+ * - добавление коллекции элементов
+ * - получение контейнера с подсписком по индексам
+ */
+public class Subtask2
+{
+    public static void main(String[] arg)
+    {
+        MyList<Integer> list  = new MyList<Integer>();
+        MyList<Integer> list2 = new MyList<Integer>(1,2,3,4,5);
+        
+        System.out.println(list.toString());
+        System.out.println(list2.toString());
+        
+        System.out.println(list2.equals(list));
+        System.out.println(list2.equals(list2));
+        
+        list.add(3);
+        list.add(9);
+        
+        System.out.println(list.toString());
+        
+        list.addAt(6, 1);
+        
+        System.out.println(list.toString());
+        
+        
+        System.out.println(list.find(6));
+        System.out.println(list.findById(1));
+        
+        list.removeAt(1);
+        
+        System.out.println(list.toString());
+        
+        ArrayList<Integer> collection = new ArrayList<>(Arrays.asList(10,20,30));
+        list.addCollection(collection);
+        
+        System.out.println(list.toString());
+        
+        
+        MyList<Integer> sub_list = list.getSubMyList(2, 4);
+        
+        System.out.println(sub_list.toString());
+        
+        
+        
+        
+        Integer[] list_values = list2.getArray();
+        
+        System.out.println(Arrays.toString(list_values));
+    }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+}
diff --git a/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyInteger.java b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyInteger.java
new file mode 100644
index 00000000..b17110ee
--- /dev/null
+++ b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyInteger.java
@@ -0,0 +1,227 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.tn.courses.kkulichkin.v1.task3.SubtaskUtils;
+
+/**
+ *
+ * @author kkulichkin
+ */
+public class MyInteger
+{
+    
+    int value;
+
+    public MyInteger()
+    {
+        value = 0;
+    }
+    
+    
+    public MyInteger(int value_new)
+    {
+        value = value_new;
+    }
+    
+    public MyInteger(char[] value_new)
+    {
+        int value_temp = 0;
+        
+        int sign_char = 0;
+        int sign = 1;
+        boolean is_signed = false;
+        
+        
+        char first_char = value_new[0];
+        if(first_char == '-' || first_char == '+') is_signed = true;
+        if(first_char == '-') sign = -1;
+        if(first_char == '+') sign =  1;
+        
+        if(is_signed) sign_char = 1;
+        else          sign_char = 0;
+        
+   
+        int digit_power = 0;
+        for(int i = value_new.length - 1; i >= sign_char; i--)
+        {
+            int char_cur  = value_new[i];
+            int digit_cur = 0;
+            
+            switch(char_cur)
+            {
+                case '0': digit_cur = 0; break;
+                case '1': digit_cur = 1; break;
+                case '2': digit_cur = 2; break;
+                case '3': digit_cur = 3; break;
+                case '4': digit_cur = 4; break;
+                case '5': digit_cur = 5; break;
+                case '6': digit_cur = 6; break;
+                case '7': digit_cur = 7; break;
+                case '8': digit_cur = 8; break;
+                case '9': digit_cur = 9; break;
+            }
+            
+            int digit_modifier;
+            if(digit_power == 0)
+            {
+                digit_modifier = 1;
+            }
+            else
+            {
+                digit_modifier = 1;
+                for(int j = 0; j < digit_power; j++) digit_modifier *= 10;  
+            }
+            
+              
+            int digit_positioned = digit_cur * digit_modifier;
+            
+            value_temp += digit_positioned;
+            
+            
+            digit_power += 1; 
+        }
+        
+        value = value_temp * sign;
+    }
+    
+    public void setValue(int value_new)
+    {
+        value = value_new;
+    }
+    
+    
+    
+    public int intValue()
+    {
+        return value;
+    }
+    
+    public void addInt(MyInteger integer)
+    {
+        value += integer.intValue();
+    }
+    
+    public void subInt(MyInteger integer)
+    {
+        value -= integer.intValue();
+    }
+    
+    public void divInt(MyInteger integer)
+    {
+        value /= integer.intValue();
+    }
+    
+    public void mulInt(MyInteger integer)
+    {
+        value *= integer.intValue();
+    }
+    
+    public void pow(int power)
+    {
+        int value_base = value;
+        int value_new  = value_base;
+        while(power-- > 0) value_new *= value_base;
+        value = value_new;
+    }
+    
+    
+    public boolean equals(MyInteger obj)
+    {
+        if(obj instanceof MyInteger) return value == ((MyInteger)obj).intValue();
+        return false;
+    }
+    
+    
+    public char[] toHexString()
+    {
+        int value_base      = value;
+        int value_remainder = 0;
+        int value_quotient  = 0;
+        
+        
+        char[] value_hex = {'0', '0', '0', '0', '0', '0', '0', '0'};
+        
+        
+        int iteration_cur = 0;
+        do
+        {
+            char char_cur = '0';
+            
+            
+            value_remainder = value_base % 16;
+            value_base /= 16;
+            
+            switch(value_remainder)
+            {
+                case 0: char_cur = '0'; break;
+                case 1: char_cur = '1'; break;
+                case 2: char_cur = '2'; break;
+                case 3: char_cur = '3'; break;
+                case 4: char_cur = '4'; break;
+                case 5: char_cur = '5'; break;
+                case 6: char_cur = '6'; break;
+                case 7: char_cur = '7'; break;
+                case 8: char_cur = '8'; break;
+                case 9: char_cur = '9'; break;
+                case 10: char_cur = 'A'; break;
+                case 11: char_cur = 'B'; break;
+                case 12: char_cur = 'C'; break;
+                case 13: char_cur = 'D'; break;
+                case 14: char_cur = 'E'; break;
+                case 15: char_cur = 'F'; break;
+            }
+            
+            value_hex[value_hex.length - 1 - iteration_cur] = char_cur;
+            
+            iteration_cur += 1;
+            
+        }while(value_base > 0);
+        
+        return value_hex;
+    }
+    
+    public char[] toOctalString()
+    {
+        int value_base      = value;
+        int value_remainder = 0;
+        int value_quotient  = 0;
+        
+        
+        char[] value_oct = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'};
+        
+        
+        int iteration_cur = 0;
+        do
+        {
+            char char_cur = '0';
+            
+            
+            value_remainder = value_base % 8;
+            value_base /= 8;
+            
+            switch(value_remainder)
+            {
+                case 0: char_cur = '0'; break;
+                case 1: char_cur = '1'; break;
+                case 2: char_cur = '2'; break;
+                case 3: char_cur = '3'; break;
+                case 4: char_cur = '4'; break;
+                case 5: char_cur = '5'; break;
+                case 6: char_cur = '6'; break;
+                case 7: char_cur = '7'; break;
+            }
+            
+            value_oct[value_oct.length - 1 - iteration_cur] = char_cur;
+            
+            iteration_cur += 1;
+            
+        }while(value_base > 0);
+        
+        return value_oct;
+    }
+        
+    
+    
+}
diff --git a/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyList.java b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyList.java
new file mode 100644
index 00000000..10bb53ec
--- /dev/null
+++ b/src/main/java/ru/tn/courses/kkulichkin/v1/task3/SubtaskUtils/MyList.java
@@ -0,0 +1,280 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.tn.courses.kkulichkin.v1.task3.SubtaskUtils;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+
+/**
+ *
+ * @author kkulichkin
+ */
+public class MyList<T>
+{
+    T[] container;
+    int length;
+    
+    MyListElement<T> root;
+    
+    
+    public class MyListElement<T>
+    {
+        T value;
+        
+        MyListElement<T> next = null;
+        MyListElement<T> prev = null;
+
+        public MyListElement(T value_new){value = value_new;}
+           
+    }
+    
+    
+    public MyList()
+    {
+        length = 0;
+        root = null;
+    }
+    
+    public MyList(T ... elements)
+    {
+        for( T element : elements)
+        {
+            add(element);
+        } 
+    }
+    
+    public boolean equals(MyList<T> list)
+    {
+        if(!(list.length == length)) return false;
+        
+        for(int i = 0; i < length; i++)
+        {
+            T my_element  = findById(i);
+            T his_element = list.findById(i);
+            
+            if(!(my_element.equals(his_element))) return false;
+        }
+        return true;
+    }
+    
+    
+   
+    public T[] getArray()
+    {
+        Class<T> type = (Class<T>) root.value.getClass();
+        MyListElement<T> element_cur = root;
+  
+        T[] array = (T[]) Array.newInstance(type, length);
+
+        int id_cur = 0;
+        while(element_cur.next != null)
+        {
+            array[id_cur]    = element_cur.value;
+            element_cur = element_cur.next;
+            id_cur += 1;
+        }
+        
+        array[length - 1] = element_cur.value;
+        return  array;
+    }
+    
+    
+    public MyList<T> getSubMyList(int from, int to)
+    {
+        MyList<T> sub_list = new MyList<T>();
+        
+        
+        MyListElement<T> element_cur = root;
+        
+        int id_cur = 0;
+        
+        while(element_cur.next != null)
+        {
+            if(id_cur >= from && id_cur <= to)
+            {
+                sub_list.add(element_cur.value);
+            }
+            
+            element_cur = element_cur.next;
+            id_cur += 1;   
+        }
+        
+        
+        if(id_cur >= from && id_cur <= to)
+        {
+            sub_list.add(element_cur.value);
+        }
+        
+        
+        return  sub_list;
+    }
+    
+    
+    
+    public int find(T value)
+    {
+        int id_cur = 0;
+        
+        MyListElement<T> element_cur = root;
+        
+        while(element_cur.value.equals(value) != true)
+        {
+            element_cur = element_cur.next;
+            id_cur += 1;
+        }
+        
+        return id_cur;
+        
+    }
+    
+    private MyListElement<T> findBy(int id)
+    {
+        int id_cur = 0;
+        
+        MyListElement<T> element_cur = root;
+        
+        while(id_cur != id)
+        {
+            element_cur = element_cur.next;
+            id_cur += 1;
+        }
+        
+        return element_cur;
+    }
+    
+    
+    public T findById(int id)
+    {
+        return findBy(id).value;
+    }
+    
+    
+    public <K extends Collection<T>> void addCollection(K collection)
+    {
+        for(T value : collection)
+        {
+            add(value);
+        }
+    }
+    
+    public void add(T element)
+    {
+        if(root == null)
+        {
+            root = new MyListElement<T>(element);
+        }
+        else
+        {
+            MyListElement<T> element_new  = new MyListElement<T>(element);
+            MyListElement<T> element_last = findBy(length - 1);
+            element_last.next = element_new;
+            element_new.prev  = element_last;
+        }
+        
+        length += 1;
+    }
+    
+    public void addAt(T element, int id)
+    {
+        if(id == 0)
+        {
+            MyListElement<T> element_new  = new MyListElement<T>(element);
+            MyListElement<T> element_first = root;
+            
+            root = element_new;
+            element_first.prev = element_new;
+            element_new.next   = element_first;
+            element_new.prev   = null;
+            
+        }
+        else if (id == length - 1)
+        {
+            MyListElement<T> element_new  = new MyListElement<T>(element);
+            MyListElement<T> element_last = findBy(length - 1);
+            element_last.next = element_new;
+            element_new.prev  = element_last;
+            element_new.next  = null;
+        }
+        else
+        {
+            MyListElement<T> element_new  = new MyListElement<T>(element);
+            
+            MyListElement<T> element_prev = findBy(id);
+            MyListElement<T> element_next = element_prev.next;
+            
+            element_prev.next = element_new;
+            element_new.prev  = element_prev;
+            
+            element_next.prev = element_new;
+            element_new.next  = element_next;   
+        }
+        
+        length += 1;
+        
+    }
+    
+    public void remove(T value)
+    {
+        removeAt(find(value));
+    }
+    
+    public void removeAt(int id)
+    {
+        int id_cur = id;
+        MyListElement<T> element_cur = findBy(id_cur);
+        
+        if(id_cur == 0)
+        {
+            MyListElement<T> element_next = element_cur.next;
+            root = element_next;
+            root.prev = null;
+        }
+        if(id_cur == length - 1)
+        {
+            MyListElement<T> element_prev = element_cur.prev;
+            element_prev.next = null;
+            
+        }
+        else
+        {
+            MyListElement<T> element_prev = element_cur.prev;
+            MyListElement<T> element_next = element_cur.next;
+        
+        
+            element_prev.next = element_next;
+            element_next.prev = element_prev;  
+        } 
+        
+        length -= 1;
+        
+    }
+    
+    
+    public String toString()
+    {
+        String result = "";
+        
+        MyListElement<T> element_cur = root;
+        if(root == null) return "";
+
+        int id_cur = 0;
+        
+        while(element_cur.next != null)
+        {
+            result += id_cur + " : " + element_cur.value.toString() + "\n";
+            element_cur = element_cur.next;
+            id_cur += 1;   
+        }
+        
+        result += id_cur + " : " + element_cur.value.toString() + "\n";
+        
+        return result;
+    }
+    
+    
+    
+    
+}