/** * Computes a context-sensitive same-level chop from <code>sourceSet</code> to <code>sinkSet * </code>. * * @param sourceSet The source criterion set. Should not contain null, should not be empty. * @param sinkSet The target criterion set. Should not contain null, should not be empty. * @return The chop (a HashSet). * @throws InvalidCriterionException, if the nodes in sourceSet and targetSet do not belong to the * same procedure or if one of the sets is empty. */ public Collection<SDGNode> chop(Collection<SDGNode> sourceSet, Collection<SDGNode> sinkSet) throws InvalidCriterionException { // the bouncer if (!Chopper.testSameLevelSetCriteria(sourceSet, sinkSet)) { // Thou shall not pass! throw new InvalidCriterionException( "This is not a same-level chopping criterion: " + sourceSet + ", " + sinkSet); } // compute the initial chop Collection<SDGNode> currentChop = intraChopper.chop(sourceSet, sinkSet); // retrieve all (formal-in / formal-out) pairs that belong to a summary edge in the chop LinkedList<SDGNodeTuple> worklist = new LinkedList<SDGNodeTuple>(); worklist.addAll(getSummaryEdgePairs(currentChop)); Set<SDGNodeTuple> visitedTuples = new HashSet<SDGNodeTuple>(); // gradually add the chops for each (formal-in / formal-out) pairs while (!worklist.isEmpty()) { SDGNodeTuple pair = worklist.pop(); if (!visitedTuples.contains(pair)) { visitedTuples.add(pair); SDGNode m = pair.getFirstNode(); SDGNode n = pair.getSecondNode(); // update the worklist with new (formal-in / formal-out) pairs Collection<SDGNode> chop = intraChopper.chop(m, n); currentChop.addAll(chop); worklist.addAll(getSummaryEdgePairs(chop)); } } return currentChop; }
/** * Replies all primitives * * @return all primitives */ public List<OsmPrimitive> getPrimitives() { LinkedList<OsmPrimitive> ret = new LinkedList<OsmPrimitive>(); ret.addAll(toAdd); ret.addAll(toUpdate); ret.addAll(toDelete); return ret; }
/** Create a list of variants from this VcfEntry */ public List<Variant> variants() { if (variants != null) return variants; // Create list of variants variants = new LinkedList<>(); // Create one Variant for each ALT Chromosome chr = (Chromosome) parent; if (!isVariant()) { // Not a variant? List<Variant> vars = variants(chr, start, ref, null, id); String alt = "."; // Add original 'ALT' field as genotype for (Variant variant : vars) variant.setGenotype(alt); variants.addAll(vars); } else { // At least one variant for (String alt : alts) { if (!isVariant(alt)) alt = null; List<Variant> vars = variants(chr, start, ref, alt, id); variants.addAll(vars); } } return variants; }
void mixLists( LinkedList<Integer> left, LinkedList<Integer> right, ArrayList<LinkedList<Integer>> mix, LinkedList<Integer> before) { if (before.isEmpty() || right.isEmpty()) { LinkedList<Integer> l = new LinkedList<>(); l = (LinkedList<Integer>) before.clone(); l.addAll(left); l.addAll(right); mix.add(l); return; } int hl = left.removeFirst(); before.addLast(hl); mixLists(left, right, mix, before); before.removeLast(); left.addFirst(hl); int hr = right.removeFirst(); before.addLast(hr); mixLists(left, right, mix, before); before.removeLast(); right.addFirst(hr); }
public void weavelists( LinkedList<Integer> first, LinkedList<Integer> second, ArrayList<LinkedList<Integer>> results, LinkedList<Integer> prefix) { if (first.size() == 0 || second.size() == 0) { LinkedList<Integer> result = (LinkedList<Integer>) prefix.clone(); result.addAll(first); result.addAll(second); results.add(result); return; } int headFirst = first.removeFirst(); prefix.addLast(headFirst); weavelists(first, second, results, prefix); prefix.removeLast(); first.addFirst(headFirst); int secondHead = second.removeFirst(); prefix.addLast(secondHead); weavelists(first, second, results, prefix); prefix.removeLast(); second.addFirst(secondHead); }
@Override public Action generateAchievementAction(String focus) { myToken.setStrategyType(AgentToken.STRATEGY_ZONE_BUILDER); // successfulParries is covered by defaultAction if (focus == "achievementsSurveyedEdges") { if (myPosition.getNumberOfUnsurveyedEdges() > 0) { Action ret = new Action("survey", myPosition.getIdentifier()); return ret; } } if (focus == "achievementsInspectedAgents") { if (longNotInspectedEnemyNear(myPosition)) { // return new Action("inspect", myPosition.getIdentifier()); LinkedList<AgentToken> agentsToCheck = new LinkedList<AgentToken>(); agentsToCheck.addAll(myPosition.getTokens()); for (Vertex w : myPosition.getAdjacentVertices()) agentsToCheck.addAll(w.getTokens()); for (AgentToken t : agentsToCheck) { if (!t.getTeam().equals(myTeam) && notRecentlyInspected(t)) return new Action("inspect", new Identifier(t.getName())); } } } if (focus == "achievementsAreaValue") { Action ret = ag.buildZone(); return ret; } return ag.expandOwnComponent(); }
/** * Compose write and append print updates. The type write or append as well as the order of the * updates are taken into account. * * @param compAPI */ private void composeAppend(PluginCompositionAPI compAPI) { for (Location l : compAPI.getAffectedLocations()) { if (!FILE_OUTPUT_FUNC_NAME.equals(l.name)) continue; LinkedList<Element> elems1 = new LinkedList<>(); LinkedList<Element> elems2 = new LinkedList<>(); Set<Element> contributingAgents = new HashSet<Element>(); Set<ScannerInfo> contributingNodes = new HashSet<ScannerInfo>(); String action = APPEND_ACTION; // if the second set does not have a basic update, // add all the updates from the first set as well if (!compAPI.isLocUpdatedWithActions(2, l, Update.UPDATE_ACTION)) { for (Update update : compAPI.getLocUpdates(1, l)) { if (APPEND_ACTION.equals(update.action) || WRITE_ACTION.equals(update.action)) { Element value = update.value; if (!(update.value instanceof ListElement)) value = new ListElement(Arrays.asList(new Element[] {value})); ListElement list = (ListElement) value; elems1.addAll(list.getList()); contributingAgents.addAll(update.agents); contributingNodes.addAll(update.sources); } if (WRITE_ACTION.equals(update.action)) action = WRITE_ACTION; } } for (Update update : compAPI.getLocUpdates(2, l)) { if (APPEND_ACTION.equals(update.action) || WRITE_ACTION.equals(update.action)) { Element value = update.value; if (!(update.value instanceof ListElement)) value = new ListElement(Arrays.asList(new Element[] {value})); ListElement list = (ListElement) value; elems2.addAll(list.getList()); contributingAgents.addAll(update.agents); contributingNodes.addAll(update.sources); } if (WRITE_ACTION.equals(update.action)) { action = WRITE_ACTION; elems1.clear(); } } if (!elems1.isEmpty() || !elems2.isEmpty()) { LinkedList<Element> outputResult = elems1; if (outputResult.isEmpty()) outputResult = elems2; else if (!elems2.isEmpty()) { outputResult = new LinkedList<>(); outputResult.addAll(elems1); outputResult.addAll(elems2); } compAPI.addComposedUpdate( new Update( l, new ListElement(new ArrayList<Element>(outputResult)), action, contributingAgents, contributingNodes), this); } } }
/** * Deeply list the opaque ports connected to this port on the outside. Begin by listing the ports * that are connected to this port. If any of those are transparent ports that we are connected to * from the inside, then list all the ports deeply connected on the outside to that transparent * port. If any are transparent ports that we are connected to from the outside, then list opaque * ports deeply inside that port. Note that a port may be listed more than once. The path argument * is the path from the port that originally calls this method to this port. If this port is * already on the list of ports on the path to this port in deeply traversing the topology, then * there is a loop in the topology, and an InvalidStateException is thrown. This method not * synchronized on the workspace, so the caller should. * * @param path The list of ports on the path to this port in deeply traversing the topology. * @return An unmodifiable list of ComponentPort objects. */ protected List _deepConnectedPortList(LinkedList path) { if (_deepLinkedPortsVersion == _workspace.getVersion()) { // Cache is valid. Use it. return _deepLinkedPorts; } if (path == null) { path = new LinkedList(); } else { if (path.indexOf(this) >= 0) { throw new InvalidStateException(path, "Loop in topology!"); } } path.add(0, this); Iterator nearRelations = linkedRelationList().iterator(); LinkedList result = new LinkedList(); while (nearRelations.hasNext()) { ComponentRelation relation = (ComponentRelation) nearRelations.next(); // A null link (supported since indexed links) might // yield a null relation here. EAL 7/19/00. if (relation != null) { Iterator connectedPorts = relation.linkedPortList(this).iterator(); while (connectedPorts.hasNext()) { ComponentPort port = (ComponentPort) connectedPorts.next(); // NOTE: If level-crossing transitions are not allowed, // then a simpler test than that of the following // would work. if (port._isInsideLinkable(relation.getContainer())) { // We are coming at the port from the inside. if (port.isOpaque()) { result.add(port); } else { // Port is transparent result.addAll(port._deepConnectedPortList(path)); } } else { // We are coming at the port from the outside. if (port.isOpaque()) { result.add(port); } else { // It is transparent. result.addAll(port._deepInsidePortList(path)); } } } } } _deepLinkedPorts = Collections.unmodifiableList(result); _deepLinkedPortsVersion = _workspace.getVersion(); path.remove(0); return _deepLinkedPorts; }
@Override public List<Variable> getUsedVariables() { LinkedList<Variable> ret = new LinkedList<Variable>(); for (Expression e : this.arguments) { ret.addAll(e.getUsedVariables()); } ret.addAll(this.getModifiedVars()); return ret; }
/** * get all textBox displayed by the entity. TextBox returned are: - textBox for entity name - * textBox for attributes - textBox for methods * * @return an array containing all TextBox */ public LinkedList<TextBox> getAllTextBox() { final LinkedList<TextBox> tb = new LinkedList<TextBox>(); tb.add(entityName); tb.addAll(methodsView); tb.addAll(attributesView); return tb; }
@Override public List<ItemChange> getChanged(BackendSession bs) throws DaoException, CollectionNotFoundException, UnknownObmSyncServerException { LinkedList<ItemChange> changes = new LinkedList<ItemChange>(); changes.addAll(getCalendarChanges(bs)); changes.addAll(getMailChanges(bs)); changes.addAll(getContactsChanges(bs)); changes.addAll(getTasksChanges(bs)); return changes; }
private boolean directedCompute() { SortedSet<Integer> degrees = new TreeSet<Integer>(); for (IElement iE : g.getNodes()) { DirectedNode n = (DirectedNode) iE; int degree = n.getOutDegree(); degrees.add(degree); if (nodesSortedByDegree.containsKey(degree)) { this.nodesSortedByDegree.get(degree).add(n); } else { LinkedList<Node> temp = new LinkedList<>(); temp.add(n); this.nodesSortedByDegree.put(degree, temp); } } HashSet<Node> currentRichClub = new HashSet<Node>(); int currentRichClubSize = 0; int size = degrees.size(); for (int i = 0; i < size; i++) { int currentDegree = degrees.last(); degrees.remove(currentDegree); LinkedList<Node> current = this.nodesSortedByDegree.get(currentDegree); currentRichClubSize += current.size(); this.nodesSortedByDegree.remove(currentDegree); if (currentRichClubSize >= this.richClubSize) { int seperateAT = current.size() - (currentRichClubSize - this.richClubSize); LinkedList<Node> temp = new LinkedList<>(); temp.addAll(current.subList(0, seperateAT)); this.richClub.put(currentDegree, temp); currentRichClub.addAll(temp); LinkedList<Node> temp2 = new LinkedList<>(); temp2.addAll(current.subList(seperateAT, current.size())); if (!temp2.isEmpty()) this.nodesSortedByDegree.put(currentDegree, (LinkedList<Node>) temp2); break; } else { richClub.put(currentDegree, current); currentRichClub.addAll(current); } } for (Node n : currentRichClub) { DirectedNode ne = (DirectedNode) n; for (IElement iE : ne.getOutgoingEdges()) { DirectedEdge e = (DirectedEdge) iE; if (currentRichClub.contains(e.getDst())) { edgesBetweenRichClub++; } } } return true; }
/** * checks for long not inspected enemy at a position and adjacent vertices * * @param v the vertex to check * @return true, if there is at least one long not inspected enemy, else false * @see {@link #notRecentlyInspected(AgentToken)} */ private boolean longNotInspectedEnemyNear(Vertex v) { // check for uninspected enemy on own position and adjacent vertices LinkedList<AgentToken> agentsToCheck = new LinkedList<AgentToken>(); agentsToCheck.addAll(v.getTokens()); for (Vertex w : v.getAdjacentVertices()) agentsToCheck.addAll(w.getTokens()); for (AgentToken t : agentsToCheck) { if (!t.getTeam().equals(myTeam) && notRecentlyInspected(t)) return true; } return false; }
public Sequence(TypedAST first, TypedAST second) { if (first instanceof Sequence) { exps.addAll(((Sequence) first).exps); } else if (first != null) { exps.add(check(first)); } if (second instanceof Sequence) { exps.addAll(((Sequence) second).exps); } else if (second != null) { exps.add(check(second)); } }
// FIXME: This is only here for wildcard imports, and we should be able to make it lazy like the // rest // with a bit of work in the typechecker // FIXME: redo this method better: https://github.com/ceylon/ceylon-spec/issues/90 @Override public List<Declaration> getMembers() { synchronized (modelLoader) { // make sure the package is loaded modelLoader.loadPackage(getQualifiedNameString(), true); List<Declaration> sourceDeclarations = super.getMembers(); LinkedList<Declaration> ret = new LinkedList<Declaration>(); ret.addAll(sourceDeclarations); ret.addAll(compiledDeclarations); return ret; } }
/** On a given class (a RobotML system), retrieve all the contained systems. Recursive. */ public static List<org.eclipse.uml2.uml.Property> getAllSubComponentsInClass( org.eclipse.uml2.uml.Class c) { LinkedList<org.eclipse.uml2.uml.Property> sub_components = new LinkedList<org.eclipse.uml2.uml.Property>(); List<org.eclipse.uml2.uml.Property> level_1 = getLevel1SubComponentsForComponent(c); sub_components.addAll(level_1); for (Property prop : level_1) { List<Property> next_levels = getAllSubComponentsInClass((org.eclipse.uml2.uml.Class) prop.getType()); sub_components.addAll(next_levels); } return sub_components; }
@Override public Iterator<TickClient> getTickSet(final Tickable T, final int tickID) { final LinkedList<TickClient> subSet = new LinkedList<TickClient>(); if (tickID < 0) subSet.addAll( tickers.subSet( new StdTickClient(T, 0, 0), true, new StdTickClient(T, 0, Integer.MAX_VALUE), true)); else subSet.addAll( tickers.subSet( new StdTickClient(T, 0, tickID), true, new StdTickClient(T, 0, tickID), true)); return subSet.iterator(); }
/** * Puts all the existing child items in a linked list, recursively following child-items if there * are any * * @param items * @return */ public static LinkedList<CmdLnValue> createFlatList(CmdLnItem item) { LinkedList<CmdLnValue> items = new LinkedList<>(); if (item instanceof CommandOP) { // Combine options and child parameters. Non-option-parameters first and then the options items.addAll(item.getChildrenInternal().values()); items.addAll(((CommandOP) item).getOptions().values()); } else { items.add((CmdLnValue) item); } return createFlatList(items); }
/** * Converts the state of this object into a list of tokens, which when combined give the command * to execute for starting the server program. */ LinkedList getTokens() { LinkedList tokens = new LinkedList(); tokens.add(mJVM); if (mCmdLineFlags != null) tokens.addAll(mCmdLineFlags); if (mVmType != null) tokens.add(mVmType); if (mJVMFlags != null) tokens.addAll(mJVMFlags); if (mLibPath != null) { tokens.add("-Djava.library.path=" + mLibPath); } tokens.add("-classpath"); tokens.add(mClasspath); tokens.add(mMainClassName); if (mAppArgs != null) tokens.addAll(mAppArgs); return tokens; }
/** * Adjusts the upload order for new relations. Child relations are uploaded first, parent * relations second. * * <p>This method detects cyclic dependencies in new relation. Relations with cyclic dependencies * can't be uploaded. * * @throws CyclicUploadDependencyException thrown, if a cyclic dependency is detected */ public void adjustRelationUploadOrder() throws CyclicUploadDependencyException { LinkedList<OsmPrimitive> newToAdd = new LinkedList<OsmPrimitive>(); newToAdd.addAll(Utils.filteredCollection(toAdd, Node.class)); newToAdd.addAll(Utils.filteredCollection(toAdd, Way.class)); List<Relation> relationsToAdd = new ArrayList<Relation>(Utils.filteredCollection(toAdd, Relation.class)); List<Relation> noProblemRelations = filterRelationsNotReferringToNewRelations(relationsToAdd); newToAdd.addAll(noProblemRelations); relationsToAdd.removeAll(noProblemRelations); RelationUploadDependencyGraph graph = new RelationUploadDependencyGraph(relationsToAdd); newToAdd.addAll(graph.computeUploadOrder()); toAdd = newToAdd; }
public void action() { buySideOrders.addAll(MarketAgent.buySideQueue); Collections.sort(buySideOrders); sellSideOrders.addAll(MarketAgent.sellSideQueue); Collections.sort(sellSideOrders); System.out.println(myAgent.getLocalName() + " LocalBuyOrders: " + buySideOrders.size()); System.out.println(myAgent.getLocalName() + " LocalSellOrders: " + sellSideOrders.size()); ACLMessage tradingRequestMsg = new ACLMessage(ACLMessage.REQUEST); tradingRequestMsg.setConversationId("TradingRequest"); tradingRequestMsg.setContent("ReadyToStart"); tradingRequestMsg.addReceiver(MarketAgent.marketAID); myAgent.send(tradingRequestMsg); }
/* * Main constructor to parse Javascript file * @param input. The string containing the file data */ public VariableNameComboModel() throws FileNotFoundException { String input = EditorRegistry.lastFocusedComponent().getText(); String replaceInput = removeComment(input).replaceAll("[)(;+}={,.]", ""); // enter entries (split) by whitespace String words[] = replaceInput.split("\\s+"); int counter = 0; // while there are still words, add them to the variableNamesArray ArrayList for (int i = 0; i < words.length; i++) { if (words[i].equals("var")) { variableNamesArray.add(words[i + 1]); } else { } counter++; } counter = 1; while (counter < words.length) { if (words[counter - 1].equals("function")) { functionNamesArray.add(" " + words[counter]); } counter++; } counter = 1; while (counter < words.length) { if (words[counter - 1].equals("class")) { classNamesArray.add(" " + words[counter]); } counter++; } int i = 0; // convert the arraylist to an array if (!variableNamesArray.isEmpty()) { MyList.add("Variables"); MyList.addAll(variableNamesArray); } if (!functionNamesArray.isEmpty()) { MyList.add("Functions"); MyList.addAll(functionNamesArray); } if (!classNamesArray.isEmpty()) { MyList.add("Classes"); MyList.addAll(classNamesArray); } this.variableNames = (String[]) MyList.toArray(new String[0]); }
/* Search recursively for all SBML files in given path. */ public static LinkedList<String> walk(String path) { LinkedList<String> sbmlList = new LinkedList<String>(); File root = new File(path); File[] list = root.listFiles(); if (list == null) { return sbmlList; } for (File f : list) { if (f.isDirectory()) { sbmlList.addAll(walk(f.getAbsolutePath())); // System.out.println( "Dir:" + f.getAbsoluteFile() ); } else { // System.out.println( "File:" + f.getAbsoluteFile() ); String fname = f.getName(); if (fname.endsWith(".xml") && fname.contains("pass") && !skip.contains(fname)) { // System.out.println( "SBML:" + f.getAbsoluteFile() ); sbmlList.add(f.getAbsolutePath()); } } } return sbmlList; }
public static void visit(final IFb2Node root, final IFb2NodeVisitor visitor) { final LinkedList<IFb2Node> nodes = new LinkedList<IFb2Node>(); nodes.add(root); try { for (IFb2Node node = getFirst(nodes); node != null; node = getFirst(nodes)) { switch (visitor.handle(node)) { case Stop: return; case ProcessOnlyChildren: nodes.clear(); case Continue: if (node instanceof IFb2CompositeNode) { nodes.addAll(0, ((IFb2CompositeNode) node).getChildren()); } break; case NextSibling: break; } } } catch (final Throwable th) { th.printStackTrace(); } finally { nodes.clear(); } }
/** * Searches zero locations in a neigboorhood in a code piece, starts a number of search threads * * @param cp The code piece * @param globalValues The global initialised values * @return The zero locations points */ private LinkedList<Point3d> searchZeroLocations( CodePiece cp, HashMap<MultivectorComponent, Double> globalValues, int a, float dist, double epsilon, boolean renderIn2d) { LinkedList<Point3d> points = new LinkedList<Point3d>(); int processorCount = Runtime.getRuntime().availableProcessors(); RayMethodThread[] threads = new RayMethodThread[processorCount]; for (int i = 0; i < processorCount; i++) { float from = (i * 2 * a) / ((float) processorCount) - a; float to = ((i != processorCount - 1) ? ((i + 1) * 2 * a) / ((float) processorCount) : 2 * a) - a; threads[i] = new RayMethodThread(from, to, a, dist, globalValues, cp, epsilon, renderIn2d); threads[i].start(); } for (int i = 0; i < threads.length; i++) { try { threads[i].join(); points.addAll(threads[i].points); } catch (InterruptedException ex) { Logger.getLogger(DiscreteCubeMethod.class.getName()).log(Level.SEVERE, null, ex); } } return points; }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#arcAbs(float, float, float, boolean, boolean, float, float) */ public void arcAbs( float rx, float ry, float phi, boolean large_arc, boolean sweep, float x, float y) throws ParseException { if (verbose) System.out.println( "arcAbs: " + rx + " " + ry + " " + phi + " " + large_arc + " " + sweep + " " + x + " " + y); Vertex lastPoint = pathPoints.getLast(); List<Vertex> arcVertices = Tools3D.arcTo(lastPoint.x, lastPoint.y, rx, ry, phi, large_arc, sweep, x, y, 40); // Prevent odd picking behavour, in which the normal is // not correctly computed, because the 2 points are the same if (!arcVertices.isEmpty() && lastPoint != null && arcVertices.get(0).equalsVector(lastPoint)) { arcVertices.remove(0); } pathPoints.addAll(arcVertices); currentSubPath.addAll(arcVertices); }
private List<RAS_Node> getAvailableNodes() { LinkedList<RAS_Node> nodes = new LinkedList<RAS_Node>(); for (String clusterId : _clusterInfo.keySet()) { nodes.addAll(this.getAvailableNodesFromCluster(clusterId)); } return nodes; }
private void generateWithLength(int length, LinkedList<EventType> posfix, EventType root) { if (length <= 1) { LinkedList<EventType> path = getPathToRoot(root); if (path != null) { path.addAll(posfix); writeToFile( TestCaseGeneratorConfiguration.OUTPUT_DIR + File.separator + TEST_NAME_PREFIX + (index) + TEST_NAME_SUFIX, path); index++; } else { GUITARLog.log.info("root: " + root.getWidgetId()); GUITARLog.log.info(posfix + " is unreachable"); } } else { for (EventType succEvent : succs.get(root)) { LinkedList<EventType> extendedPosfix = new LinkedList<EventType>(posfix); extendedPosfix.addLast(root); generateWithLength(length - 1, extendedPosfix, succEvent); } } }
/** * 根据参数showArea 和 showBlock 跟显示的数据内容 * * @param showArea * @param showBlock */ public void updateShowText(String showArea, String showBlock) { if (showArea == null || showBlock == null) { return; } for (int i = 0; i < groups.size(); i++) { if (groups.get(i).equals(showArea)) { // 如果showArea的值和ArrayList中的某个值相等时,将earaListViewAdapter的选中位置设置在第i个位置 earaListViewAdapter.setSelectedPosition(i); childrenItem.clear(); // 立即将这个链表清掉,准备把位置腾出来给children链表的第i个位置的LinkedList // children为SparseArray(LinkedList<String>) if (i < children.size()) { // children为SparseArray(LinkedList<String>) childrenItem.addAll(children.get(i)); } tEaraPosition = i; // 将地域的位置现在修改为之前选中的第i个位置 break; } } for (int j = 0; j < childrenItem.size(); j++) { if (childrenItem.get(j).replace("不限", "").equals(showBlock.trim())) { plateListViewAdapter.setSelectedPosition(j); // 商圈的适配器设置到选中的位置 tBlockPosition = j; break; } } setDefaultSelect(); }
// // Methode zum Auflisten der XML-Dateien public LinkedList<File> listDir(File dir) { LinkedList<File> result = new LinkedList<File>(); File[] files = dir.listFiles(); if (files != null) { for (int i = 0; i < files.length; i++) { // System.out.printf(files[i].getAbsolutePath()); if (files[i].isDirectory()) { if (files[i].getAbsolutePath().contains("timeless")) { } else { // System.out.print(" (Ordner)\n"); result.addAll(listDir(files[i])); } } // else{ // System.out.print(" (Datei)\n"); // } if (files[i].getAbsolutePath().contains("xml")) { if (files[i].getAbsolutePath().contains("timeless")) { } else { System.out.println(files[i].getAbsolutePath()); result.add(files[i]); } } // else{ // files[i].delete(); // } } } return result; }