How to use

iterator

method

in

java.util.List

 List<String> list = new ArrayList<>();

// This is a clever way to create the iterator and call iterator.hasNext() like
// you would do in a while-loop. It would be the same as doing:
//     Iterator<String> iterator = list.iterator();
//     while (iterator.hasNext()) {
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
  String string = iterator.next();
  if (string.isEmpty()) {
    // Remove the current element from the iterator and the list.
    iterator.remove();
  }
}

public URL toUrl() {
  return urls.isEmpty() ? null : urls.iterator().next();
}

@Override
public String getPath() {
  StringBuilder pathBuilder = new StringBuilder();
  pathBuilder.append(PATH_DELIMITER);
  for (Iterator<String> iterator = this.pathSegments.iterator(); iterator.hasNext(); ) {
    String pathSegment = iterator.next();
    pathBuilder.append(pathSegment);
    if (iterator.hasNext()) {
      pathBuilder.append(PATH_DELIMITER);
    }
  }
  return pathBuilder.toString();
}

public void testAdvance_pastEnd() {
 List<String> list = newArrayList();
 list.add("a");
 list.add("b");
 Iterator<String> iterator = list.iterator();
 advance(iterator, 5);
 assertFalse(iterator.hasNext());
}

 private MethodSpec overrideGlideWithMethod(
   String packageName, TypeSpec generatedRequestManager, ExecutableElement methodToOverride) {
  ClassName generatedRequestManagerClassName =
    ClassName.get(packageName, generatedRequestManager.name);
  List<ParameterSpec> parameters = ProcessorUtil.getParameters(methodToOverride);
  Preconditions.checkArgument(
    parameters.size() == 1, "Expected size of 1, but got %s", methodToOverride);
  ParameterSpec parameter = parameters.iterator().next();

  Builder builder = MethodSpec.methodBuilder(methodToOverride.getSimpleName().toString())
    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
    .addJavadoc(processorUtil.generateSeeMethodJavadoc(methodToOverride))
    .addParameters(parameters)
    .returns(generatedRequestManagerClassName)
    .addStatement("return ($T) $T.$N($L)",
      generatedRequestManagerClassName, glideType,
      methodToOverride.getSimpleName().toString(),
      parameter.name);

  return addReturnAnnotations(builder, methodToOverride).build();
 }
}

  private void processInsertShardingCondition(final TableUnit tableUnit, final InsertShardingCondition shardingCondition, final List<String> expressions, final List<Object> parameters) {
    for (DataNode each : shardingCondition.getDataNodes()) {
      if (each.getDataSourceName().equals(tableUnit.getDataSourceName()) && each.getTableName().equals(tableUnit.getRoutingTables().iterator().next().getActualTableName())) {
        expressions.add(shardingCondition.getInsertValueExpression());
        parameters.addAll(shardingCondition.getParameters());
        return;
      }
    }
    if (shardingCondition.getDataNodes().isEmpty()) {
      expressions.add(shardingCondition.getInsertValueExpression());
      parameters.addAll(shardingCondition.getParameters());
    }
  }
}

public void testAdvance_basic() {
 List<String> list = newArrayList();
 list.add("a");
 list.add("b");
 Iterator<String> iterator = list.iterator();
 advance(iterator, 1);
 assertEquals("b", iterator.next());
}

public void testGetLast_basic() {
 List<String> list = newArrayList();
 list.add("a");
 list.add("b");
 assertEquals("b", getLast(list.iterator()));
}

public void testLeastOfIterator_ties() {
 Integer foo = new Integer(Integer.MAX_VALUE - 10);
 Integer bar = new Integer(Integer.MAX_VALUE - 10);
 assertNotSame(foo, bar);
 assertEquals(foo, bar);
 List<Integer> list = Arrays.asList(3, foo, bar, -1);
 List<Integer> result = numberOrdering.leastOf(list.iterator(), list.size());
 assertEquals(ImmutableList.of(-1, 3, foo, bar), result);
}

public void testPartition_view() {
 List<Integer> list = asList(1, 2);
 Iterator<List<Integer>> partitions = Iterators.partition(list.iterator(), 1);
 // Changes before the partition is retrieved are reflected
 list.set(0, 3);
 List<Integer> first = partitions.next();
 // Changes after are not
 list.set(0, 4);
 assertEquals(ImmutableList.of(3), first);
}

public void testTransformRemove() {
 List<String> list = Lists.newArrayList("1", "2", "3");
 Iterator<String> input = list.iterator();
 Iterator<Integer> iterator =
   Iterators.transform(
     input,
     new Function<String, Integer>() {
      @Override
      public Integer apply(String from) {
       return Integer.valueOf(from);
      }
     });
 assertEquals(Integer.valueOf(1), iterator.next());
 assertEquals(Integer.valueOf(2), iterator.next());
 iterator.remove();
 assertEquals(asList("1", "3"), list);
}

public void testIteratorMinExhaustsIterator() {
 List<Integer> ints = Lists.newArrayList(9, 0, 3, 5);
 Iterator<Integer> iterator = ints.iterator();
 assertEquals(0, (int) numberOrdering.min(iterator));
 assertFalse(iterator.hasNext());
}

public static void remove(List<InsnNode> list, InsnNode insn) {
  for (Iterator<InsnNode> iterator = list.iterator(); iterator.hasNext(); ) {
    InsnNode next = iterator.next();
    if (next == insn) {
      iterator.remove();
      return;
    }
  }
}

public void testGet_basic() {
 List<String> list = newArrayList();
 list.add("a");
 list.add("b");
 Iterator<String> iterator = list.iterator();
 assertEquals("b", get(iterator, 1));
 assertFalse(iterator.hasNext());
}

@Test
public void configureMessageConvertersCustomAndDefault() {
  final MessageConverter testConverter = mock(MessageConverter.class);
  AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig() {
    @Override
    protected boolean configureMessageConverters(List<MessageConverter> messageConverters) {
      messageConverters.add(testConverter);
      return true;
    }
  };
  CompositeMessageConverter compositeConverter = config.brokerMessageConverter();
  assertThat(compositeConverter.getConverters().size(), Matchers.is(4));
  Iterator<MessageConverter> iterator = compositeConverter.getConverters().iterator();
  assertThat(iterator.next(), Matchers.is(testConverter));
  assertThat(iterator.next(), Matchers.instanceOf(StringMessageConverter.class));
  assertThat(iterator.next(), Matchers.instanceOf(ByteArrayMessageConverter.class));
  assertThat(iterator.next(), Matchers.instanceOf(MappingJackson2MessageConverter.class));
}

  public static <T> void printList(List<T> list) {
    Log.info("PrintList:");
    Iterator<T> it = list.iterator();
    while (it.hasNext()) {
      Log.info(it.next().toString());
    }

  }
}

public URL toUrl() {
  return urls.isEmpty() ? null : urls.iterator().next();
}

public void testAny() {
 List<String> list = Lists.newArrayList();
 Predicate<String> predicate = Predicates.equalTo("pants");
 assertFalse(Iterators.any(list.iterator(), predicate));
 list.add("cool");
 assertFalse(Iterators.any(list.iterator(), predicate));
 list.add("pants");
 assertTrue(Iterators.any(list.iterator(), predicate));
}

public void testLeastOfIterator_simple_nMinusOne() {
 List<Integer> list = Arrays.asList(3, 4, 5, -1);
 List<Integer> result = numberOrdering.leastOf(list.iterator(), list.size() - 1);
 assertTrue(result instanceof RandomAccess);
 assertListImmutable(result);
 assertEquals(ImmutableList.of(-1, 3, 4), result);
}

public void testPaddedPartition_view() {
 List<Integer> list = asList(1, 2);
 Iterator<List<Integer>> partitions = Iterators.paddedPartition(list.iterator(), 1);
 // Changes before the PaddedPartition is retrieved are reflected
 list.set(0, 3);
 List<Integer> first = partitions.next();
 // Changes after are not
 list.set(0, 4);
 assertEquals(ImmutableList.of(3), first);
}