Java Iterator.hasNext方法代碼示例

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包/類
@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包/類
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;
            }
        });
    }
}
 

import scala.collection.Iterator; //導入方法依賴的package包/類
public boolean removeAcls(scala.collection.immutable.Set<Acl> acls, final Resource resource) {
    verifyAcls(acls);
    LOG.info("Removing Acl: acl->" + acls + " resource->" + resource);
    final Iterator<Acl> iterator = acls.iterator();
    while (iterator.hasNext()) {
        final Acl acl = iterator.next();
        final String role = getRole(acl);
        try {
            execute(new Command<Void>() {
                @Override
                public Void run(SentryGenericServiceClient client) throws Exception {
                    client.dropPrivilege(
                            requestorName, role, toTSentryPrivilege(acl, resource));
                    return null;
                }
            });
        } catch (KafkaException kex) {
            LOG.error("Failed to remove acls.", kex);
            return false;
        }
    }

    return true;
}
 

import scala.collection.Iterator; //導入方法依賴的package包/類
@Override
public double meanOfEdges() {
	String current = "WHERE (m." + KEY_TIMESTAMP_DELETE + " = "
			+ InternalMetadata.METADATA_NOT_DELETED_TIMESTAMP + ")";

	String querie = ALL_IDENTIFIER + " MATCH (i)-[:Link]-(l)-[:Meta]-(m) "
			+ current + " RETURN count(l) / count(distinct i ) as result";

	ExecutionResult result = executeQuery(querie);

	Iterator<Double> nodes = result.columnAs("result");

	if (nodes.hasNext()) {
		return nodes.next();
	}

	log.error("Error occured while counting!");
	throw new RuntimeException("Error occured while counting!");
}
 

import scala.collection.Iterator; //導入方法依賴的package包/類
@SuppressWarnings("rawtypes")
private void init(String swcPath) {
    File swcFile = new File(swcPath);
    TagContainer tagContainer = TagContainer.fromFile(swcFile);

    List<SwfTag> tagsScalaList = tagContainer.tags();
    Iterator tagsScalaIterator = tagsScalaList.iterator();

    while (tagsScalaIterator.hasNext()) {
        SwfTag tag = (SwfTag) tagsScalaIterator.next();
        if (tag instanceof DoABC) {
            DoABC doABC = (DoABC) tag;
            Abc abc = Abc.fromDoABC(doABC);

            AbcScript[] abcScripts = abc.scripts();
            for (AbcScript abcScript : abcScripts) {
                AbcTrait[] abcTraits = abcScript.traits();
                for (AbcTrait abcTrait : abcTraits) {
                    cacheTrait(abcTrait);
                }
            }
        }
    }
}