canonical example by Tabnine
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" }
List<String> list = new ArrayList<String>(); //add some stuff list.add("android"); list.add("apple"); String[] stringArray = list.toArray(new String[0]);
List<String> stockList = new ArrayList<String>(); stockList.add("stock1"); stockList.add("stock2"); String[] stockArr = new String[stockList.size()]; stockArr = stockList.toArray(stockArr); for(String s : stockArr) System.out.println(s);
ArrayList<String> list = new ArrayList<String>(); list.add("A"); list.add("B"); list.add("C");
public class SortedList<E> extends AbstractList<E> { private ArrayList<E> internalList = new ArrayList<E>(); // Note that add(E e) in AbstractList is calling this one @Override public void add(int position, E e) { internalList.add(e); Collections.sort(internalList, null); } @Override public E get(int i) { return internalList.get(i); } @Override public int size() { return internalList.size(); } }
private List<String> percentDecode(List<String> list, boolean plusIsSpace) { int size = list.size(); List<String> result = new ArrayList<>(size); for (int i = 0; i < size; i++) { String s = list.get(i); result.add(s != null ? percentDecode(s, plusIsSpace) : null); } return Collections.unmodifiableList(result); }
List<String> strings = new ArrayList<String>() strings.add("lol"); strings.add("cat"); Collections.sort(strings); for (String s : strings) { System.out.println(s); } // Prints out "cat" and "lol"
public SortedSetSubsetTestSetGenerator( TestSortedSetGenerator<E> delegate, Bound to, Bound from) { this.to = to; this.from = from; this.delegate = delegate; SortedSet<E> emptySet = delegate.create(); this.comparator = emptySet.comparator(); SampleElements<E> samples = delegate.samples(); List<E> samplesList = new ArrayList<>(samples.asList()); Collections.sort(samplesList, comparator); this.firstInclusive = samplesList.get(0); this.lastInclusive = samplesList.get(samplesList.size() - 1); }
protected HandshakeInterceptor[] getInterceptors() { List<HandshakeInterceptor> interceptors = new ArrayList<>(this.interceptors.size() + 1); interceptors.addAll(this.interceptors); interceptors.add(new OriginHandshakeInterceptor(this.allowedOrigins)); return interceptors.toArray(new HandshakeInterceptor[0]); }
String[] arr = new String[1]; arr[0] = "rohit"; List<String> newList = Arrays.asList(arr); // Will throw `UnsupportedOperationException // newList.add("jain"); // Can't do this. ArrayList<String> updatableList = new ArrayList<String>(); updatableList.addAll(newList); updatableList.add("jain"); // OK this is fine. System.out.println(newList); // Prints [rohit] System.out.println(updatableList); //Prints [rohit, jain]
// Substitute appropriate type. ArrayList<...> a = new ArrayList<...>(); // Add elements to list. // Generate an iterator. Start just after the last element. ListIterator li = a.listIterator(a.size()); // Iterate in reverse. while(li.hasPrevious()) { System.out.println(li.previous()); }
@Test public void testGenericListOfArrays() throws MalformedURLException { GenericBean<String> gb = new GenericBean<>(); ArrayList<String[]> list = new ArrayList<>(); list.add(new String[] {"str1", "str2"}); gb.setListOfArrays(list); BeanWrapper bw = new BeanWrapperImpl(gb); bw.setPropertyValue("listOfArrays[0][1]", "str3 "); assertEquals("str3 ", bw.getPropertyValue("listOfArrays[0][1]")); assertEquals("str3 ", gb.getListOfArrays().get(0)[1]); }
@Test public void moreThanMaxWorkers() { final List<Worker> list = new ArrayList<Worker>(); SchedulerMultiWorkerSupport mws = (SchedulerMultiWorkerSupport)Schedulers.computation(); mws.createWorkers(max * 2, new WorkerCallback() { @Override public void onWorker(int i, Worker w) { list.add(w); } }); assertEquals(max * 2, list.size()); }
List<Person> people = new ArrayList<>(); people.add(new Person("Alice")); people.add(new Person("Bob")); System.out.println(people); // Prints [Alice, Bob]
ArrayList<String> aList = new ArrayList<String>(); aList.add("One"); String element = aList.get(0); // no cast needed System.out.println("Got one: " + element);
public static List<String> alpnProtocolNames(List<Protocol> protocols) { List<String> names = new ArrayList<>(protocols.size()); for (int i = 0, size = protocols.size(); i < size; i++) { Protocol protocol = protocols.get(i); if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN. names.add(protocol.toString()); } return names; }