canonical example by Tabnine
private static List<String> getComparableParameterNames( ExecutableElement element, boolean skipFirst) { List<? extends VariableElement> parameters = element.getParameters(); if (skipFirst) { parameters = parameters.subList(1, parameters.size()); } List<String> result = new ArrayList<>(parameters.size()); for (VariableElement parameter : parameters) { result.add(parameter.asType().toString()); } return result; }
@CollectionSize.Require(absent = {ZERO}) public void testSubList_isEmpty() { List<E> list = getList(); int size = getNumElements(); for (List<E> subList : Arrays.asList( list.subList(0, size), list.subList(0, size - 1), list.subList(1, size), list.subList(0, 0), list.subList(size, size))) { assertEquals(subList.size() == 0, subList.isEmpty()); } }
@Override public void setContents(List<Content> contentsBefore, List<Content> contentsAfter) { // Do nothing with contents after. List<Content> myContentsBefore = new ArrayList<>(contentsBefore.size() + contents.size()); myContentsBefore.addAll(contentsBefore); for (int i = contents.size() - 1; i >= 0; i--) { Content content = contents.get(i); content.setContents(myContentsBefore, contents.subList(0, i)); myContentsBefore.add(content); } }
@CollectionSize.Require(absent = {ZERO, ONE}) public void testSubList_get() { List<E> list = getList(); int size = getNumElements(); List<E> copy = list.subList(0, size); List<E> head = list.subList(0, size - 1); List<E> tail = list.subList(1, size); assertEquals(list.get(0), copy.get(0)); assertEquals(list.get(size - 1), copy.get(size - 1)); assertEquals(list.get(1), tail.get(0)); assertEquals(list.get(size - 1), tail.get(size - 2)); assertEquals(list.get(0), head.get(0)); assertEquals(list.get(size - 2), head.get(size - 2)); for (List<E> subList : Arrays.asList(copy, head, tail)) { for (int index : Arrays.asList(-1, subList.size())) { try { subList.get(index); fail("expected IndexOutOfBoundsException"); } catch (IndexOutOfBoundsException expected) { } } } }
Builder(Picasso picasso) { context = picasso.context; callFactory = picasso.callFactory; service = picasso.dispatcher.service; cache = picasso.cache; listener = picasso.listener; requestTransformers.addAll(picasso.requestTransformers); // See Picasso(). Removes internal request handlers added before and after custom handlers. int numRequestHandlers = picasso.requestHandlers.size(); requestHandlers.addAll(picasso.requestHandlers.subList(2, numRequestHandlers - 6)); defaultBitmapConfig = picasso.defaultBitmapConfig; indicatorsEnabled = picasso.indicatorsEnabled; loggingEnabled = picasso.loggingEnabled; }
private void addMention(int beginIdx, int endIdx, IndexedWord headword, List<Mention> mentions, Set<IntPair> mentionSpanSet, Set<IntPair> namedEntitySpanSet, List<CoreLabel> sent, SemanticGraph basic, SemanticGraph enhanced) { IntPair mSpan = new IntPair(beginIdx, endIdx); if(!mentionSpanSet.contains(mSpan) && (!insideNE(mSpan, namedEntitySpanSet)) ) { int dummyMentionId = -1; Mention m = new Mention(dummyMentionId, beginIdx, endIdx, sent, basic, enhanced, new ArrayList<>(sent.subList(beginIdx, endIdx))); m.headIndex = headword.index()-1; m.headWord = sent.get(m.headIndex); m.headString = m.headWord.word().toLowerCase(Locale.ENGLISH); mentions.add(m); mentionSpanSet.add(mSpan); } }
List<Integer> numbers = new ArrayList<Integer>( Arrays.asList(5,3,1,2,9,5,0,7) ); List<Integer> head = numbers.subList(0, 4); List<Integer> tail = numbers.subList(4, 8); System.out.println(head); // prints "[5, 3, 1, 2]" System.out.println(tail); // prints "[9, 5, 0, 7]" Collections.sort(head); System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7]" tail.add(-1); System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7, -1]"
@Override public List<T> next() { if (!hasNext()) { throw new NoSuchElementException(); } Object[] array = new Object[size]; int count = 0; for (; count < size && iterator.hasNext(); count++) { array[count] = iterator.next(); } for (int i = count; i < size; i++) { array[i] = null; // for GWT } @SuppressWarnings("unchecked") // we only put Ts in it List<T> list = Collections.unmodifiableList((List<T>) Arrays.asList(array)); return (pad || count == size) ? list : list.subList(0, count); } };
@CollectionSize.Require(absent = {ZERO, ONE}) public void testSubList_ofSubListNonEmpty() { List<E> subList = getList().subList(0, 2).subList(1, 2); assertEquals( "subList(0, 2).subList(1, 2) " + "should be a single-element list of the element at index 1", Collections.singletonList(getOrderedElements().get(1)), subList); }
/** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */ public void testSublistConcurrentModificationException() { ListMultimap<String, Integer> multimap = create(); multimap.putAll("foo", asList(1, 2, 3, 4, 5)); List<Integer> list = multimap.get("foo"); assertThat(multimap.get("foo")).containsExactly(1, 2, 3, 4, 5).inOrder(); List<Integer> sublist = list.subList(0, 5); assertThat(sublist).containsExactly(1, 2, 3, 4, 5).inOrder(); sublist.clear(); assertTrue(sublist.isEmpty()); multimap.put("foo", 6); try { sublist.isEmpty(); fail("Expected ConcurrentModificationException"); } catch (ConcurrentModificationException expected) { } }
ToOptionalState combine(ToOptionalState other) { if (element == null) { return other; } else if (other.element == null) { return this; } else { if (extras == null) { extras = new ArrayList<>(); } extras.add(other.element); if (other.extras != null) { this.extras.addAll(other.extras); } if (extras.size() > MAX_EXTRAS) { extras.subList(MAX_EXTRAS, extras.size()).clear(); throw multiples(true); } return this; } }
@Override public Type createType(TypeManager typeManager, List<TypeParameter> parameters) { checkArgument(parameters.size() >= 1, "Function type must have at least one parameter, got %s", parameters); checkArgument( parameters.stream().allMatch(parameter -> parameter.getKind() == ParameterKind.TYPE), "Expected only types as a parameters, got %s", parameters); List<Type> types = parameters.stream().map(TypeParameter::getType).collect(toList()); return new FunctionType(types.subList(0, types.size() - 1), types.get(types.size() - 1)); } }
@Override public List<E> objectsList() { List<E> result = new ArrayList<>(); if (result.size() > backingIndexSize) { // we told you not to do this result.addAll(backingIndex.objectsList().subList(0, backingIndexSize)); } else { result.addAll(backingIndex.objectsList()); } result.addAll(spilloverIndex.objectsList()); return Collections.unmodifiableList(result); }