Java Iterator类代码示例

import scala.collection.Iterator; //导入依赖的package包/类
private Seq<KoreanToken> convertPhrasesToTokens(Seq<KoreanPhrase> phrases) {
    KoreanToken[] tokens = new KoreanToken[phrases.length()];

    Iterator<KoreanPhrase> iterator = phrases.iterator();
    int i = 0;
    while (iterator.hasNext()) {
        KoreanPhrase phrase = iterator.next();
        tokens[i++] = new KoreanToken(phrase.text(), phrase.pos(), phrase.offset(), phrase.length(), scala.Option.apply(null), false);
    }

    Arrays.sort(tokens, (o1, o2) -> {
        if(o1.offset()== o2.offset())
            return 0;
        return o1.offset()< o2.offset()? -1 : 1;
    });

    return JavaConverters.asScalaBuffer(Arrays.asList(tokens)).toSeq();
}
 

import scala.collection.Iterator; //导入依赖的package包/类
public String getStringElements() {
	String elementsString = "\n  ----------------ELEMENTS---------------- \n";
	for(Map.Entry<String, Tuple2<String, List<Tuple2<String, Object>>>> entry : mapInfos.entrySet()) {
		String name = entry.getKey();
		elementsString += "\n  Element "+name+" ";
		Tuple2<String, List<Tuple2<String, Object>>> typeAndInfos = entry.getValue();
		String type = (String) typeAndInfos._1;
		elementsString += "("+type+") : \n";
		List<Tuple2<String, Object>> listInfos = (List<Tuple2<String, Object>>) typeAndInfos._2;
		Iterator<Tuple2<String, Object>> itInfos = listInfos.iterator();
		while(itInfos.hasNext()) {
			Tuple2<String, Object> infos = itInfos.next();
			String attribute = infos._1;
			String value = String.valueOf(infos._2);
			elementsString += "  * "+attribute+" : "+value+" \n";
		}
		elementsString += "  ---------------------------------------- \n";
	}
	return elementsString;
}
 

import scala.collection.Iterator; //导入依赖的package包/类
/**
 * 
 * @param sqlogger "Monte-Carlo" simulation results
 * @param model The instance of the SimQRi model
 * @deprecated
 * This method set simulation results to queries objects of the Sirius Metamodel instance. 
 * No longer used due to a too long time for setting results when there are a lot of queries
 */
@SuppressWarnings("unused")
private void setQueriesSamples(TraceLogger sqlogger, Model model) {
	Iterator<SamplingTuple> itProbes = sqlogger.logs().mcSamplings().probesSampling().iterator();
	while(itProbes.hasNext()) {
		SamplingTuple probes = itProbes.next();
		for(Query q : model.getQuery()) {
			if(q.getName().equals(probes.name())) {
				TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(q);
				domain.getCommandStack().execute(new RecordingCommand(domain) {
				   public void doExecute() {
					  // q.setResult("");
					  // q.setMax(String.format("%.2f", JsonFormat.jsonToDouble(probes.samplingStr(), "max")));
					  // q.setMin(String.format("%.2f", JsonFormat.jsonToDouble(probes.samplingStr(), "min")));
					  // q.setMean(String.format("%.2f", JsonFormat.jsonToDouble(probes.samplingStr(), "mean")));
					  // q.setVariance(String.valueOf(JsonFormat.jsonToDouble(probes.samplingStr(), "variance")));
				   }
				});
			}
		}
	}
}
 

import scala.collection.Iterator; //导入依赖的package包/类
@Override
public boolean matchBlock(final int side2, final int x2, final int y2, final int z2) {
    if (this.isOpaque) {
        final TileEntity tile_base = this.blockAccess.getTileEntity(x2, y2, z2);
        if (tile_base != null && tile_base instanceof TileMultipart) {
            final TileMultipart tile = (TileMultipart)tile_base;
            final Iterator<TMultiPart> parts = (Iterator<TMultiPart>)tile.partList().toIterator();
            while (parts.hasNext()) {
                final TMultiPart part = (TMultiPart)parts.next();
                if ((part instanceof FaceMicroblockClient || part instanceof HollowMicroblockClient) && (side2 == -1 || this.getSideFromBounds(((Microblock)part).getBounds()) == side2)) {
                    final ItemStack t = MicroMaterialRegistry.getMaterial(((Microblock)part).getMaterial()).getItem();
                    if (t.getItem() instanceof ItemBlock && this.curBlock == ((ItemBlock)t.getItem()).field_150939_a && t.getItemDamage() == this.curMeta) {
                        return true;
                    }
                    continue;
                }
            }
        }
    }
    return super.matchBlock(side2, x2, y2, z2);
}
 

import scala.collection.Iterator; //导入依赖的package包/类
public ProverExpr[] freeVariables(ProverExpr expr) {
  final ArrayList<ProverExpr> res = new ArrayList<ProverExpr> ();
  
  final scala.Tuple3<scala.collection.Set<IVariable>,
                      scala.collection.Set<ConstantTerm>,
                      scala.collection.Set<Predicate>> symTriple;
  if (expr instanceof TermExpr)
    symTriple = SymbolCollector$.MODULE$.varsConstsPreds(((TermExpr)expr).term);
  else
    symTriple = SymbolCollector$.MODULE$.varsConstsPreds(((FormulaExpr)expr).formula);
  
  final Iterator<IVariable> it1 = symTriple._1().iterator();
  while (it1.hasNext())
    res.add(new TermExpr(it1.next(), getIntType()));
  
  final Iterator<ConstantTerm> it2 = symTriple._2().iterator();
  while (it2.hasNext())
    res.add(new TermExpr(IConstant$.MODULE$.apply(it2.next()), getIntType()));
  
  final Iterator<Predicate> it3 = symTriple._3().iterator();
  final List<ITerm> emptyArgs = (new ArrayBuffer<ITerm>()).toList();
  while (it3.hasNext())
    res.add(new FormulaExpr(IAtom$.MODULE$.apply(it3.next(), emptyArgs)));
  
  return res.toArray(new ProverExpr[0]);
}
 

import scala.collection.Iterator; //导入依赖的package包/类
private void processQueryFunction(FilterOption option, String boolMethod) {
    BooleanMethodCallExpr methodCall = (BooleanMethodCallExpr) option.expression();
    assertThat(methodCall.methodName(), is(boolMethod));
    List<Expression> args = methodCall.args();
    Iterator iterator = args.iterator();
    while (iterator.hasNext()) {
        Object cursor = iterator.next();
        if (cursor instanceof EntityPathExpr) {
            EntityPathExpr pathExpr = (EntityPathExpr) cursor;
            PropertyPathExpr path = (PropertyPathExpr) pathExpr.subPath().get();
            assertThat(path.propertyName(), is("name"));
        } else if (cursor instanceof LiteralExpr) {
            LiteralExpr literalExpr = (LiteralExpr) cursor;
            StringLiteral stringLiteral = (StringLiteral) literalExpr.value();
            assertThat(stringLiteral.value(), is("John"));
        }
    }
}
 

import scala.collection.Iterator; //导入依赖的package包/类
private void testQueryFunction(String operator) throws ODataException {
    EqExpr expr = getExprFromOperator(operator);
    MethodCallExpr call = (MethodCallExpr) expr.left();
    assertThat(call.methodName(), is(operator));
    List<Expression> args = call.args();
    Iterator iter = args.iterator();
    while (iter.hasNext()) {
        Object obj = iter.next();
        if (obj instanceof EntityPathExpr) {
            EntityPathExpr entityPathExpr = (EntityPathExpr) obj;
            PropertyPathExpr propertyPath = (PropertyPathExpr) entityPathExpr.subPath().get();
            assertThat(propertyPath.propertyName(), is("name"));
        }
    }
    LiteralExpr literal = (LiteralExpr) expr.right();
    NumberLiteral number = (NumberLiteral) literal.value();
    assertThat(number.value(), is(new BigDecimal(new java.math.BigDecimal(19))));
}
 

import scala.collection.Iterator; //导入依赖的package包/类
@Override
protected ImmutableList<ValueAssignment> modelToList() {
  scala.collection.Map<ModelLocation, ModelValue> interpretation = model.interpretation();

  // first get the addresses of arrays
  Map<IdealInt, ITerm> arrays = getArrayAddresses(interpretation);

  // then iterate over the model and generate the assignments
  Builder<ValueAssignment> assignments = ImmutableSet.builder();
  Iterator<Tuple2<ModelLocation, ModelValue>> it2 = interpretation.iterator();
  while (it2.hasNext()) {
    Tuple2<ModelLocation, ModelValue> entry = it2.next();
    ValueAssignment assignment = getAssignment(entry._1, entry._2, arrays);
    if (assignment != null) {
      assignments.add(assignment);
    }
  }

  return assignments.build().asList();
}
 

import scala.collection.Iterator; //导入依赖的package包/类
/**
 * Collect array-models, we need them to replace identifiers later. Princess models arrays as
 * plain numeric "memory-addresses", and the model for an array-access at one of the addresses is
 * the array-content. Example: "arr[5]=123" is modeled as "{arr=0, select(0,5)=123}" or "{arr=0,
 * store(0,5,123)=0}", where "0" is the memory-address. The returned mapping contains the mapping
 * of "0" (=address) to "arr" (=identifier).
 */
private Map<IdealInt, ITerm> getArrayAddresses(
    scala.collection.Map<ModelLocation, ModelValue> interpretation) {
  Map<IdealInt, ITerm> arrays = new HashMap<>();
  Iterator<Tuple2<ModelLocation, ModelValue>> it1 = interpretation.iterator();
  while (it1.hasNext()) {
    Tuple2<ModelLocation, ModelValue> entry = it1.next();
    if (entry._1 instanceof ConstantLoc) {
      ITerm maybeArray = IExpression.i(((ConstantLoc) entry._1).c());
      if (creator.getEnv().hasArrayType(maybeArray) && entry._2 instanceof IntValue) {
        arrays.put(((IntValue) entry._2).v(), maybeArray);
      }
    }
  }
  return arrays;
}
 

import scala.collection.Iterator; //导入依赖的package包/类
@Override
public Option<Model> read(Class<?> modelClass, Map<String, String> typeMap) {
    final Option<Model> modelOption = super.read(modelClass, typeMap);

    // Look for public properties
    java.util.Map<String, ApiControllerUtilsServiceImpl.SerializationEntry> entries = ApiControllerUtilsServiceImpl.getSerializationEntries(modelClass,
            null);

    // Remove all properties which are not public
    if (!modelOption.isEmpty()) {
        Iterator<String> keysIterator = modelOption.get().properties().keysIterator();
        while (keysIterator.hasNext()) {
            String propertyName = keysIterator.next();
            if (!entries.containsKey(propertyName)) {
                modelOption.get().properties().remove(propertyName);
                if (log.isDebugEnabled()) {
                    log.debug("Successfully hidden API model property '" + propertyName + "'");
                }
            }
        }
    }

    return modelOption;
}
 

import scala.collection.Iterator; //导入依赖的package包/类
public void testMultipleNext() {
	Struct list = new Struct(new Term[] {new Int(0), new Int(1), new Int(2), new Int(3), new Int(5), new Int(7)});
	Iterator<? extends Term> i = list.iterator();
	assertTrue(i.hasNext());
	i.next(); // skip the first term
	assertEquals(new Int(1), i.next());
	assertEquals(new Int(2), i.next());
	assertEquals(new Int(3), i.next());
	assertEquals(new Int(5), i.next());
	assertEquals(new Int(7), i.next());
	// no more terms
	assertFalse(i.hasNext());
	try {
		i.next();
		fail();
	} catch (NoSuchElementException expected) {}
}
 

import scala.collection.Iterator; //导入依赖的package包/类
public void testMultipleNext() {
	String theory = "p(X):-q(X),X>1." + "\n" +
	                "q(1)." + "\n" +
					"q(2)." + "\n" +
					"q(3)." + "\n" +
					"q(5)." + "\n" +
					"q(7).";
	Iterator<Term> i = Term.getIterator(theory);
	assertTrue(i.hasNext());
	i.next(); // skip the first term
	assertEquals(new Struct("q", new Int(1)), i.next());
	assertEquals(new Struct("q", new Int(2)), i.next());
	assertEquals(new Struct("q", new Int(3)), i.next());
	assertEquals(new Struct("q", new Int(5)), i.next());
	assertEquals(new Struct("q", new Int(7)), i.next());
	// no more terms
	assertFalse(i.hasNext());
	try {
		i.next();
		fail();
	} catch (NoSuchElementException expected) {}
}
 

import scala.collection.Iterator; //导入依赖的package包/类
@Override
public BoxedUnit apply(Iterator<T> v1) {
    IExtractor<T, S> extractor;
    try {
        extractor = getExtractorInstance(config);
    } catch (DeepExtractorInitializationException e) {
        extractor = getExtractorClient();
    }

    extractor.initSave(config, first, queryBuilder);

    while (v1.hasNext()) {
        extractor.saveRDD(v1.next());
    }
    config.setPartitionId(config.getPartitionId() + 1);
    extractor.close();
    return null;
}
 

import scala.collection.Iterator; //导入依赖的package包/类
@Override
public Iterator<Tuple> call(Iterator<Tuple> i) {
    final java.util.Iterator<Tuple> tuples = JavaConversions.asJavaIterator(i);

    return JavaConversions.asScalaIterator(new POOutputConsumerIterator(tuples) {

        protected void attach(Tuple tuple) {
            poLimit.setInputs(null);
            poLimit.attachInput(tuple);
        }

        protected Result getNextResult() throws ExecException {
            return poLimit.getNextTuple();
        }
    });
}
 

import scala.collection.Iterator; //导入依赖的package包/类
public void addAcls(scala.collection.immutable.Set<Acl> acls, final Resource resource) {
    verifyAcls(acls);
    LOG.info("Adding Acl: acl->" + acls + " resource->" + resource);

    final Iterator<Acl> iterator = acls.iterator();
    while (iterator.hasNext()) {
        final Acl acl = iterator.next();
        final String role = getRole(acl);
        if (!roleExists(role)) {
            throw new KafkaException("Can not add Acl for non-existent Role: " + role);
        }
        execute(new Command<Void>() {
            @Override
            public Void run(SentryGenericServiceClient client) throws Exception {
                client.grantPrivilege(
                    requestorName, role, COMPONENT_NAME, toTSentryPrivilege(acl, resource));
                return null;
            }
        });
    }
}