java.util.Stack#subList ( )源码实例Demo

void scanDependencies(Stack<CtPackageReference> path) {
	CtPackageReference ref = path.peek();
	// return if already scanned
	if (scanned.contains(ref)) {
		return;
	}
	scanned.add(ref);
	Set<CtPackageReference> refs = packRefs.get(ref);
	if (refs != null) {
		for (CtPackageReference p : refs) {
			if (path.contains(p)) {
				List<CtPackageReference> circularPath = new ArrayList<>(
						path.subList(path.indexOf(p), path.size()));
				circularPath.add(p);

				circularPathes.add(circularPath);
				break;
			} else {
				path.push(p);
				scanDependencies(path);
				path.pop();
			}
		}
	}
}
 

private static void findCircuits(final Set<Circuit> circuits, final Node node, final Stack<Node> stack) {
    if (stack.contains(node)) {
        final int fromIndex = stack.indexOf(node);
        final int toIndex = stack.size();
        final ArrayList<Node> circularity = new ArrayList<>(stack.subList(fromIndex, toIndex));

        // add ending node to list so a full circuit is shown
        circularity.add(node);

        final Circuit circuit = new Circuit(circularity);

        circuits.add(circuit);

        return;
    }

    stack.push(node);

    for (final Node reference : node.initialReferences) {
        findCircuits(circuits, reference, stack);
    }

    stack.pop();
}
 

public void execute(ExecutionContext context)
{
    Stack<Object> stack = context.getStack();
    int n = ((Number)stack.pop()).intValue();
    if (n > 0)
    {
        int size = stack.size();
        //Need to copy to a new list to avoid ConcurrentModificationException
        List<Object> copy = new java.util.ArrayList<Object>(
                stack.subList(size - n, size));
        stack.addAll(copy);
    }
}
 

@Override
public void execute(ExecutionContext context)
{
    Stack<Object> stack = context.getStack();
    int n = ((Number) stack.pop()).intValue();
    if (n > 0)
    {
        int size = stack.size();
        // Need to copy to a new list to avoid ConcurrentModificationException
        List<Object> copy = new java.util.ArrayList<Object>(stack.subList(size - n, size));
        stack.addAll(copy);
    }
}
 

private static String substituteParams(String pattern, IvyVariableContainer params,
        Stack<String> substituting) {
    // TODO : refactor this with substituteVariables
    // if you supply null, null is what you get
    if (pattern == null) {
        return null;
    }

    Matcher m = PARAM_PATTERN.matcher(pattern);

    StringBuffer sb = new StringBuffer();
    while (m.find()) {
        String var = m.group(1);
        String val = params.getVariable(var);
        if (val != null) {
            int index = substituting.indexOf(var);
            if (index != -1) {
                List<String> cycle = new ArrayList<>(substituting.subList(index, substituting.size()));
                cycle.add(var);
                throw new IllegalArgumentException("cyclic param definition: cycle = " + cycle);
            }
            substituting.push(var);
            val = substituteVariables(val, params, substituting);
            substituting.pop();
        } else {
            val = m.group();
        }
        m.appendReplacement(sb, val.replaceAll("\\\\", "\\\\\\\\").replaceAll("\\@", "\\\\\\@"));
    }
    m.appendTail(sb);

    return sb.toString();
}
 

public void execute(ExecutionContext context)
{
    Stack<Object> stack = context.getStack();
    int n = ((Number)stack.pop()).intValue();
    if (n > 0)
    {
        int size = stack.size();
        //Need to copy to a new list to avoid ConcurrentModificationException
        List<Object> copy = new java.util.ArrayList<Object>(
                stack.subList(size - n, size));
        stack.addAll(copy);
    }
}
 

private void printHierarchy(final String clazzName, final Stack<Boolean> moreClassesInHierarchy) {
	if (!moreClassesInHierarchy.empty()) {
		for (final Boolean hasColumn : moreClassesInHierarchy.subList(0, moreClassesInHierarchy.size() - 1)) {
			System.out.print(hasColumn.booleanValue() ? PADDING_WITH_COLUMN : PADDING);
		}
	}

	if (!moreClassesInHierarchy.empty()) {
		System.out.print(PADDING_WITH_ENTRY);
	}

	System.out.println(clazzName);

	if (subClazzEntries.containsKey(clazzName)) {
		final List<String> list = subClazzEntries.get(clazzName);

		for (int i = 0; i < list.size(); i++) {
			// if there is another class that comes beneath the next class,
			// flag this level
			moreClassesInHierarchy.push(new Boolean(i < list.size() - 1));

			printHierarchy(list.get(i), moreClassesInHierarchy);

			moreClassesInHierarchy.removeElementAt(moreClassesInHierarchy.size() - 1);
		}
	}
}
 

private static String substituteVariables(String pattern, IvyVariableContainer variables,
        Stack<String> substituting) {
    // if you supply null, null is what you get
    if (pattern == null) {
        return null;
    }

    Matcher m = VAR_PATTERN.matcher(pattern);

    boolean useVariables = false;
    StringBuffer sb = null;
    while (m.find()) {
        if (!useVariables) {
            useVariables = true;
            sb = new StringBuffer();
        }
        String var = m.group(1);
        String val = variables.getVariable(var);
        if (val != null) {
            int index = substituting.indexOf(var);
            if (index != -1) {
                List<String> cycle = new ArrayList<>(substituting.subList(index, substituting.size()));
                cycle.add(var);
                throw new IllegalArgumentException("cyclic variable definition: cycle = "
                        + cycle);
            }
            substituting.push(var);
            val = substituteVariables(val, variables, substituting);
            substituting.pop();
        } else {
            val = m.group();
        }
        m.appendReplacement(sb, val.replaceAll("\\\\", "\\\\\\\\").replaceAll("\\$", "\\\\\\$"));
    }
    if (useVariables) {
        m.appendTail(sb);
        return sb.toString();
    } else {
        return pattern;
    }
}