How to use

ArrayList

in

java.util

private void usingArrayList() {
 ArrayList<String> list = new ArrayList<>(Arrays.asList("cat", "cow", "dog"));
 list.add("fish");
 int size = list.size(); // size = 4
 list.set(size - 1, "horse"); // replacing the last element to "horse"
 String removed = list.remove(1); // removed = "cow"
 String second = list.get(1); // second = "dog"
}

/**
 * Get all items
 */
public List<Item> getItems() {
 return new ArrayList<>(items);
}

 ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

@Override
public void add(int index, T element) {
  list.add(index, element);
  lazySet(list.size());
}

 @Test(expected=IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {
  ArrayList emptyList = new ArrayList();
  Object o = emptyList.get(0);
}

@Test
public void testNoBackpressure() {
  ArrayList<Long> list = new ArrayList<Long>(Flowable.bufferSize() * 2);
  for (long i = 1; i <= Flowable.bufferSize() * 2 + 1; i++) {
    list.add(i);
  }
  Observable<Long> o = Observable.rangeLong(1, list.size());
  TestObserver<Long> to = new TestObserver<Long>();
  o.subscribe(to);
  to.assertValueSequence(list);
  to.assertTerminated();
}

@CollectionSize.Require(absent = CollectionSize.ZERO)
@CollectionFeature.Require(ALLOWS_NULL_VALUES)
public void testEquals_containingNull() {
 ArrayList<E> elements = new ArrayList<>(getSampleElements());
 elements.set(elements.size() / 2, null);
 collection = getSubjectGenerator().create(elements.toArray());
 List<E> other = new ArrayList<>(getSampleElements());
 assertFalse(
   "Two Lists should not be equal if exactly one of them has null at a given index.",
   getList().equals(other));
}

@CollectionSize.Require(absent = CollectionSize.ZERO)
public void testEquals_otherListWithDifferentElements() {
 ArrayList<E> other = new ArrayList<>(getSampleElements());
 other.set(other.size() / 2, getSubjectGenerator().samples().e3());
 assertFalse(
   "A List should not equal another List containing different elements.",
   getList().equals(other));
}

 ArrayList<String> list = new ArrayList<String>() {{
  add("A");
  add("B");
  add("C");
}};

@Override
public boolean addAll(int index, Collection<? extends T> c) {
  boolean b = list.addAll(index, c);
  lazySet(list.size());
  return b;
}

@Override
public boolean remove(Object o) {
  boolean b = list.remove(o);
  lazySet(list.size());
  return b;
}

@Override
public boolean removeAll(Collection<?> c) {
  boolean b = list.removeAll(c);
  lazySet(list.size());
  return b;
}

@Override
public boolean retainAll(Collection<?> c) {
  boolean b = list.retainAll(c);
  lazySet(list.size());
  return b;
}

@Override
public T get(int index) {
  return list.get(index);
}

@Test
public void testNoBackpressure() {
  ArrayList<Integer> list = new ArrayList<Integer>(Flowable.bufferSize() * 2);
  for (int i = 1; i <= Flowable.bufferSize() * 2 + 1; i++) {
    list.add(i);
  }
  Observable<Integer> o = Observable.range(1, list.size());
  TestObserver<Integer> to = new TestObserver<Integer>();
  o.subscribe(to);
  to.assertValueSequence(list);
  to.assertTerminated();
}

  @Override
  public void accept(ArrayList<Integer> a, Integer b) throws Exception {
    a.add(b);
  }
}).toFlowable());

@Override
public boolean addAll(Collection<? extends T> c) {
  boolean b = list.addAll(c);
  lazySet(list.size());
  return b;
}

@Override
public T remove(int index) {
  T v = list.remove(index);
  lazySet(list.size());
  return v;
}

 List<String> list = new ArrayList<String>();
//add some stuff
list.add("android");
list.add("apple");
String[] stringArray = list.toArray(new String[0]);

 static <T> List<T> defensiveCopy(Iterable<T> iterable) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : iterable) {
   list.add(checkNotNull(element));
  }
  return list;
 }
}