diff --git a/gradle.properties b/gradle.properties
index d273149..8585e4a 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,2 +1,2 @@
-version=1.5
+version=1.6
 release=false
\ No newline at end of file
diff --git a/src/main/java/com/dselent/bigarraylist/BigArrayList.java b/src/main/java/com/dselent/bigarraylist/BigArrayList.java
index 5a23524..ae33bdc 100644
--- a/src/main/java/com/dselent/bigarraylist/BigArrayList.java
+++ b/src/main/java/com/dselent/bigarraylist/BigArrayList.java
@@ -22,6 +22,7 @@
 import java.io.IOException;
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -1001,8 +1002,7 @@ public E set(long index, E element) {
 	 * @return The new element at the specified index
 	 */
 	public E set(int index, E element) {
-		long longIndex = index;
-		return set(longIndex, element);
+		return set((long)index, element);
 	}
 
 	/**
@@ -1011,49 +1011,36 @@ public E set(int index, E element) {
 	 * @return True is the list is empty, false otherwise
 	 */
 	public boolean isEmpty() {
-		boolean empty = true;
-
-		if (size() > 0) {
-			empty = false;
-		}
-
-		return empty;
+		return wholeListSize == 0;
 	}
 
 	//hashCode cannot be implemented correctly due to contents being on disk and out of sight from memory
 
-	/* (non-Javadoc)
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	@SuppressWarnings("rawtypes")
 	@Override
 	public boolean equals(Object otherObject) {
 
-		boolean isEqual = true;
-
-		if (otherObject == null) {
-			isEqual = false;
-		} else if (this == otherObject) {
-			isEqual = true;
-		} else if (!(otherObject instanceof BigArrayList)) {
-			isEqual = false;
-		} else {
-			BigArrayList otherBigArrayList = (BigArrayList) otherObject;
-
-			if (wholeListSize != otherBigArrayList.size()) {
-				isEqual = false;
-			} else if (liveObject != otherBigArrayList.isLive()) {
-				isEqual = false;
-			} else {
-				for (long i = 0; i < wholeListSize && isEqual; i++) {
-					if (!get(i).equals(otherBigArrayList.get(i))) {
-						isEqual = false;
-					}
-				}
-			}
+		if (!(otherObject instanceof BigArrayList)) {
+			return super.equals(otherObject);
 		}
+		
+		BigArrayList<?> otherBigArrayList = (BigArrayList<?>) otherObject;
 
-		return isEqual;
+		if (wholeListSize != otherBigArrayList.size()) {
+			return false;
+		}
+		if (liveObject != otherBigArrayList.isLive()) {
+			return false;
+		}
+		
+        Iterator<E> thisIterator = this.iterator();
+        Iterator<?> otherIterator = otherBigArrayList.iterator();
+        while (thisIterator.hasNext() && otherIterator.hasNext()) {
+            E o1 = thisIterator.next();
+            Object o2 = otherIterator.next();
+            if (!(o1==null ? o2==null : o1.equals(o2)))
+                return false;
+		}
+        return !(thisIterator.hasNext() || otherIterator.hasNext());
 	}
 
 	@Override
@@ -1078,4 +1065,33 @@ public E next() {
 			}
 		};
 	}
+	
+	/**
+	 * @param other The other BigArrayList
+	 * @see ArrayList#addAll(Collection)
+	 */
+	public void addAll(BigArrayList<? extends E> other) {
+		for (E element : other) {
+			add(element);
+		}
+	}
+	
+	/**
+	 * @param other The other collection
+	 * @see ArrayList#addAll(Collection)
+	 */
+	public void addAll(Collection<? extends E> other) {
+		for (E element : other) {
+			add(element);
+		}
+	}
+	
+	/**
+	 * Clears all elements without clearing the memory
+	 */
+	public void clear() {
+		for (long i = wholeListSize-1; i >= 0; i--) {
+			remove(i);
+		}
+	}
 }
diff --git a/src/main/java/com/dselent/bigarraylist/CacheMapping.java b/src/main/java/com/dselent/bigarraylist/CacheMapping.java
index 275fd65..a3aca94 100644
--- a/src/main/java/com/dselent/bigarraylist/CacheMapping.java
+++ b/src/main/java/com/dselent/bigarraylist/CacheMapping.java
@@ -499,4 +499,4 @@ protected void clearMemory() throws IOException
 	{
 		fileAccessor.clearMemory();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/com/dselent/bigarraylist/FileAccessor.java b/src/main/java/com/dselent/bigarraylist/FileAccessor.java
index 7b396e3..6677d20 100644
--- a/src/main/java/com/dselent/bigarraylist/FileAccessor.java
+++ b/src/main/java/com/dselent/bigarraylist/FileAccessor.java
@@ -368,9 +368,6 @@ protected void clearMemory() throws IOException
 				}
 			}
 		}
-
 		//don't delete the folder, other things may be using it
-
 	}
-
-}
\ No newline at end of file
+}
diff --git a/src/test/java/BigArrayListTest.java b/src/test/java/BigArrayListTest.java
index 9019844..b69ee44 100644
--- a/src/test/java/BigArrayListTest.java
+++ b/src/test/java/BigArrayListTest.java
@@ -13,6 +13,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class BigArrayListTest
 {
@@ -27,7 +28,7 @@ public class BigArrayListTest
 	private static int maxActions;
 	
 	private static Random random;
-	private BigArrayList<Integer> bigArrayList;
+	private BigArrayList<Integer> actualMonte;
 
 	@BeforeAll
 	static void setUp() throws Exception
@@ -47,9 +48,9 @@ static void setUp() throws Exception
 	@AfterEach
 	protected void tearDown() throws Exception
 	{
-		if(bigArrayList != null)
+		if(actualMonte != null)
 		{
-			bigArrayList.clearMemory();
+			actualMonte.clearMemory();
 		}
 	}
 	
@@ -68,7 +69,7 @@ public void testBigArrayList()
 			int cacheBlocks = random.nextInt(maxCacheBlocks- minCacheBlocks) + minCacheBlocks;
 			int actions = random.nextInt(maxActions-minActions) + minActions;
 
-			bigArrayList = new BigArrayList<Integer>(blockSize, cacheBlocks);
+			actualMonte = new BigArrayList<Integer>(blockSize, cacheBlocks);
 			List<Integer> arrayList = new ArrayList<>();
 
 			for(int j=0; j<actions; j++)
@@ -81,18 +82,18 @@ public void testBigArrayList()
 					
 					int num1 = random.nextInt();
 					arrayList.add(num1);
-					bigArrayList.add(num1);
+					actualMonte.add(num1);
 					
 					//add another if it is early
 					if(j < actions/2)
 					{
 						int num2 = random.nextInt();
 						arrayList.add(num2);
-						bigArrayList.add(num2);
+						actualMonte.add(num2);
 					}
 					
 					String errorMessage = "(ADD) Sizes not equal: test run iteration = " + i + ", action number = " + j;
-					assertEquals((long)arrayList.size(), bigArrayList.size(), errorMessage);
+					assertEquals((long)arrayList.size(), actualMonte.size(), errorMessage);
 				}
 				else if(action == 1)
 				{
@@ -103,14 +104,14 @@ else if(action == 1)
 					int getIndex = random.nextInt(listSize);
 
 					long number1 = arrayList.get(getIndex);
-					long number2 = bigArrayList.get(getIndex);
+					long number2 = actualMonte.get(getIndex);
 					
 					String errorMessage = "(GET) Elements not equal: test run iteration = " + i + ", action number = " + j +
 							", ArrayList element = " + number1 + ", BigArrayList element = " + number2 + ", index = " + getIndex;
 					assertEquals(number1, number2, errorMessage);
 					
 					String errorMessage2 = "(GET) Sizes not equal: test run iteration = " + i + ", action number = " + j;
-					assertEquals(arrayList.size(), bigArrayList.size(), errorMessage2);
+					assertEquals(arrayList.size(), actualMonte.size(), errorMessage2);
 				}
 				else if(action == 2)
 				{
@@ -122,11 +123,11 @@ else if(action == 2)
 					int randomNumber = random.nextInt();
 
 					arrayList.set(setIndex, randomNumber);
-					bigArrayList.set(setIndex, randomNumber);
+					actualMonte.set(setIndex, randomNumber);
 					
 					
 					String errorMessage2 = "(SET) Sizes not equal: test run iteration = " + i + ", action number = " + j + ", index = " + setIndex;
-					assertEquals(arrayList.size(), bigArrayList.size(), errorMessage2);
+					assertEquals(arrayList.size(), actualMonte.size(), errorMessage2);
 				}
 				else if(action == 3)
 				{
@@ -137,14 +138,14 @@ else if(action == 3)
 					int removeIndex = random.nextInt(listSize);
 
 					int number1 = arrayList.remove(removeIndex);
-					int number2 = bigArrayList.remove(removeIndex);
+					int number2 = actualMonte.remove(removeIndex);
 
 					String errorMessage = "(REMOVE) Elements not equal: test run iteration = " + i + ", action number = " + j +
 							", ArrayList element = " + number1 + ", BigArrayList element = " + number2 + ", index = " + removeIndex;
 					assertEquals(number1, number2, errorMessage);
 					
 					String errorMessage2 = "(REMOVE) Sizes not equal: test run iteration = " + i + ", action number = " + j;
-					assertEquals(arrayList.size(), bigArrayList.size(), errorMessage2);
+					assertEquals(arrayList.size(), actualMonte.size(), errorMessage2);
 					
 					if(j > actions/2 && arrayList.size() > 0)
 					{
@@ -152,14 +153,14 @@ else if(action == 3)
 						int removeIndex2 = random.nextInt(listSize2);
 						
 						int number1_2 = arrayList.remove(removeIndex2);
-						int number2_2 = bigArrayList.remove(removeIndex2);
+						int number2_2 = actualMonte.remove(removeIndex2);
 
 						String errorMessage3 = "(REMOVE) Elements not equal: test run iteration = " + i + ", action number = " + j +
 								", ArrayList element = " + number1_2 + ", BigArrayList element = " + number2_2 + ", index = " + removeIndex;
 						assertEquals(number1, number2, errorMessage3);
 						
 						String errorMessage4 = "(REMOVE) Sizes not equal: test run iteration = " + i + ", action number = " + j;
-						assertEquals(arrayList.size(), bigArrayList.size(), errorMessage4);
+						assertEquals(arrayList.size(), actualMonte.size(), errorMessage4);
 					}
 				}
 					
@@ -181,7 +182,7 @@ else if(action == 3)
 			for(int j=0; j<arrayList.size(); j++)
 			{
 				int number1 = arrayList.get(j);
-				int number2 = bigArrayList.get(j);
+				int number2 = actualMonte.get(j);
 
 				String errorMessage = "(Elements not equal: test run iteration = " + i +
 						", ArrayList element = " + number1 + ", BigArrayList element = " + number2 + ", index = " + j;
@@ -193,7 +194,7 @@ else if(action == 3)
 			
 			try
 			{
-				bigArrayList = BigArrayList.sort(bigArrayList);
+				actualMonte = BigArrayList.sort(actualMonte);
 			}
 			catch (IOException e)
 			{
@@ -203,7 +204,7 @@ else if(action == 3)
 			
 			try
 			{
-				bigArrayList.clearMemory();
+				actualMonte.clearMemory();
 			}
 			catch(IOException e)
 			{
@@ -213,7 +214,7 @@ else if(action == 3)
 			for(int j=0; j<arrayList.size(); j++)
 			{
 				int number1 = arrayList.get(j);
-				int number2 = bigArrayList.get(j);
+				int number2 = actualMonte.get(j);
 
 				String errorMessage = "(Elements not equal after sorting: test run iteration = " + i +
 						", ArrayList element = " + number1 + ", BigArrayList element = " + number2 + ", index = " + j;
@@ -228,22 +229,94 @@ else if(action == 3)
 	@Test
 	public void testIterator() {
 
-		bigArrayList = new BigArrayList<Integer>();
+		BigArrayList<Integer> bal = new BigArrayList<>();
 		
 		for (int i = 0; i < 10000; i++) {
-			bigArrayList.add(random.nextInt());
+			bal.add(random.nextInt());
 		}
 		
 		List<Integer> expected = new ArrayList<>();
-		for (int i = 0; i < bigArrayList.size(); i++) {
-			expected.add(bigArrayList.get(i));
+		for (int i = 0; i < bal.size(); i++) {
+			expected.add(bal.get(i));
 		}
 		
 		List<Integer> actual = new ArrayList<>();
-		for (int i : bigArrayList) {
+		for (int i : bal) {
 			actual.add(i);
 		}
 		
 		assertIterableEquals(expected, actual);
+		try {
+			bal.clearMemory();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	@Test
+	public void testAddAll() {
+		BigArrayList<Integer> actual = new BigArrayList<>();
+		List<Integer> expected = new ArrayList<>();
+		
+		for (int i = 0; i < 1000; i++) {
+			int randomInt = random.nextInt();
+			actual.add(randomInt);
+			expected.add(randomInt);
+		}
+		
+		List<Integer> toAdd = new ArrayList<>();
+		
+		for (int i = 0; i < 1000; i++) {
+			int randomInt = random.nextInt();
+			toAdd.add(randomInt);
+		}
+		
+		actual.addAll(toAdd);
+		expected.addAll(toAdd);
+		
+		assertIterableEquals(expected, actual);
+		try {
+			actual.clearMemory();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	@Test
+	public void testClear() {
+		BigArrayList<Integer> actual = new BigArrayList<>();
+		List<Integer> expected = new ArrayList<>();
+		
+		for (int i = 0; i < 1000; i++) {
+			int randomInt = random.nextInt();
+			actual.add(randomInt);
+			expected.add(randomInt);
+		}
+		
+		actual.clear();
+		expected.clear();
+		
+		assertTrue(actual.isLive());
+		assertTrue(actual.isEmpty());
+	}
+	
+	@Test
+	public void testEquals() {
+		BigArrayList<Integer> actual = new BigArrayList<>();
+		BigArrayList<Integer> expected = new BigArrayList<>();
+		for (int i = 0; i < 1000; i++) {
+			int randomInt = random.nextInt();
+			actual.add(randomInt);
+			expected.add(randomInt);
+		}
+
+		assertEquals(expected, actual);
+		
+		try {
+			actual.clearMemory();
+			expected.clearMemory();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
 	}
 }