TestMu Conference is Back! Future of Testing + AI
How to use remove method of org.assertj.core.test.jdk11.ImmutableCollections class
Best Assertj code snippet using org.assertj.core.test.jdk11.ImmutableCollections.remove
Source:ImmutableCollections.java 
...79 public void clear() {80 throw uoe();81 }82 @Override83 public boolean remove(Object o) {84 throw uoe();85 }86 @Override87 public boolean removeAll(Collection<?> c) {88 throw uoe();89 }90 @Override91 public boolean removeIf(Predicate<? super E> filter) {92 throw uoe();93 }94 @Override95 public boolean retainAll(Collection<?> c) {96 throw uoe();97 }98 }99 // ---------- List Implementations ----------100 // make a copy, short-circuiting based on implementation class101 @SuppressWarnings("unchecked")102 static <E> List<E> listCopy(Collection<? extends E> coll) {103 if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {104 return (List<E>) coll;105 } else {106 return (List<E>) Jdk11.List.of(coll.toArray());107 }108 }109 @SuppressWarnings("unchecked")110 static <E> List<E> emptyList() {111 return (List<E>) ListN.EMPTY_LIST;112 }113 static abstract class AbstractImmutableList<E> extends AbstractImmutableCollection<E>114 implements List<E>, RandomAccess {115 // all mutating methods throw UnsupportedOperationException116 @Override117 public void add(int index, E element) {118 throw uoe();119 }120 @Override121 public boolean addAll(int index, Collection<? extends E> c) {122 throw uoe();123 }124 @Override125 public E remove(int index) {126 throw uoe();127 }128 @Override129 public void replaceAll(UnaryOperator<E> operator) {130 throw uoe();131 }132 @Override133 public E set(int index, E element) {134 throw uoe();135 }136 @Override137 public void sort(Comparator<? super E> c) {138 throw uoe();139 }140 @Override141 public List<E> subList(int fromIndex, int toIndex) {142 int size = size();143 subListRangeCheck(fromIndex, toIndex, size);144 return SubList.fromList(this, fromIndex, toIndex);145 }146 static void subListRangeCheck(int fromIndex, int toIndex, int size) {147 if (fromIndex < 0)148 throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);149 if (toIndex > size)150 throw new IndexOutOfBoundsException("toIndex = " + toIndex);151 if (fromIndex > toIndex)152 throw new IllegalArgumentException("fromIndex(" + fromIndex +153 ") > toIndex(" + toIndex + ")");154 }155 @Override156 public Iterator<E> iterator() {157 return new ListItr<E>(this, size());158 }159 @Override160 public ListIterator<E> listIterator() {161 return listIterator(0);162 }163 @Override164 public ListIterator<E> listIterator(final int index) {165 int size = size();166 if (index < 0 || index > size) {167 throw outOfBounds(index);168 }169 return new ListItr<E>(this, size, index);170 }171 @Override172 public boolean equals(Object o) {173 if (o == this) {174 return true;175 }176 if (!(o instanceof List)) {177 return false;178 }179 Iterator<?> oit = ((List<?>) o).iterator();180 for (int i = 0, s = size(); i < s; i++) {181 if (!oit.hasNext() || !get(i).equals(oit.next())) {182 return false;183 }184 }185 return !oit.hasNext();186 }187 @Override188 public int indexOf(Object o) {189 Objects.requireNonNull(o);190 for (int i = 0, s = size(); i < s; i++) {191 if (o.equals(get(i))) {192 return i;193 }194 }195 return -1;196 }197 @Override198 public int lastIndexOf(Object o) {199 Objects.requireNonNull(o);200 for (int i = size() - 1; i >= 0; i--) {201 if (o.equals(get(i))) {202 return i;203 }204 }205 return -1;206 }207 @Override208 public int hashCode() {209 int hash = 1;210 for (int i = 0, s = size(); i < s; i++) {211 hash = 31 * hash + get(i).hashCode();212 }213 return hash;214 }215 @Override216 public boolean contains(Object o) {217 return indexOf(o) >= 0;218 }219 IndexOutOfBoundsException outOfBounds(int index) {220 return new IndexOutOfBoundsException("Index: " + index + " Size: " + size());221 }222 }223 static final class ListItr<E> implements ListIterator<E> {224 private final List<E> list;225 private final int size;226 private final boolean isListIterator;227 private int cursor;228 ListItr(List<E> list, int size) {229 this.list = list;230 this.size = size;231 this.cursor = 0;232 isListIterator = false;233 }234 ListItr(List<E> list, int size, int index) {235 this.list = list;236 this.size = size;237 this.cursor = index;238 isListIterator = true;239 }240 public boolean hasNext() {241 return cursor != size;242 }243 public E next() {244 try {245 int i = cursor;246 E next = list.get(i);247 cursor = i + 1;248 return next;249 } catch (IndexOutOfBoundsException e) {250 throw new NoSuchElementException();251 }252 }253 public void remove() {254 throw uoe();255 }256 public boolean hasPrevious() {257 if (!isListIterator) {258 throw uoe();259 }260 return cursor != 0;261 }262 public E previous() {263 if (!isListIterator) {264 throw uoe();265 }266 try {267 int i = cursor - 1;268 E previous = list.get(i);269 cursor = i;270 return previous;271 } catch (IndexOutOfBoundsException e) {272 throw new NoSuchElementException();273 }274 }275 public int nextIndex() {276 if (!isListIterator) {277 throw uoe();278 }279 return cursor;280 }281 public int previousIndex() {282 if (!isListIterator) {283 throw uoe();284 }285 return cursor - 1;286 }287 public void set(E e) {288 throw uoe();289 }290 public void add(E e) {291 throw uoe();292 }293 }294 static final class SubList<E> extends AbstractImmutableList<E>295 implements RandomAccess {296 private final List<E> root;297 private final int offset;298 private final int size;299 private SubList(List<E> root, int offset, int size) {300 this.root = root;301 this.offset = offset;302 this.size = size;303 }304 /**305 * Constructs a sublist of another SubList.306 */307 static <E> SubList<E> fromSubList(SubList<E> parent, int fromIndex, int toIndex) {308 return new SubList<>(parent.root, parent.offset + fromIndex, toIndex - fromIndex);309 }310 /**311 * Constructs a sublist of an arbitrary AbstractImmutableList, which is312 * not a SubList itself.313 */314 static <E> SubList<E> fromList(List<E> list, int fromIndex, int toIndex) {315 return new SubList<>(list, fromIndex, toIndex - fromIndex);316 }317 public E get(int index) {318 // Replacement for Objects.checkIndex(index, size);319 if (index < 0 || index >= size) {320 throw new IndexOutOfBoundsException(String.format("Index %s out of bounds for length %s", index, size));321 }322 return root.get(offset + index);323 }324 public int size() {325 return size;326 }327 public Iterator<E> iterator() {328 return new ListItr<>(this, size());329 }330 public ListIterator<E> listIterator(int index) {331 rangeCheck(index);332 return new ListItr<>(this, size(), index);333 }334 public List<E> subList(int fromIndex, int toIndex) {335 subListRangeCheck(fromIndex, toIndex, size);336 return SubList.fromSubList(this, fromIndex, toIndex);337 }338 private void rangeCheck(int index) {339 if (index < 0 || index > size) {340 throw outOfBounds(index);341 }342 }343 }344 static final class List12<E> extends AbstractImmutableList<E>345 implements Serializable {346 private final E e0;347 private final E e1;348 List12(E e0) {349 this.e0 = Objects.requireNonNull(e0);350 this.e1 = null;351 }352 List12(E e0, E e1) {353 this.e0 = Objects.requireNonNull(e0);354 this.e1 = Objects.requireNonNull(e1);355 }356 @Override357 public int size() {358 return e1 != null ? 2 : 1;359 }360 @Override361 public E get(int index) {362 if (index == 0) {363 return e0;364 } else if (index == 1 && e1 != null) {365 return e1;366 }367 throw outOfBounds(index);368 }369 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {370 throw new InvalidObjectException("not serial proxy");371 }372 private Object writeReplace() {373 if (e1 == null) {374 return new CollSer(CollSer.IMM_LIST, e0);375 } else {376 return new CollSer(CollSer.IMM_LIST, e0, e1);377 }378 }379 }380 static final class ListN<E> extends AbstractImmutableList<E>381 implements Serializable {382 // EMPTY_LIST may be initialized from the CDS archive.383 static List<?> EMPTY_LIST;384 static {385 // VM.initializeFromArchive(ListN.class);386 if (EMPTY_LIST == null) {387 EMPTY_LIST = new ListN<>();388 }389 }390 private final E[] elements;391 @SafeVarargs392 ListN(E... input) {393 // copy and check manually to avoid TOCTOU394 @SuppressWarnings("unchecked")395 E[] tmp = (E[]) new Object[input.length]; // implicit nullcheck of input396 for (int i = 0; i < input.length; i++) {397 tmp[i] = Objects.requireNonNull(input[i]);398 }399 elements = tmp;400 }401 @Override402 public boolean isEmpty() {403 return size() == 0;404 }405 @Override406 public int size() {407 return elements.length;408 }409 @Override410 public E get(int index) {411 return elements[index];412 }413 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {414 throw new InvalidObjectException("not serial proxy");415 }416 private Object writeReplace() {417 return new CollSer(CollSer.IMM_LIST, elements);418 }419 }420 // ---------- Set Implementations ----------421 static abstract class AbstractImmutableSet<E> extends AbstractImmutableCollection<E>422 implements Set<E> {423 @Override424 public boolean equals(Object o) {425 if (o == this) {426 return true;427 } else if (!(o instanceof Set)) {428 return false;429 }430 Collection<?> c = (Collection<?>) o;431 if (c.size() != size()) {432 return false;433 }434 for (Object e : c) {435 if (e == null || !contains(e)) {436 return false;437 }438 }439 return true;440 }441 @Override442 public abstract int hashCode();443 }444 @SuppressWarnings("unchecked")445 static <E> Set<E> emptySet() {446 return (Set<E>) SetN.EMPTY_SET;447 }448 static final class Set12<E> extends AbstractImmutableSet<E>449 implements Serializable {450 final E e0;451 final E e1;452 Set12(E e0) {453 this.e0 = Objects.requireNonNull(e0);454 this.e1 = null;455 }456 Set12(E e0, E e1) {457 if (e0.equals(Objects.requireNonNull(e1))) { // implicit nullcheck of e0458 throw new IllegalArgumentException("duplicate element: " + e0);459 }460 this.e0 = e0;461 this.e1 = e1;462 }463 @Override464 public int size() {465 return (e1 == null) ? 1 : 2;466 }467 @Override468 public boolean contains(Object o) {469 return o.equals(e0) || o.equals(e1); // implicit nullcheck of o470 }471 @Override472 public int hashCode() {473 return e0.hashCode() + (e1 == null ? 0 : e1.hashCode());474 }475 @Override476 public Iterator<E> iterator() {477 return new Iterator<E>() {478 private int idx = size();479 @Override480 public boolean hasNext() {481 return idx > 0;482 }483 @Override484 public E next() {485 if (idx == 1) {486 idx = 0;487 return SALT >= 0 || e1 == null ? e0 : e1;488 } else if (idx == 2) {489 idx = 1;490 return SALT >= 0 ? e1 : e0;491 } else {492 throw new NoSuchElementException();493 }494 }495 };496 }497 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {498 throw new InvalidObjectException("not serial proxy");499 }500 private Object writeReplace() {501 if (e1 == null) {502 return new CollSer(CollSer.IMM_SET, e0);503 } else {504 return new CollSer(CollSer.IMM_SET, e0, e1);505 }506 }507 }508 /**509 * An array-based Set implementation. The element array must be strictly510 * larger than the size (the number of contained elements) so that at511 * least one null is always present.512 * @param <E> the element type513 */514 static final class SetN<E> extends AbstractImmutableSet<E>515 implements Serializable {516 // EMPTY_SET may be initialized from the CDS archive.517 static Set<?> EMPTY_SET;518 static {519 // VM.initializeFromArchive(SetN.class);520 if (EMPTY_SET == null) {521 EMPTY_SET = new SetN<>();522 }523 }524 final E[] elements;525 final int size;526 @SafeVarargs527 @SuppressWarnings("unchecked")528 SetN(E... input) {529 size = input.length; // implicit nullcheck of input530 elements = (E[]) new Object[EXPAND_FACTOR * input.length];531 for (int i = 0; i < input.length; i++) {532 E e = input[i];533 int idx = probe(e); // implicit nullcheck of e534 if (idx >= 0) {535 throw new IllegalArgumentException("duplicate element: " + e);536 } else {537 elements[-(idx + 1)] = e;538 }539 }540 }541 @Override542 public int size() {543 return size;544 }545 @Override546 public boolean contains(Object o) {547 Objects.requireNonNull(o);548 return size > 0 && probe(o) >= 0;549 }550 private final class SetNIterator implements Iterator<E> {551 private int remaining;552 private int idx;553 SetNIterator() {554 remaining = size();555 if (remaining > 0) {556 idx = Math.floorMod(SALT, elements.length);557 }558 }559 @Override560 public boolean hasNext() {561 return remaining > 0;562 }563 private int nextIndex() {564 int idx = this.idx;565 if (SALT >= 0) {566 if (++idx >= elements.length) {567 idx = 0;568 }569 } else {570 if (--idx < 0) {571 idx = elements.length - 1;572 }573 }574 return this.idx = idx;575 }576 @Override577 public E next() {578 if (hasNext()) {579 E element;580 // skip null elements581 while ((element = elements[nextIndex()]) == null) {}582 remaining--;583 return element;584 } else {585 throw new NoSuchElementException();586 }587 }588 }589 @Override590 public Iterator<E> iterator() {591 return new SetN<E>.SetNIterator();592 }593 @Override594 public int hashCode() {595 int h = 0;596 for (E e : elements) {597 if (e != null) {598 h += e.hashCode();599 }600 }601 return h;602 }603 // returns index at which element is present; or if absent,604 // (-i - 1) where i is location where element should be inserted.605 // Callers are relying on this method to perform an implicit nullcheck606 // of pe607 private int probe(Object pe) {608 int idx = Math.floorMod(pe.hashCode(), elements.length);609 while (true) {610 E ee = elements[idx];611 if (ee == null) {612 return -idx - 1;613 } else if (pe.equals(ee)) {614 return idx;615 } else if (++idx == elements.length) {616 idx = 0;617 }618 }619 }620 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {621 throw new InvalidObjectException("not serial proxy");622 }623 private Object writeReplace() {624 Object[] array = new Object[size];625 int dest = 0;626 for (Object o : elements) {627 if (o != null) {628 array[dest++] = o;629 }630 }631 return new CollSer(CollSer.IMM_SET, array);632 }633 }634 // ---------- Map Implementations ----------635 @SuppressWarnings("unchecked")636 static <K, V> Map<K, V> emptyMap() {637 return (Map<K, V>) MapN.EMPTY_MAP;638 }639 abstract static class AbstractImmutableMap<K, V> extends AbstractMap<K, V> implements Serializable {640 @Override641 public void clear() {642 throw uoe();643 }644 @Override645 public V compute(K key, BiFunction<? super K, ? super V, ? extends V> rf) {646 throw uoe();647 }648 @Override649 public V computeIfAbsent(K key, Function<? super K, ? extends V> mf) {650 throw uoe();651 }652 @Override653 public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> rf) {654 throw uoe();655 }656 @Override657 public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> rf) {658 throw uoe();659 }660 @Override661 public V put(K key, V value) {662 throw uoe();663 }664 @Override665 public void putAll(Map<? extends K, ? extends V> m) {666 throw uoe();667 }668 @Override669 public V putIfAbsent(K key, V value) {670 throw uoe();671 }672 @Override673 public V remove(Object key) {674 throw uoe();675 }676 @Override677 public boolean remove(Object key, Object value) {678 throw uoe();679 }680 @Override681 public V replace(K key, V value) {682 throw uoe();683 }684 @Override685 public boolean replace(K key, V oldValue, V newValue) {686 throw uoe();687 }688 @Override689 public void replaceAll(BiFunction<? super K, ? super V, ? extends V> f) {690 throw uoe();691 }...
remove
Using AI Code Generation
1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3import java.util.Map;4import java.util.Set;5import java.util.SortedMap;6import java.util.SortedSet;7import java.util.stream.Collectors;8import java.util.stream.Stream;9import static org.assertj.core.api.Assertions.assertThat;10import static org.assertj.core.test.jdk11.ImmutableCollections.immutableListOf;11import static org.assertj.core.test.jdk11.ImmutableCollections.immutableMapOf;12import static org.assertj.core.test.jdk11.ImmutableCollections.immutableSetOf;13import static org.assertj.core.test.jdk11.ImmutableCollections.immutableSortedMapOf;14import static org.assertj.core.test.jdk11.ImmutableCollections.immutableSortedSetOf;15import static org.assertj.core.test.jdk11.ImmutableCollections.listOf;16import static org.assertj.core.test.jdk11.ImmutableCollections.mapOf;17import static org.assertj.core.test.jdk11.ImmutableCollections.setOf;18import static org.assertj.core.test.jdk11.ImmutableCollections.sortedMapOf;19import static org.assertj.core.test.jdk11.ImmutableCollections.sortedSetOf;20public class ImmutableCollectionsTest {21 public void should_remove_elements_from_list() {22 List<Integer> list = listOf(1, 2, 3, 4, 5);23 List<Integer> result = ImmutableCollections.remove(list, 3);24 assertThat(result).containsExactly(1, 2, 4, 5);25 }26 public void should_remove_elements_from_immutable_list() {27 List<Integer> list = immutableListOf(1, 2, 3, 4, 5);28 List<Integer> result = ImmutableCollections.remove(list, 3);29 assertThat(result).containsExactly(1, 2, 4, 5);30 }31 public void should_remove_elements_from_set() {32 Set<Integer> set = setOf(1, 2, 3, 4, 5);33 Set<Integer> result = ImmutableCollections.remove(set, 3);34 assertThat(result).containsExactly(1, 2, 4, 5);35 }36 public void should_remove_elements_from_immutable_set() {
remove
Using AI Code Generation
1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3import java.util.Set;4import java.util.Map;5import java.util.Collection;6import java.util.Collections;7import java.util.ArrayList;8import java.util.HashSet;9import java.util.HashMap;10import java.util.Arrays;11import java.util.function.Consumer;12import java.util.function.Supplier;13public class ImmutableCollectionsTest {14 public static void main(String[] args) {15 testList();16 testSet();17 testMap();18 }19 private static void testList() {20 List<Integer> list = Arrays.asList(1, 2, 3);21 List<Integer> immutableList = ImmutableCollections.copy(list);22 System.out.println(immutableList);
remove
Using AI Code Generation
1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3public class Test {4 public static void main(String[] args) {5 List<String> list = List.of("a", "b", "c");6 System.out.println(ImmutableCollections.remove(list, "a"));7 }8}
remove
Using AI Code Generation
1import static org.assertj.core.test.jdk11.ImmutableCollections.remove;2import java.util.List;3import java.util.stream.Collectors;4import java.util.stream.Stream;5public class ImmutableCollectionsExample {6 public static void main(String[] args) {7 List<String> list = Stream.of("A", "B", "C").collect(Collectors.toList());8 System.out.println(list);9 List<String> newList = remove(list, "B");10 System.out.println(newList);11 }12}13public static <E> List<E> remove(List<E> list, E element) {14 List<E> newList = new ArrayList<>(list);15 newList.remove(element);16 return newList;17}18public boolean remove(Object o) {19 throw new UnsupportedOperationException();20}21public static <E> List<E> remove(List<E> list, E element) {22 List<E> newList = new ArrayList<>(list);23 newList.remove(element);24 return newList;25}
remove
Using AI Code Generation
1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3import java.util.stream.Collectors;4import java.util.stream.IntStream;5List<Integer> list = IntStream.rangeClosed(1, 10).boxed().collect(Collectors.toList());6System.out.println("list: " + list);7List<Integer> newList = ImmutableCollections.remove(list, 5);8System.out.println("newList: " + newList);9System.out.println("list: " + list);
remove
Using AI Code Generation
1public void testRemove() {2 List<String> list = ImmutableCollections.listOf("one", "two", "three");3 assertThat(list).containsExactly("one", "two", "three");4 List<String> listWithoutTwo = ImmutableCollections.remove(list, "two");5 assertThat(listWithoutTwo).containsExactly("one", "three");6}7The following image shows the testRemove() method in the IntelliJ IDEA editor:
remove
Using AI Code Generation
1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3import java.util.ArrayList;4import java.util.Arrays;5import org.assertj.core.api.Assertions;6class Test {7 public static void main(String[] args) {8 List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));9 List<String> immutableList = ImmutableCollections.remove(list, 1);10 Assertions.assertThat(immutableList).containsExactly("a", "c");11 }12}13[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ assertj-core-jdk11 ---
remove
Using AI Code Generation
1@DisplayName("remove method should remove the element from the list")2void should_remove_element_from_list() {3 List<String> list = ImmutableCollections.list("a", "b", "c");4 List<String> removedList = ImmutableCollections.remove(list, "a");5 assertThat(removedList).containsExactly("b", "c");6}7@DisplayName("remove method should remove the element from the set")8void should_remove_element_from_set() {9 Set<String> set = ImmutableCollections.set("a", "b", "c");10 Set<String> removedSet = ImmutableCollections.remove(set, "a");11 assertThat(removedSet).containsExactly("b", "c");12}13@DisplayName("remove method should remove the element from the map")14void should_remove_element_from_map() {15 Map<String, String> map = ImmutableCollections.map("a", "a", "b", "b", "c", "c");16 Map<String, String> removedMap = ImmutableCollections.remove(map, "a");17 assertThat(removedMap).containsExactly(entry("b", "b"), entry("c", "c"));18}19@DisplayName("remove method should remove the element from the multimap")20void should_remove_element_from_multimap() {21 Multimap<String, String> multimap = ImmutableCollections.multimap("a", "a", "b", "b", "c", "c");22 Multimap<String, String> removedMultimap = ImmutableCollections.remove(multimap, "a");23 assertThat(removedMultimap).containsExactly(entry("a", "a"), entry("b", "b"), entry("c", "c"));24}25@DisplayName("remove method should remove the element from the multiset")26void should_remove_element_from_multiset() {27 Multiset<String> multiset = ImmutableCollections.multiset("a", "b", "c");28 Multiset<String> removedMultiset = ImmutableCollections.remove(multiset, "a");29 assertThat(removedMultiset).containsExactly("b", "c");30}31@DisplayName("remove method should remove the element from the list")32void should_remove_element_from_list() {33 List<String> list = ImmutableCollections.list("a", "b", "c");34 List<String> removedList = ImmutableCollections.remove(list, "a");35 assertThat(removedList).containsExactly("b", "c");36}37@DisplayName("
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Assertj automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in ImmutableCollections
- ImmutableCollections
- addAll
- clear
- remove
- removeAll
- removeIf
- retainAll
- replaceAll
- sort
- subList
- iterator
- listIterator
- equals
- indexOf
- lastIndexOf
- hashCode
- contains
- hasNext
- next
- hasPrevious
- previous
- nextIndex
- previousIndex
- size
- rangeCheck
- readObject
- writeReplace
- isEmpty
- probe
- compute
- computeIfAbsent
- computeIfPresent
- merge
- putAll
- putIfAbsent
- replace
- entrySet
- containsKey
- containsValue
- writeObject
- readResolve
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
