I am implementing a generic List class and not getting the expected output.
My current output is: [0, 1, null]
Expected Output in a separate test class:
List list = new SparseList<>();
list.add("0");
list.add("1");
list.add(4, "4");
will result in the following list of size 5: [0, 1, null, null, 4].
list.add(3, "Three");
will result in the following list of size 6: [0, 1, null, Three, null, 4].
list.set(3, "Three");
is going to produce a list of size 5 (unchanged): [0, 1, null, Three, 4].
When removing an element from the list above, via list.remove(1); the result should be the following list of size 4: [0, null, Three, 4]
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class SparseList<E> implements List<E>{
private int endIndex = 0;
private HashMap<Integer,E> list;
public SparseList() {
list = new HashMap<>();
}
public SparseList(E[] arr) {
list = new HashMap<>();
for(int i = 0; i <arr.length; i++) {
list.put(i, arr[i]);
}
endIndex = arr.length - 1;
}
@Override
public boolean add(E e) {
list.put(endIndex, e);
endIndex++;
return true;
}
@Override
public void add(int index, E element) {
List<E> l = (List<E>) list.get(index);
if(l == null) {
l = new ArrayList<E>();
l.add(element);
list.put(index, (E) l);
} else {
if(!((List<E>) list).contains(element)) ((List<E>)
list).add(element);
}
}
@Override
public E remove(int index) {
return list.remove(index);
}
@Override
public E get(int index) {
return list.get(index);
}
@Override
public E set(int index, E element) {
E previous = list.get(index);
list.put(index, element);
return previous;
}
@Override
public int size() {
return endIndex + 1;
}
@Override
public void clear() {
list.clear();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public String toString() {
String s = "";
for(int i = 0; i < list.size(); i++) {
if(list.get(i) == null) {
s += "null, ";
}else {
s += list.get(i).toString() + ", ";
}
}
return "[" + s + "]";
}
@Override
public boolean contains(Object o) {
throw new UnsupportedOperationException();
}
@Override
public Iterator<E> iterator() {
throw new UnsupportedOperationException();
}
@Override
public Object[] toArray() {
throw new UnsupportedOperationException();
}
@Override
public <T> T[] toArray(T[] a) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(int index, Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public int indexOf(Object o) {
throw new UnsupportedOperationException();
}
@Override
public int lastIndexOf(Object o) {
throw new UnsupportedOperationException();
}
@Override
public ListIterator<E> listIterator() {
throw new UnsupportedOperationException();
}
@Override
public ListIterator<E> listIterator(int index) {
throw new UnsupportedOperationException();
}
@Override
public List<E> subList(int fromIndex, int toIndex) {
throw new UnsupportedOperationException();
}
}
