diff --git a/.gitignore b/.gitignore
index 188fae8..ba9ea56 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,4 @@
 out
 *.iml
 log
-
-
-
+lib
diff --git a/src/ArrayStorage.java b/src/ArrayStorage.java
deleted file mode 100644
index cefa261..0000000
--- a/src/ArrayStorage.java
+++ /dev/null
@@ -1,85 +0,0 @@
-import java.util.Arrays;
-import java.util.Objects;
-
-/**
- * Array based storage for Resumes
- */
-public class ArrayStorage {
-    private Resume[] storage = new Resume[10_000];
-
-    private int size;
-
-    public void clear() {
-        Arrays.fill(storage, 0, size, null);
-        size = 0;
-    }
-
-    public void update(Resume resume) {
-        int index = getIndex(resume.getUuid());
-
-        if (index >= 0) {
-            storage[index] = resume;
-        } else {
-            System.out.println("ERROR in method 'update' :" + resume.getUuid());
-        }
-    }
-
-    public void save(Resume resume) {
-        int index = getIndex(resume.getUuid());
-
-        if (index >= 0) {
-            System.out.println("ERROR in method 'save' :" + resume.getUuid());
-        } else {
-            if (size < storage.length) {
-                storage[size] = resume;
-                size++;
-            } else {
-                System.out.println("ERROR in method 'save' :" + resume.getUuid() + " (storage backing array boundary has been reached)");
-            }
-        }
-    }
-
-    public Resume get(String uuid) {
-        int index = getIndex(uuid);
-
-        if (index >= 0) {
-            return storage[index];
-        } else {
-            System.out.println("Invalid uuid in method 'get': " + uuid);
-            return null;
-        }
-    }
-
-
-    public void delete(String uuid) {
-        int index = getIndex(uuid);
-
-        if (index >= 0) {
-            storage[index] = storage[size - 1];
-            storage[size - 1] = null;
-            size--;
-        } else {
-            System.out.println("Invalid uuid in method 'delete': " + uuid);
-        }
-    }
-
-    /**
-     * @return array, contains only Resumes in storage (without null)
-     */
-    public Resume[] getAll() {
-        return Arrays.copyOf(storage, size);
-    }
-
-    public int size() {
-        return size;
-    }
-
-    private int getIndex(String uuid) {
-        for (int i = 0; i < size; i++) {
-            if (Objects.equals(storage[i].getUuid(), uuid)) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}
diff --git a/src/Resume.java b/src/Resume.java
deleted file mode 100644
index ef673e6..0000000
--- a/src/Resume.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * Initial resume class
- */
-public class Resume {
-
-    // Unique identifier
-    private String uuid;
-
-    public String getUuid() {
-        return uuid;
-    }
-
-    public void setUuid(String uuid) {
-        this.uuid = uuid;
-    }
-
-    @Override
-    public String toString() {
-        return uuid;
-    }
-}
diff --git a/src/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java
similarity index 78%
rename from src/MainArray.java
rename to src/ru/javawebinar/basejava/MainArray.java
index cc060cf..da69a13 100644
--- a/src/MainArray.java
+++ b/src/ru/javawebinar/basejava/MainArray.java
@@ -1,19 +1,24 @@
+package ru.javawebinar.basejava;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.Storage;
+import ru.javawebinar.basejava.storage.impl.ArrayStorage;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 
 /**
- * Interactive test for ArrayStorage implementation
- * (just run, no need to understand)
+ * Test for ru.javawebinar.basejava.storage.impl.ArrayStorage
  */
 public class MainArray {
-    private final static ArrayStorage ARRAY_STORAGE = new ArrayStorage();
+    private final static Storage ARRAY_STORAGE = new ArrayStorage();
 
     public static void main(String[] args) throws IOException {
         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
         Resume r;
         while (true) {
-            System.out.print("Введите одну из команд - (list | save uuid | update uuid | delete uuid | get uuid | clear | exit): ");
+            System.out.print("Введите одну из команд - (list | save uuid | delete uuid | get uuid | update uuid | clear | exit): ");
             String[] params = reader.readLine().trim().toLowerCase().split(" ");
             if (params.length < 1 || params.length > 2) {
                 System.out.println("Неверная команда.");
@@ -31,15 +36,14 @@ public static void main(String[] args) throws IOException {
                     System.out.println(ARRAY_STORAGE.size());
                     break;
                 case "save":
-                    r = new Resume();
-                    r.setUuid(uuid);
+                    r = new Resume(uuid);
                     ARRAY_STORAGE.save(r);
                     printAll();
                     break;
                 case "update":
-                    Resume rNew = new Resume();
-                    rNew.setUuid(uuid);
-                    ARRAY_STORAGE.update(rNew);
+                    r = new Resume(uuid);
+                    ARRAY_STORAGE.update(r);
+                    printAll();
                     break;
                 case "delete":
                     ARRAY_STORAGE.delete(uuid);
@@ -62,7 +66,7 @@ public static void main(String[] args) throws IOException {
     }
 
     static void printAll() {
-        Resume[] all = ARRAY_STORAGE.getAll();
+        Resume [] all = ARRAY_STORAGE.getAll();
         System.out.println("----------------------------");
         if (all.length == 0) {
             System.out.println("Empty");
diff --git a/src/ru/javawebinar/basejava/MainCollections.java b/src/ru/javawebinar/basejava/MainCollections.java
new file mode 100644
index 0000000..5b7077f
--- /dev/null
+++ b/src/ru/javawebinar/basejava/MainCollections.java
@@ -0,0 +1,58 @@
+package ru.javawebinar.basejava;
+
+import ru.javawebinar.basejava.model.Resume;
+
+import java.util.*;
+
+public class MainCollections {
+    private static final String UUID_1 = "uuid1";
+    private static final Resume RESUME_1 = new Resume(UUID_1);
+
+    private static final String UUID_2 = "uuid2";
+    private static final Resume RESUME_2 = new Resume(UUID_2);
+
+    private static final String UUID_3 = "uuid3";
+    private static final Resume RESUME_3 = new Resume(UUID_3);
+
+    private static final String UUID_4 = "uuid4";
+    private static final Resume RESUME_4 = new Resume(UUID_4);
+
+    public static void main(String[] args) {
+        Collection<Resume> collection = new ArrayList<>();
+        collection.add(RESUME_1);
+        collection.add(RESUME_2);
+        collection.add(RESUME_3);
+
+        for (Resume r : collection) {
+            System.out.println(r);
+            if (Objects.equals(r.getUuid(), UUID_1)) {
+//                collection.remove(r);
+            }
+        }
+
+        Iterator<Resume> iterator = collection.iterator();
+        while (iterator.hasNext()) {
+            Resume r = iterator.next();
+            System.out.println(r);
+            if (Objects.equals(r.getUuid(), UUID_1)) {
+                iterator.remove();
+            }
+        }
+        System.out.println(collection.toString());
+
+
+        Map<String, Resume> map = new HashMap<>();
+        map.put(UUID_1, RESUME_1);
+        map.put(UUID_2, RESUME_2);
+        map.put(UUID_3, RESUME_3);
+
+        // Bad!
+        for (String uuid : map.keySet()) {
+            System.out.println(map.get(uuid));
+        }
+
+        for (Map.Entry<String, Resume> entry : map.entrySet()) {
+            System.out.println(entry.getValue());
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java
new file mode 100644
index 0000000..7652fd8
--- /dev/null
+++ b/src/ru/javawebinar/basejava/MainReflection.java
@@ -0,0 +1,40 @@
+package ru.javawebinar.basejava;
+
+import ru.javawebinar.basejava.model.Resume;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class MainReflection {
+
+    public static void main(String[] args) throws IllegalAccessException {
+        Resume r = new Resume();
+        Field field = r.getClass().getDeclaredFields()[0];
+        field.setAccessible(true);
+        System.out.println(field.getName());
+        System.out.println(field.get(r));
+        field.set(r, "new_uuid");
+        // TODO : invoke r.toString via reflection
+        System.out.println(r);
+
+        System.out.println(field.get(r));
+
+        try {
+            Method toString = r.getClass().getMethod("toString");
+
+            try {
+                Object invoke = toString.invoke(r);
+                System.out.println(invoke);
+
+            } catch (IllegalArgumentException e) {  }
+            catch (IllegalAccessException e) { }
+            catch (InvocationTargetException e) { }
+
+        } catch (SecurityException e) { }
+        catch (NoSuchMethodException e) { }
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/MainString.java b/src/ru/javawebinar/basejava/MainString.java
new file mode 100644
index 0000000..681b189
--- /dev/null
+++ b/src/ru/javawebinar/basejava/MainString.java
@@ -0,0 +1,18 @@
+package ru.javawebinar.basejava;
+
+public class MainString {
+    public static void main(String[] args) {
+        String[] strArray = new String[]{"1", "2", "3", "4", "5"};
+//        String result = "";
+        StringBuilder sb = new StringBuilder();
+        for (String str : strArray) {
+            sb.append(str).append(", ");
+        }
+        System.out.println(sb.toString());
+
+        String str1 = "abc";
+        String str3 = "c";
+        String str2 = ("ab" + str3).intern();
+        System.out.println(str1 == str2);
+    }
+}
\ No newline at end of file
diff --git a/src/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java
similarity index 50%
rename from src/MainTestArrayStorage.java
rename to src/ru/javawebinar/basejava/MainTestArrayStorage.java
index 7683807..dad5b1b 100644
--- a/src/MainTestArrayStorage.java
+++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java
@@ -1,19 +1,18 @@
+package ru.javawebinar.basejava;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.impl.ArrayStorage;
+
 /**
- * Test for your ArrayStorage implementation
+ * Test ru.javawebinar.basejava.storage.impl.ArrayStorage
  */
 public class MainTestArrayStorage {
     static final ArrayStorage ARRAY_STORAGE = new ArrayStorage();
-    static int ARRAY_STORAGE_LIMIT = 10_000;
 
     public static void main(String[] args) {
-        Resume r1 = new Resume();
-        r1.setUuid("uuid1");
-        Resume r2 = new Resume();
-        r2.setUuid("uuid2");
-        Resume r3 = new Resume();
-        r3.setUuid("uuid3");
-        Resume r2new = new Resume();
-        r2new.setUuid("uuid2");
+        Resume r1 = new Resume("uuid1");
+        Resume r2 = new Resume("uuid2");
+        Resume r3 = new Resume("uuid3");
 
         ARRAY_STORAGE.save(r1);
         ARRAY_STORAGE.save(r2);
@@ -24,14 +23,6 @@ public static void main(String[] args) {
 
         System.out.println("Get dummy: " + ARRAY_STORAGE.get("dummy"));
 
-        ARRAY_STORAGE.save(r2new);
-
-        ARRAY_STORAGE.update(r2new);
-        System.out.println("Get r2new: " + ARRAY_STORAGE.get(r2new.getUuid()));
-
-        ARRAY_STORAGE.get("uuid111");
-        ARRAY_STORAGE.delete("uuid111");
-
         printAll();
         ARRAY_STORAGE.delete(r1.getUuid());
         printAll();
@@ -39,14 +30,6 @@ public static void main(String[] args) {
         printAll();
 
         System.out.println("Size: " + ARRAY_STORAGE.size());
-
-        for (int i = 0; i <= ARRAY_STORAGE_LIMIT; i++) {
-            Resume r = new Resume();
-            r.setUuid("uuid" + i);
-            ARRAY_STORAGE.save(r);
-        }
-
-        System.out.println("Size: " + ARRAY_STORAGE.size());
     }
 
     static void printAll() {
@@ -55,4 +38,4 @@ static void printAll() {
             System.out.println(r);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/exception/ExistStorageException.java b/src/ru/javawebinar/basejava/exception/ExistStorageException.java
new file mode 100644
index 0000000..33d98be
--- /dev/null
+++ b/src/ru/javawebinar/basejava/exception/ExistStorageException.java
@@ -0,0 +1,7 @@
+package ru.javawebinar.basejava.exception;
+
+public class ExistStorageException extends StorageException {
+    public ExistStorageException(String uuid) {
+        super("Resume " + uuid + " already exist", uuid);
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/exception/NotExistStorageException.java b/src/ru/javawebinar/basejava/exception/NotExistStorageException.java
new file mode 100644
index 0000000..9a9b867
--- /dev/null
+++ b/src/ru/javawebinar/basejava/exception/NotExistStorageException.java
@@ -0,0 +1,7 @@
+package ru.javawebinar.basejava.exception;
+
+public class NotExistStorageException extends StorageException {
+    public NotExistStorageException(String uuid) {
+        super("Resume " + uuid + " not exist", uuid);
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/exception/StorageException.java b/src/ru/javawebinar/basejava/exception/StorageException.java
new file mode 100644
index 0000000..dbd1be0
--- /dev/null
+++ b/src/ru/javawebinar/basejava/exception/StorageException.java
@@ -0,0 +1,14 @@
+package ru.javawebinar.basejava.exception;
+
+public class StorageException extends RuntimeException {
+    private final String uuid;
+
+    public StorageException(String message, String uuid) {
+        super(message);
+        this.uuid = uuid;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/model/Resume.java b/src/ru/javawebinar/basejava/model/Resume.java
new file mode 100644
index 0000000..508cc20
--- /dev/null
+++ b/src/ru/javawebinar/basejava/model/Resume.java
@@ -0,0 +1,49 @@
+package ru.javawebinar.basejava.model;
+
+import java.util.UUID;
+
+/**
+ * ru.javawebinar.basejava.model.Resume class
+ */
+public class Resume implements Comparable<Resume> {
+
+    // Unique identifier
+    private final String uuid;
+
+    public Resume() {
+        this(UUID.randomUUID().toString());
+    }
+
+    public Resume(String uuid) {
+        this.uuid = uuid;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Resume resume = (Resume) o;
+
+        return uuid.equals(resume.uuid);
+    }
+
+    @Override
+    public int hashCode() {
+        return uuid.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return uuid;
+    }
+
+    @Override
+    public int compareTo(Resume o) {
+        return uuid.compareTo(o.uuid);
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java
new file mode 100644
index 0000000..4656f95
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java
@@ -0,0 +1,70 @@
+package ru.javawebinar.basejava.storage;
+
+import ru.javawebinar.basejava.exception.StorageException;
+import ru.javawebinar.basejava.model.Resume;
+
+import java.util.Arrays;
+
+/**
+ * Array based storage for Resumes
+ */
+public abstract class AbstractArrayStorage extends AbstractStorage {
+    protected static final int STORAGE_LIMIT = 10000;
+
+    protected Resume[] storage = new Resume[STORAGE_LIMIT];
+    protected int size = 0;
+
+    protected abstract void implDelete(int index);
+
+    protected abstract void implSave(int index, Resume r);
+
+    protected abstract Object getIndex(String uuid);
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public void clear() {
+        Arrays.fill(storage, 0, size, null);
+        size = 0;
+    }
+
+    @Override
+    public void doUpdate(Object index, Resume r) {
+        storage[(Integer)index] = r;
+    }
+
+    @Override
+    public Resume doGet(Object index) {
+        return storage[(Integer)index];
+    }
+
+    @Override
+    public void doDelete(Object index) {
+        implDelete((Integer)index);
+        storage[size - 1] = null;
+        size--;
+    }
+
+    @Override
+    public Resume[] getAll() {
+        return Arrays.copyOfRange(storage, 0, size);
+    }
+
+    @Override
+    public void doSave(Object index, Resume r) {
+        if (size == STORAGE_LIMIT) {
+            throw new StorageException("Storage overflow", r.getUuid());
+        } else {
+            implSave((Integer)index, r);
+            size++;
+        }
+    }
+
+    @Override
+    public boolean isPresent(Object index) {
+        return (Integer) index >= 0;
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java
new file mode 100644
index 0000000..e53a5af
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java
@@ -0,0 +1,60 @@
+package ru.javawebinar.basejava.storage;
+
+import ru.javawebinar.basejava.exception.ExistStorageException;
+import ru.javawebinar.basejava.exception.NotExistStorageException;
+import ru.javawebinar.basejava.model.Resume;
+
+public abstract class AbstractStorage implements Storage {
+
+    protected abstract void doSave(Object index, Resume r);
+
+    protected abstract void doUpdate(Object index, Resume r);
+
+    protected abstract Resume doGet(Object index);
+
+    protected abstract void doDelete(Object index);
+
+    protected abstract Object getIndex(String uuid);
+
+    protected abstract boolean isPresent(Object index);
+
+    @Override
+    public void save(Resume r) {
+        Object index = getNotExistingKey(r.getUuid());
+        doSave(index, r);
+    }
+
+    @Override
+    public void update(Resume r) {
+        Object index = getExistingKey(r.getUuid());
+        doUpdate(index, r);
+    }
+
+    @Override
+    public void delete(String uuid) {
+        Object index = getExistingKey(uuid);
+        doDelete(index);
+    }
+
+    @Override
+    public Resume get(String uuid) {
+        Object index = getExistingKey(uuid);
+        return doGet(index);
+    }
+
+    protected Object getExistingKey(String uuid) {
+        Object index = getIndex(uuid);
+        if (!isPresent(index)) {
+            throw new NotExistStorageException(uuid);
+        }
+        return index;
+    }
+
+    protected Object getNotExistingKey(String uuid) {
+        Object index = getIndex(uuid);
+        if (isPresent(index)) {
+            throw new ExistStorageException(uuid);
+        }
+        return index;
+    }
+}
diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java
new file mode 100644
index 0000000..992a445
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/Storage.java
@@ -0,0 +1,22 @@
+package ru.javawebinar.basejava.storage;
+
+import ru.javawebinar.basejava.model.Resume;
+
+public interface Storage {
+
+    void clear();
+
+    void update(Resume r);
+
+    void save(Resume r);
+
+    Resume get(String uuid);
+
+    void delete(String uuid);
+
+    Resume[] getAll();
+
+//    List<Resume> getAll();
+
+    int size();
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java
new file mode 100644
index 0000000..f9e28d7
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java
@@ -0,0 +1,30 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.AbstractArrayStorage;
+
+/**
+ * Array based storage for Resumes
+ */
+public class ArrayStorage extends AbstractArrayStorage {
+
+    @Override
+    protected void implDelete(int index) {
+        storage[index] = storage[size - 1];
+    }
+
+    @Override
+    protected void implSave(int index, Resume r) {
+        storage[size] = r;
+    }
+
+    @Override
+    protected Object getIndex(String uuid) {
+        for (int i = 0; i < size; i++) {
+            if (uuid.equals(storage[i].getUuid())) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java
new file mode 100644
index 0000000..d512a93
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java
@@ -0,0 +1,62 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.AbstractStorage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListStorage extends AbstractStorage {
+
+    private List<Resume> list = new ArrayList<>();
+
+    @Override
+    protected void doSave(Object index, Resume r) {
+        list.add(r);
+    }
+
+    @Override
+    protected void doUpdate(Object index, Resume r) {
+        list.set((int) index, r);
+    }
+
+    @Override
+    protected Resume doGet(Object index) {
+        return list.get((int) index);
+    }
+
+    @Override
+    protected void doDelete(Object index) {
+        list.remove(((int) index));
+    }
+
+    @Override
+    protected Object getIndex(String uuid) {
+        for (int i = 0; i < list.size(); i++) {
+            if (uuid.equals(list.get(i).getUuid())) {
+                return i;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected boolean isPresent(Object index) {
+        return index != null;
+    }
+
+    @Override
+    public void clear() {
+        list.clear();
+    }
+
+    @Override
+    public Resume[] getAll() {
+        return list.toArray(Resume[]::new);
+    }
+
+    @Override
+    public int size() {
+        return list.size();
+    }
+}
diff --git a/src/ru/javawebinar/basejava/storage/impl/MapStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapStorage.java
new file mode 100644
index 0000000..ef777e1
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/impl/MapStorage.java
@@ -0,0 +1,60 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.AbstractStorage;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapStorage extends AbstractStorage {
+
+    private Map<String, Resume> map = new HashMap<>();
+
+
+    @Override
+    protected void doSave(Object index, Resume r) {
+        map.put((String)index,r);
+    }
+
+    @Override
+    protected void doUpdate(Object index, Resume r) {
+        map.put((String)index,r);
+    }
+
+    @Override
+    protected Resume doGet(Object index) {
+        return map.get(index);
+    }
+
+    @Override
+    protected void doDelete(Object index) {
+        map.remove(index);
+    }
+
+    @Override
+    protected Object getIndex(String uuid) {
+        return uuid;
+    }
+
+    @Override
+    protected boolean isPresent(Object index) {
+        return map.containsKey(index);
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public Resume[] getAll() {
+        return map.values().stream()
+                .sorted(Resume::compareTo)
+                .toArray(Resume[]::new);
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+}
diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java
new file mode 100644
index 0000000..0958689
--- /dev/null
+++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java
@@ -0,0 +1,30 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import ru.javawebinar.basejava.model.Resume;
+import ru.javawebinar.basejava.storage.AbstractArrayStorage;
+
+import java.util.Arrays;
+
+public class SortedArrayStorage extends AbstractArrayStorage {
+
+    @Override
+    protected void implDelete(int index) {
+        int numMoved = size - index - 1;
+        if (numMoved > 0) {
+            System.arraycopy(storage, index + 1, storage, index, numMoved);
+        }
+    }
+
+    @Override
+    protected void implSave(int index, Resume r) {
+        int insert = -index - 1;
+        System.arraycopy(storage, insert, storage, insert + 1, size - insert);
+        storage[insert] = r;
+    }
+
+    @Override
+    protected Object getIndex(String uuid) {
+        Resume searchKey = new Resume(uuid);
+        return Arrays.binarySearch(storage, 0, size, searchKey);
+    }
+}
\ No newline at end of file
diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java
new file mode 100644
index 0000000..1639fe4
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java
@@ -0,0 +1,54 @@
+package ru.javawebinar.basejava.storage;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+import ru.javawebinar.basejava.exception.StorageException;
+import ru.javawebinar.basejava.model.Resume;
+
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+
+public abstract class AbstractArrayStorageTest extends AbstractStorageTest {
+
+    protected AbstractArrayStorageTest(Storage storage) {
+        super(storage);
+    }
+
+
+    @Nested
+    class SaveOverflow {
+
+        @BeforeEach
+        void setUp() {
+            storage.clear();
+        }
+
+        @Test
+        @DisplayName("Should not throw within size limit, then throws when overflow")
+        void fill() {
+            // arrange
+            String uuid = "New item";
+            Executable throwingExecutable = () -> {
+                storage.save(new Resume(uuid));
+            };
+
+            // act and assert
+            assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1).
+                    limit(AbstractArrayStorage.STORAGE_LIMIT).
+                    mapToObj(i -> new Resume("Name" + i)).
+                    forEach(storage::save));
+
+            RuntimeException thrown = assertThrows(
+                    StorageException.class, throwingExecutable, "Should throw generic StorageException"
+            );
+
+            assertEquals("Storage overflow", thrown.getMessage());
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java
new file mode 100644
index 0000000..6b4f9a8
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java
@@ -0,0 +1,127 @@
+package ru.javawebinar.basejava.storage;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import ru.javawebinar.basejava.exception.ExistStorageException;
+import ru.javawebinar.basejava.exception.NotExistStorageException;
+import ru.javawebinar.basejava.model.Resume;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static ru.javawebinar.basejava.storage.Util.*;
+
+public abstract class AbstractStorageTest {
+    protected Storage storage;
+
+    protected AbstractStorageTest(Storage storage) {
+        this.storage = storage;
+    }
+
+    @BeforeEach
+    void beforeEach() {
+        storage.clear();
+        storage.save(R1);
+        storage.save(R2);
+        storage.save(R3);
+    }
+
+    @AfterEach
+    void afterEach() {
+        storage.clear();
+    }
+
+    @Test
+    void size() throws Exception {
+        assertSize(3);
+    }
+
+    @Test
+    void clear() throws Exception {
+        storage.clear();
+        assertSize(0);
+    }
+
+
+    @Test
+    void update() throws Exception {
+        Resume r2New = new Resume(UUID_2);
+        storage.update(r2New);
+
+        assertSame(r2New, storage.get(UUID_2));
+    }
+
+
+    @Test
+    void updateNonExisting() {
+        assertThrows(
+                NotExistStorageException.class,
+                () -> storage.update(new Resume("dummy"))
+        );
+    }
+
+    @Test
+    void save() throws Exception {
+        Resume r4 = new Resume(UUID_4);
+        storage.save(r4);
+
+        assertSize(4);
+        assertSame(r4, storage.get(UUID_4));
+    }
+
+
+    @Test
+    void saveExisting() throws Exception {
+        assertThrows(ExistStorageException.class,
+                () -> storage.save(R1));
+    }
+
+
+    @Test
+    void delete() throws Exception {
+        storage.delete(UUID_2);
+        assertAll("storage size is decreased, and access to deleted item correctly throws",
+                () -> assertEquals(2, storage.size()),
+                () -> assertThrows(NotExistStorageException.class,
+                        () -> storage.get(UUID_2))
+        );
+    }
+
+    @Test
+    void deleteNonExisting() {
+        assertThrows(
+                NotExistStorageException.class,
+                () -> storage.delete("dummy")
+        );
+    }
+
+
+    @Test
+    void getAll() throws Exception {
+        Resume[] test = new Resume[]{R1, R2, R3};
+        assertEquals(3, storage.getAll().length);
+        assertArrayEquals(test, storage.getAll());
+    }
+
+
+    @Test
+    void get() throws Exception {
+        assertGet(R1);
+    }
+
+    @Test
+    void getNonExisting() {
+        assertThrows(
+                NotExistStorageException.class,
+                () -> storage.get("dummy")
+        );
+    }
+
+
+    protected void assertSize(int size) {
+        assertEquals(size, storage.size());
+    }
+
+    private void assertGet(Resume r) {
+        assertEquals(r, storage.get(r.getUuid()));
+    }
+}
diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java
new file mode 100644
index 0000000..e4587c3
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/Util.java
@@ -0,0 +1,20 @@
+package ru.javawebinar.basejava.storage;
+
+import ru.javawebinar.basejava.model.Resume;
+
+class Util {
+    static final String UUID_1 = "uuid1";
+    static final String UUID_2 = "uuid2";
+    static final String UUID_3 = "uuid3";
+    static final String UUID_4 = "uuid4";
+
+    static final Resume R1;
+    static final Resume R2;
+    static final Resume R3;
+
+    static {
+        R1 = new Resume(UUID_1);
+        R2 = new Resume(UUID_2);
+        R3 = new Resume(UUID_3);
+    }
+}
diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java
new file mode 100644
index 0000000..c4a303b
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java
@@ -0,0 +1,12 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import org.junit.jupiter.api.DisplayName;
+import ru.javawebinar.basejava.storage.AbstractArrayStorageTest;
+
+@DisplayName("ArrayStorage implementation")
+public class ArrayStorageTest extends AbstractArrayStorageTest {
+
+    public ArrayStorageTest() {
+        super(new ArrayStorage());
+    }
+}
\ No newline at end of file
diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java
new file mode 100644
index 0000000..ac30618
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java
@@ -0,0 +1,11 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import org.junit.jupiter.api.DisplayName;
+import ru.javawebinar.basejava.storage.AbstractStorageTest;
+
+@DisplayName("ListStorage implementation")
+class ListStorageTest extends AbstractStorageTest {
+    public ListStorageTest() {
+        super(new ListStorage());
+    }
+}
\ No newline at end of file
diff --git a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java
new file mode 100644
index 0000000..3625069
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java
@@ -0,0 +1,11 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import org.junit.jupiter.api.DisplayName;
+import ru.javawebinar.basejava.storage.AbstractStorageTest;
+
+@DisplayName("MapStorage implementation")
+public class MapStorageTest extends AbstractStorageTest {
+    public MapStorageTest() {
+        super(new MapStorage());
+    }
+}
diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java
new file mode 100644
index 0000000..6b8c2aa
--- /dev/null
+++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java
@@ -0,0 +1,12 @@
+package ru.javawebinar.basejava.storage.impl;
+
+import org.junit.jupiter.api.DisplayName;
+import ru.javawebinar.basejava.storage.AbstractArrayStorageTest;
+
+@DisplayName("SortedArrayStorage implementation")
+public class SortedArrayStorageTest extends AbstractArrayStorageTest {
+
+    public SortedArrayStorageTest() {
+        super(new SortedArrayStorage());
+    }
+}
\ No newline at end of file