下面列出了java.util.LinkedList#add ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public Hypothesis subsume(Hypothesis otherHypothesis) {
LinkedList<Literal> newLiterals = new LinkedList<>();
for (Literal otherLiteral : otherHypothesis.literalMap.values()) {
Literal correspondingLiteral = literalMap.get(otherLiteral.getAttribute());
if (correspondingLiteral == null) {
continue;
}
if (otherLiteral.equals(correspondingLiteral)) {
newLiterals.add(otherLiteral);
continue;
}
if (otherLiteral.contradicts(literalMap.get(otherLiteral.getAttribute()))) {
return null;
}
}
return new Hypothesis(newLiterals);
}
@Override
public LineRenderer renderer(Iterator<Element> stream) {
if (stream.hasNext()) {
Element element = stream.next();
if (stream.hasNext()) {
LinkedList<LineRenderer> renderers = new LinkedList<LineRenderer>();
renderers.add(element.renderer());
while (stream.hasNext()) {
element = stream.next();
renderers.add(element.renderer());
}
return LineRenderer.vertical(renderers);
} else {
return element.renderer();
}
} else {
throw new UnsupportedOperationException("todo");
}
}
@Test
public void testCounterWithTimestampAndEmptyLine() {
String textToParse = "# Simple metric without labels:\n" +
"# TYPE metric_without_labels counter\n" +
"\n"+
"metric_without_labels 12.47 123456789012345600\n";
Parser subject = new Parser(textToParse);
HashMap<String, Collector.MetricFamilySamples> resultMap = subject.parse();
Enumeration<Collector.MetricFamilySamples> result = Collections.enumeration(resultMap.values());
// creating expected result
LinkedList<Collector.MetricFamilySamples> expectedList = new LinkedList<>();
List<Sample> samples = new LinkedList<>();
Sample sample = new Sample("metric_without_labels", new LinkedList<String>(), new LinkedList<String>(), 12.47);
samples.add(sample);
Collector.MetricFamilySamples expectedMFS = new Collector.MetricFamilySamples("metric_without_labels", Type.COUNTER, "", samples);
expectedList.add(expectedMFS);
Enumeration<Collector.MetricFamilySamples> expected = Collections.enumeration(expectedList);
// compare
compareEMFS(expected, result);
}
private LinkedList<Integer> backTrace(int n, int k, boolean[] used,
LinkedList<Integer> path) {
if (path.size() == n) {
++count;
return path;
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
used[i] = true;
path.add(i);
path = backTrace(n, k, used, path);
if (count == k) {
return path;
}
used[i] = false;
path.removeLast();
}
}
return path;
}
/**
* combine from other {@link ProfileStackNode}
*/
public ProfileStackNode combine(ProfileStackNode node) {
// combine this node
this.combineDetectedStacks(node);
// merge tree using LDR to traversal tree node
// using stack to avoid recursion
// merge key.children <- value.children
LinkedList<Pair<ProfileStackNode, ProfileStackNode>> stack = new LinkedList<>();
stack.add(new Pair<>(this, node));
while (!stack.isEmpty()) {
Pair<ProfileStackNode, ProfileStackNode> needCombineNode = stack.pop();
// merge value children to key
// add to stack if need to keep traversal
combineChildrenNodes(needCombineNode.key, needCombineNode.value, stack::add);
}
return this;
}
/**
* Sets the {@link #combo} field from a string.
* @param s the string
*/
public void comboFromString(String s) {
if (s == null)
return;
LinkedList<Color> colors = new LinkedList<Color>();
String[] tokens = s.split("\\|");
for (int i = 0; i < tokens.length; i++) {
String[] rgb = tokens[i].split(",");
colors.add(new Color(Integer.parseInt(rgb[0]), Integer.parseInt(rgb[1]), Integer.parseInt(rgb[2])));
}
if (!colors.isEmpty())
this.combo = colors.toArray(new Color[colors.size()]);
}
private static void writeList(LinkedList<Object> parcelData, InvocationOnMock invocation, List<Parcelable> list) {
if (list == null) {
parcelData.add(-1);
} else {
parcelData.add(list.size());
for (Parcelable item : list) {
writeParcelable(parcelData, item, (Parcel) invocation.getMock());
}
}
}
/**
* The function creates a ordered list of chemicals from src to dst.
*
* @param src - The src id
* @param dst - The dst id
* @return Returns a list of ids from src to dst.
*/
public LinkedList<Long> pathFromSrcToDerivativeOfSrc(Long src, Long dst) {
LinkedList<Long> result = new LinkedList<>();
Long id = dst;
result.add(id);
while (!id.equals(src)) {
Long newId = this.actData.getActTree().parents.get(id);
result.add(newId);
id = newId;
}
Collections.reverse(result);
return result;
}
public static List<AbstractInsnNode> insnListFindEnd(InsnList haystack, InsnList needle) {
LinkedList<AbstractInsnNode> callNodes = new LinkedList<AbstractInsnNode>();
for (int callPoint : insnListFind(haystack, needle)) {
callNodes.add(haystack.get(callPoint + needle.size() - 1));
}
return callNodes;
}
private void addLinkToMismatchMap(HashMap<String, HashMap<Integer, TreeSet<MismatchValueAndRelationship>>> map, String key1,
int key2, double mismatch, String relationshipID) {
if (map.containsKey(key1)) {
// If there are multiple links from i to j, store the smallest mismatch value (naturally sorted by treeset)
if (map.get(key1).containsKey(key2)) {
if (map.get(key1).get(key2).size() >= 2 && mismatch >= map.get(key1).get(key2).first().getMismatch()) {
return; // already have top 2, no need to update
}
// need to populate first two or mismatch is actually lower
map.get(key1).get(key2).add(new MismatchValueAndRelationship(mismatch, relationshipID));
LinkedList<MismatchValueAndRelationship> removeList = new LinkedList<MismatchValueAndRelationship>();
int count = 0;
for (MismatchValueAndRelationship mvr : map.get(key1).get(key2)) {
count++;
if (count > 2) {
removeList.add(mvr); // take top 2
}
}
for (MismatchValueAndRelationship remove : removeList) {
map.get(key1).get(key2).remove(remove);
}
} else {
map.get(key1).put(key2, new TreeSet<MismatchValueAndRelationship>()); // init
map.get(key1).get(key2).add(new MismatchValueAndRelationship(mismatch, relationshipID));
}
} else { // list init
map.put(key1, new HashMap<Integer, TreeSet<MismatchValueAndRelationship>>());
map.get(key1).put(key2, new TreeSet<MismatchValueAndRelationship>());
map.get(key1).get(key2).add(new MismatchValueAndRelationship(mismatch, relationshipID));
}
}
public void addScriptHashToTxMap(Collection<Map.Entry<ByteString, Sha256Hash> > lst)
{
LinkedList<Map.Entry<ByteString, ByteString>> out = new LinkedList<>();
for(Map.Entry<ByteString, Sha256Hash> me : lst)
{
out.add(new SimpleEntry<ByteString, ByteString>(me.getKey(), ByteString.copyFrom(me.getValue().getBytes())));
}
pubkey_to_tx_map.addAll(out);
}
/**
* Building a ContentElement from a single line. But the result is given, so
* e.g. a NestedListElement can be filled with information...
*/
private ContentElement parseContentElement(SpanManager sm,
ContentElementParsingParameters cepp, Span lineSpan,
ContentElement result)
{
LinkedList<Span> lineSpans = new LinkedList<Span>();
lineSpans.add(lineSpan);
return parseContentElement(sm, cepp, lineSpans, result);
}
@Test
public void testLinkedListSerialization() throws Exception {
LinkedList<Object> ll = new LinkedList<Object>();
ll.add(1); ll.add("two");
String result = checkSerializesAs(ll, null);
log.info("LLIST json is: "+result);
Assert.assertFalse(result.contains("error"), "Shouldn't have had an error, instead got: "+result);
Assert.assertEquals(Strings.collapseWhitespace(result, ""), "[1,\"two\"]");
}
private static Statement findFirstBlock(Statement stat, Set<Statement> setStats) {
LinkedList<Statement> stack = new LinkedList<>();
stack.add(stat);
while (!stack.isEmpty()) {
Statement st = stack.remove(0);
if (stack.isEmpty() || setStats.contains(st)) {
if (st.isLabeled() && !stack.isEmpty() || st.getExprents() != null) {
return st;
}
stack.clear();
//noinspection Duplicates
switch (st.type) {
case Statement.TYPE_SEQUENCE:
stack.addAll(0, st.getStats());
break;
case Statement.TYPE_IF:
case Statement.TYPE_ROOT:
case Statement.TYPE_SWITCH:
case Statement.TYPE_SYNCRONIZED:
stack.add(st.getFirst());
break;
default:
return st;
}
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
protected void processGroupedEvent(Object subViews, IDataCollection subCollection, Object groupKey, IEvent theEvent)
{
@SuppressWarnings("unchecked")
LinkedList<IEvent> curData = (LinkedList<IEvent>)curDataPerKey.get(groupKey);
Long oldestTime = curOldestTimePerKey.get(groupKey);
long timestamp = getTimestamp(theEvent);
IEvent[] curBatch = null;
if (oldestTime != null && curData != null)
{
if (timestamp - oldestTime >= getKeepTime())
{
curBatch = curData.toArray(new IEvent[curData.size()]);
curData.clear();
oldestTime = null;
}
}
if (curData == null)
{
curData = new LinkedList<IEvent>();
curDataPerKey.put(groupKey, curData);
}
curData.add(theEvent);
if (oldestTime == null)
{
oldestTime = timestamp;
}
curOldestTimePerKey.put(groupKey, oldestTime);
if (curBatch != null)
{
IEvent[] lastBatch = (IEvent[])lastBatchPerKey.get(groupKey);
if (subCollection != null)
{
subCollection.update(curBatch, lastBatch);
}
if (null != subViews)
{
if (subViews instanceof IView)
{
((IView)subViews).update(curBatch, lastBatch);
}
}
lastBatch = curBatch;
lastBatchPerKey.put(groupKey, lastBatch);
}
}
public DownloadManager(Context context) {
mContext = context;
// Get all labels
List<DownloadLabel> labels = EhDB.getAllDownloadLabelList();
mLabelList = labels;
// Create list for each label
HashMap<String, LinkedList<DownloadInfo>> map = new HashMap<>();
mMap = map;
for (DownloadLabel label : labels) {
map.put(label.getLabel(), new LinkedList<DownloadInfo>());
}
// Create default for non tag
mDefaultInfoList = new LinkedList<>();
// Get all info
List<DownloadInfo> allInfoList = EhDB.getAllDownloadInfo();
mAllInfoList = new LinkedList<>(allInfoList);
// Create all info map
HashMap<String,DownloadInfo> allInfoMap = new HashMap<>(allInfoList.size() + 10);
mAllInfoMap = allInfoMap;
for (int i = 0, n = allInfoList.size(); i < n; i++) {
DownloadInfo info = allInfoList.get(i);
// Add to all info map
allInfoMap.put(info.gid, info);
// Add to each label list
LinkedList<DownloadInfo> list = getInfoListForLabel(info.label);
if (list == null) {
// Can't find the label in label list
list = new LinkedList<>();
map.put(info.label, list);
if (!containLabel(info.label)) {
// Add label to DB and list
labels.add(EhDB.addDownloadLabel(info.label));
}
}
list.add(info);
}
mWaitList = new LinkedList<>();
mSpeedReminder = new SpeedReminder();
mDownloadInfoListeners = new ArrayList<>();
}
LinkedList<String> getTargetMapping(){
LinkedList<String> targetMapping = new LinkedList<String>();
targetMapping.add(wrapper.getPlanNodeCTE(left, true));
targetMapping.add(wrapper.getPlanNodeCTE(right, true));
return targetMapping;
}
private StructuredSwitch rewriteSwitch(StructuredSwitch original, SwitchStringMatchResultCollector matchResultCollector) {
Op04StructuredStatement body = original.getBody();
BlockIdentifier blockIdentifier = original.getBlockIdentifier();
StructuredStatement inner = body.getStatement();
if (!(inner instanceof Block)) {
throw new FailedRewriteException("Switch body is not a block, is a " + inner.getClass());
}
Block block = (Block) inner;
Map<Integer, List<String>> replacements = matchResultCollector.getValidatedHashes();
List<Op04StructuredStatement> caseStatements = block.getBlockStatements();
LinkedList<Op04StructuredStatement> tgt = ListFactory.newLinkedList();
InferredJavaType typeOfSwitch = matchResultCollector.getStringExpression().getInferredJavaType();
for (Op04StructuredStatement op04StructuredStatement : caseStatements) {
inner = op04StructuredStatement.getStatement();
if (!(inner instanceof StructuredCase)) {
throw new FailedRewriteException("Block member is not a case, it's a " + inner.getClass());
}
StructuredCase structuredCase = (StructuredCase) inner;
List<Expression> values = structuredCase.getValues();
List<Expression> transformedValues = ListFactory.newList();
for (Expression value : values) {
Integer i = getInt(value);
List<String> replacementStrings = replacements.get(i);
if (replacementStrings == null) {
throw new FailedRewriteException("No replacements for " + i);
}
for (String s : replacementStrings) {
transformedValues.add(new Literal(TypedLiteral.getString(s)));
}
}
StructuredCase replacementStructuredCase = new StructuredCase(transformedValues, typeOfSwitch, structuredCase.getBody(), structuredCase.getBlockIdentifier());
tgt.add(new Op04StructuredStatement(replacementStructuredCase));
}
Block newBlock = new Block(tgt, true);
Expression switchOn = matchResultCollector.getStringExpression();
// If the literal is a naughty null, we need to expressly force it to a string.
// Don't cast to its own type, as this might be a null type.
if (switchOn.equals(Literal.NULL)) {
switchOn = new CastExpression(new InferredJavaType(TypeConstants.STRING, InferredJavaType.Source.EXPRESSION), switchOn, true);
}
return new StructuredSwitch(
switchOn,
new Op04StructuredStatement(newBlock),
blockIdentifier, false);
}
@Test
public void populateNorms()
{
NodeNormalizer target = new NodeNormalizer();
FacetFieldAdapter adapter = new FacetFieldAdapter("testField");
AggregationWaitable runner = new AggregationWaitable(context, adapter, "testField", 0, 1);
runner.buckets = new LinkedList<>();
runner.adapter = adapter;
SimpleOrderedMap<Object> bucket1 = new SimpleOrderedMap<>();
bucket1.add("val", "testValue1");
bucket1.add("id", "1");
SimpleOrderedMap<Object> bucket2 = new SimpleOrderedMap<>();
bucket2.add("val", "testValue2");
bucket2.add("id", "2");
SimpleOrderedMap<Object> bucket3 = new SimpleOrderedMap<>();
bucket3.add("val", "value3");
bucket3.add("id", "3");
runner.buckets.add(bucket1);
runner.buckets.add(bucket2);
runner.buckets.add(bucket3);
String requestValue1 = "testValue1";
String requestValue2 = "testValue2";
LinkedList<String> normalizedStrings = new LinkedList<>();
LinkedList<SimpleOrderedMap<String>> normalizedMaps = new LinkedList<>();
String [] expectedStrings = new String [] {"testValue1", "testValue2"};
LinkedList<SimpleOrderedMap<String>> expectedMaps = new LinkedList<>();
SimpleOrderedMap<String> map1 = new SimpleOrderedMap<>();
map1.add("name", "testValue1");
map1.add("id", "1");
SimpleOrderedMap<String> map2 = new SimpleOrderedMap<>();
map2.add("name", "testValue2");
map2.add("id", "2");
expectedMaps.add(map1);
expectedMaps.add(map2);
Deencapsulation.invoke(target, "populateNorms", runner, requestValue1, normalizedStrings, normalizedMaps);
Deencapsulation.invoke(target, "populateNorms", runner, requestValue2, normalizedStrings, normalizedMaps);
Assert.assertEquals(2, normalizedStrings.size());
Assert.assertEquals(2, normalizedMaps.size());
for(int i = 0; i < expectedStrings.length ; ++i) {
Assert.assertEquals(expectedMaps.get(i),normalizedMaps.get(i));
Assert.assertEquals(expectedStrings[i],normalizedStrings.get(i));
}
}
private boolean processStatementEx(StructMethod mt, RootStatement root, ControlFlowGraph graph) {
int bytecode_version = mt.getClassStruct().getBytecodeVersion();
LinkedList<Statement> stack = new LinkedList<>();
stack.add(root);
while (!stack.isEmpty()) {
Statement stat = stack.removeLast();
Statement parent = stat.getParent();
if (parent != null && parent.type == Statement.TYPE_CATCHALL && stat == parent.getFirst() && !parent.isCopied()) {
CatchAllStatement fin = (CatchAllStatement) parent;
BasicBlock head = fin.getBasichead().getBlock();
BasicBlock handler = fin.getHandler().getBasichead().getBlock();
if (catchallBlockIDs.containsKey(handler.id)) {
// do nothing
} else if (finallyBlockIDs.containsKey(handler.id)) {
fin.setFinally(true);
Integer var = finallyBlockIDs.get(handler.id);
fin.setMonitor(var == null ? null : new VarExprent(var.intValue(), VarType.VARTYPE_INT, varProcessor));
} else {
Record inf = getFinallyInformation(mt, root, fin);
if (inf == null) { // inconsistent finally
catchallBlockIDs.put(handler.id, null);
} else {
if (DecompilerContext.getOption(IFernflowerPreferences.FINALLY_DEINLINE) && verifyFinallyEx(graph, fin, inf)) {
finallyBlockIDs.put(handler.id, null);
} else {
int varindex = DecompilerContext.getCounterContainer().getCounterAndIncrement(CounterContainer.VAR_COUNTER);
insertSemaphore(graph, getAllBasicBlocks(fin.getFirst()), head, handler, varindex, inf, bytecode_version);
finallyBlockIDs.put(handler.id, varindex);
}
DeadCodeHelper.removeDeadBlocks(graph); // e.g. multiple return blocks after a nested finally
DeadCodeHelper.removeEmptyBlocks(graph);
DeadCodeHelper.mergeBasicBlocks(graph);
}
return true;
}
}
stack.addAll(stat.getStats());
}
return false;
}