Example usage for java.util List remove

List of usage examples for java.util List remove

  1. HOME
  2. Java
  3. java
  4. java.util.*
  5. List
  6. remove

Introduction

In this page you can find the example usage for java.util List remove.

Prototype

E remove(int index);

Source Link

Document

Removes the element at the specified position in this list (optional operation).

Usage

From source file:MultiMap.java

public static Object remove(Object list, int i) {
    if (list == null)
        return null;

    if (list instanceof List) {
        List l = (List) list;
        l.remove(i);
        if (l.size() == 0)
            return null;
        return list;
    }/*  w w  w . ja  v a2  s  .  c  om*/

    if (i == 0)
        return null;
    return list;
}

From source file:io.github.lxgaming.teleportbow.managers.CommandManager.java

private static Optional<AbstractCommand> getCommand(AbstractCommand parentCommand, List<String> arguments) {
    Set<AbstractCommand> commands = Toolbox.newLinkedHashSet();
    if (parentCommand != null) {
        commands.addAll(parentCommand.getChildren());
    } else {/*from  www  .j a  v  a 2s  .  c  om*/
        commands.addAll(getCommands());
    }

    if (arguments.isEmpty() || commands.isEmpty()) {
        return Optional.ofNullable(parentCommand);
    }

    for (AbstractCommand command : commands) {
        if (Toolbox.containsIgnoreCase(command.getAliases(), arguments.get(0))) {
            arguments.remove(0);
            return getCommand(command, arguments);
        }
    }

    return Optional.ofNullable(parentCommand);
}

From source file:com.ben12.openhab.model.util.BeanCopy.java

public static <T> void copy(final List<T> source, final List<T> destination,
        final Function<T, String> idGetter) {
    for (int i = 0; i < source.size(); i++) {
        final T newWidget = source.get(i);

        boolean found = false;
        int j = i;

        while (j < destination.size()
                && !(found = Objects.equals(idGetter.apply(newWidget), idGetter.apply(destination.get(j))))) {
            j++;/*  w  ww. j a  v  a2  s.c  o  m*/
        }

        if (found) {
            BeanCopy.copy(newWidget, destination.get(j));
            if (i != j) {
                destination.add(i, destination.remove(j));
            }
        } else {
            destination.add(i, newWidget);
        }
    }

    if (destination.size() > source.size()) {
        destination.subList(source.size(), destination.size()).clear();
    }
}

From source file:Main.java

private static <E> void updateList(List<E> origList, Collection<? extends E> updateList, boolean add,
        boolean replace, boolean remove, BiPredicate<? super E, ? super E> equalTester,
        BiConsumer<List<E>, Collection<? extends E>> adder) {
    List<E> itemsToRemove = null;
    List<E> itemsToAdd = null;
    for (E update : updateList) {
        boolean origListContainsUpdate = false;
        ListIterator<E> origIter = origList.listIterator();
        while (origIter.hasNext()) {
            E orig = origIter.next();//  www .j  ava  2 s . c  o  m
            if (equalTester.test(orig, update)) {
                origListContainsUpdate = true;
                if (remove) {
                    if (itemsToRemove == null) {
                        itemsToRemove = new ArrayList<>(origList);
                    }
                    itemsToRemove.remove(orig);
                }
                if (replace) {
                    origIter.set(update);
                }
                break;
            }
        }
        if (!origListContainsUpdate && add) {
            if (itemsToAdd == null) {
                itemsToAdd = new ArrayList<>();
            }
            itemsToAdd.add(update);
        }
    }
    if (remove) {
        if (itemsToRemove != null) {
            origList.removeAll(itemsToRemove);
        } else {
            origList.clear();
        }
    }
    if (itemsToAdd != null) {
        adder.accept(origList, itemsToAdd);
    }
}

From source file:com.wavemaker.commons.util.IOUtils.java

/**
 * Get all files (excluding directories) under dir.
 *//*from   ww  w  .jav  a 2  s.c  o m*/
public static Collection<File> getFiles(File indir) {
    if (!indir.isDirectory()) {
        throw new IllegalArgumentException("Expected directory as input");
    }
    Collection<File> rtn = new HashSet<File>();

    List<File> dirs = new ArrayList<File>();
    dirs.add(indir);

    while (!dirs.isEmpty()) {

        File dir = dirs.remove(0);

        String[] files = dir.list();
        for (String s : files) {
            File f = new File(dir, s);
            if (f.isDirectory()) {
                dirs.add(f);
            } else {
                rtn.add(f);
            }
        }
    }

    return rtn;
}

From source file:com.ocs.dynamo.dao.query.JpaQueryBuilder.java

private static Predicate createOrPredicate(CriteriaBuilder builder, Root<?> root, Filter filter) {
    Or or = (Or) filter;/*from  w w w  .  j  av  a2 s. c om*/
    List<Filter> filters = new ArrayList<>(or.getFilters());

    Predicate predicate = null;
    if (!filters.isEmpty()) {
        predicate = createPredicate(filters.remove(0), builder, root);
        while (!filters.isEmpty()) {
            Predicate next = createPredicate(filters.remove(0), builder, root);
            if (next != null) {
                predicate = builder.or(predicate, next);
            }
        }
    }

    return predicate;
}

From source file:com.allinfinance.startup.init.MenuInfoUtil.java

/**
 * ??//from ww w  . j a v a  2  s. c  o m
 */
@SuppressWarnings("unchecked")
public static void init() {
    String hql = "from com.allinfinance.po.TblFuncInf t where t.FuncType in ('0','1','2') order by t.FuncId";
    ICommQueryDAO commQueryDAO = (ICommQueryDAO) ContextUtil.getBean("CommQueryDAO");
    List<TblFuncInf> funcInfList = commQueryDAO.findByHQLQuery(hql);
    for (int i = 0, n = funcInfList.size(); i < n; i++) {
        TblFuncInf tblFuncInf = funcInfList.get(i);
        Map<String, Object> menuBean = new LinkedHashMap<String, Object>();
        if (StringUtil.isEmpty(tblFuncInf.getIconPath()) || "-".equals(tblFuncInf.getIconPath().trim())) {
            menuBean.put(Constants.TOOLBAR_ICON, Constants.TOOLBAR_ICON_MENUITEM);
        } else {
            menuBean.put(Constants.TOOLBAR_ICON, tblFuncInf.getIconPath().trim());
        }

        if (Constants.MENU_LVL_1.equals(tblFuncInf.getFuncType())) {//??
            //            Map<String, Object> menuBean = new LinkedHashMap<String, Object>();
            menuBean.put(Constants.MENU_ID, tblFuncInf.getFuncId().toString().trim());
            menuBean.put(Constants.MENU_TEXT, tblFuncInf.getFuncName().trim());
            menuBean.put(Constants.MENU_CLS, Constants.MENU_FOLDER);
            allMenuBean.addJSONArrayElement(menuBean);
        } else if (Constants.MENU_LVL_2.equals(tblFuncInf.getFuncType())) {//??
            //            Map<String, Object> menuBean = new LinkedHashMap<String, Object>();
            menuBean.put(Constants.MENU_ID, tblFuncInf.getFuncId().toString().trim());
            menuBean.put(Constants.MENU_TEXT, tblFuncInf.getFuncName().trim());
            menuBean.put(Constants.MENU_PARENT_ID, tblFuncInf.getFuncParentId().toString().trim());
            menuBean.put(Constants.MENU_CLS, Constants.MENU_FOLDER);
            addLvl2Menu(menuBean);
        } else if (Constants.MENU_LVL_3.equals(tblFuncInf.getFuncType())) {
            //            Map<String, Object> menuBean = new LinkedHashMap<String, Object>();
            menuBean.put(Constants.MENU_ID, tblFuncInf.getFuncId().toString().trim());
            menuBean.put(Constants.MENU_TEXT, tblFuncInf.getFuncName().trim());
            menuBean.put(Constants.MENU_PARENT_ID, tblFuncInf.getFuncParentId().toString().trim());
            menuBean.put(Constants.MENU_LEAF, true);
            menuBean.put(Constants.MENU_URL, tblFuncInf.getPageUrl().trim());
            menuBean.put(Constants.MENU_CLS, Constants.MENU_FILE);

            //            if("-".equals(tblFuncInf.getIconPath().trim())) {
            //               menuBean.put(Constants.TOOLBAR_ICON, Constants.TOOLBAR_ICON_MENUITEM);
            //            } else {
            //               menuBean.put(Constants.TOOLBAR_ICON, tblFuncInf.getIconPath().trim());
            //            }
            addLvl3Menu(menuBean);

        }
    }

    //??
    List<Object> menuLvl1List = allMenuBean.getDataList();
    for (int i = 0; i < menuLvl1List.size(); i++) {
        Map<String, Object> menuLvl1Bean = (Map<String, Object>) menuLvl1List.get(i);
        if (!menuLvl1Bean.containsKey(Constants.MENU_CHILDREN)) {
            menuLvl1List.remove(i);
            i--;
            continue;
        }
        List<Object> menuLvl2List = (List<Object>) menuLvl1Bean.get(Constants.MENU_CHILDREN);
        for (int j = 0; j < menuLvl2List.size(); j++) {
            Map<String, Object> menuLvl2Bean = (Map<String, Object>) menuLvl2List.get(j);
            if (!menuLvl2Bean.containsKey(Constants.MENU_CHILDREN)) {
                menuLvl2List.remove(j);
                menuLvl1Bean.put(Constants.MENU_CHILDREN, menuLvl2List);
                menuLvl1List.set(i, menuLvl1Bean);
                allMenuBean.setDataList(menuLvl1List);
                j--;
            }
        }
    }
}

From source file:com.ocs.dynamo.dao.query.JpaQueryBuilder.java

/**
 * Creates a predicate based on an "And" filter
 * //from   w  ww  .j  a  v  a 2s.c o  m
 * @param builder
 *            the criteria builder
 * @param root
 *            the root object
 * @param filter
 *            the "And" filter
 * @return
 */
private static Predicate createAndPredicate(CriteriaBuilder builder, Root<?> root, Filter filter) {
    And and = (And) filter;
    List<Filter> filters = new ArrayList<>(and.getFilters());

    Predicate predicate = null;
    if (!filters.isEmpty()) {
        predicate = createPredicate(filters.remove(0), builder, root);
        while (!filters.isEmpty()) {
            Predicate next = createPredicate(filters.remove(0), builder, root);
            if (next != null) {
                predicate = builder.and(predicate, next);
            }
        }
    }
    return predicate;
}

From source file:de.alpharogroup.collections.ListExtensions.java

/**
 * Shuffle selected elements in the source list to the destination list from the given indexes
 * in the array selectedElements./*from www .j  av  a  2s  . com*/
 *
 * @param <T>
 *            the generic type
 * @param source
 *            the source
 * @param destination
 *            the destination
 * @param selectedElements
 *            the selected elements
 */
public static <T> void shuffle(final List<T> source, final List<T> destination, final int[] selectedElements) {
    final int lastIndex = selectedElements.length - 1;
    for (int i = lastIndex; -1 < i; i--) {
        final int selectedRow = selectedElements[i];
        final T row = source.remove(selectedRow);
        destination.add(row);
    }
}

From source file:de._13ducks.cor.game.server.movement.SubSectorPathfinder.java

/**
 * Sucht einen Weg auf Freiflchen (FreePolygon) um ein Hindernis herum.
 * Beachtet weitere Hindernisse auf der "Umleitung".
 * Sucht die Route nur bis zum nchsten Ziel.
 * Der Mover darf sich nicht bereits auf einer Umleitung befinden,
 * diese muss ggf vorher gelscht worden sein.
 * @param mover/*from   w  w  w.  j  a  v a 2s.c  om*/
 * @param obstacle
 * @return 
 */
static List<SubSectorEdge> searchDiversion(Moveable mover, Moveable obstacle, SimplePosition target) {
    // Vorberprfung: Ist das Ziel berhaupt noch frei?
    List<Moveable> moversAroundTarget = Server.getInnerServer().moveMan.moveMap
            .moversAroundPoint(target.toFPP(), mover.getRadius() + 5);
    moversAroundTarget.remove(mover); // Falls drin
    for (Moveable m : moversAroundTarget) {
        if (m.getPrecisePosition().getDistance(target.toFPP()) < m.getRadius() + mover.getRadius()
                + ServerBehaviourMove.MIN_DISTANCE) {
            System.out.println("No div, target blocked!");
            return null;
        }
    }

    /**
     * Wegsuche in 2 Schritten:
     * 1. Aufbauen eines geeigneten Graphen, der das gesamte Problem enthlt.
     * 2. Suchen einer Route in diesem Graphen mittels A* (A-Star).
     */
    // Aufbauen des Graphen:
    ArrayList<SubSectorObstacle> graph = new ArrayList<SubSectorObstacle>(); // Der Graph selber
    LinkedList<Moveable> openObstacles = new LinkedList<Moveable>(); // Die Liste mit noch zu untersuchenden Knoten
    ArrayList<Moveable> closedObstacles = new ArrayList<Moveable>(); // Bearbeitete Knoten

    openObstacles.add(obstacle); // Startpunkt des Graphen.
    closedObstacles.add(mover); // Wird im Graphen nicht mitbercksichtigt.
    double radius = mover.getRadius() + ServerBehaviourMove.MIN_DISTANCE;

    while (!openObstacles.isEmpty()) {
        // Neues Element aus der Liste holen und als bearbeitet markieren.
        Moveable work = openObstacles.poll();
        closedObstacles.add(work);
        SubSectorObstacle next = new SubSectorObstacle(work.getPrecisePosition().x(),
                work.getPrecisePosition().y(), work.getRadius());
        // Zuerst alle Punkte des Graphen lschen, die jetzt nichtmehr erreichbar sind:
        for (SubSectorObstacle obst : graph) {
            obst.removeNearNodes(next, radius);
        }
        // Mit Graph vernetzen
        for (SubSectorObstacle node : graph) {
            if (node.inColRange(next, radius)) {
                // Schnittpunkte suchen
                SubSectorNode[] intersections = node.calcIntersections(next, radius);
                for (SubSectorNode n2 : intersections) {
                    boolean reachable = true;
                    for (SubSectorObstacle o : graph) {
                        if (o.equals(node)) {
                            continue; // Um den gehts jetzt ja gerade, natrlich liegen wir auf diesem Kreis
                        }
                        if (o.moveCircleContains(n2, radius)) {
                            reachable = false;
                            break;
                        }
                    }
                    if (reachable) {
                        // Schnittpunkt einbauen
                        next.addNode(n2);
                        node.addNode(n2);
                    }
                }
            }
        }
        // Bearbeitetes selbst in Graph einfgen
        graph.add(next);
        // Weitere Hindernisse suchen, die jetzt relevant sind.
        List<Moveable> moversAround = Server.getInnerServer().moveMan.moveMap.moversAround(work,
                (work.getRadius() + radius) * 2);
        for (Moveable pmove : moversAround) {
            if (!closedObstacles.contains(pmove) && !openObstacles.contains(pmove)) {
                openObstacles.add(pmove);
            }
        }
    }

    // Jetzt drber laufen und Graph aufbauen:
    for (SubSectorObstacle obst : graph) {
        // Vorgensweise:
        // In jedem Hinderniss die Linie entlanglaufen und Knoten mit Kanten verbinden.
        // Ein Knoten darf auf einem Kreis immer nur in eine Richtung gehen.
        // (das sollte mithilfe seiner beiden, bekannten hindernisse recht einfach sein)
        // Die Lnge des Kreissegments lsst sich einfach mithilfe des winkels ausrechnen (Math.atan2(y,x)
        // Dann darf der A*. Bzw. Dijkstra, A* ist hier schon fast Overkill.
        // Alle Knoten ihrem Bogenma nach sortieren.
        obst.sortNodes();
        obst.interConnectNodes(radius);
    }

    // Start- und Zielknoten einbauen und mit dem Graph vernetzten.
    SubSectorNode startNode = new SubSectorNode(mover.getPrecisePosition().x(), mover.getPrecisePosition().y());
    SubSectorNode targetNode = new SubSectorNode(target.x(), target.y());
    double min = Double.POSITIVE_INFINITY;
    SubSectorObstacle minObstacle = null;
    for (SubSectorObstacle obst : graph) {
        double newdist = Math.sqrt((obst.getX() - startNode.getX()) * (obst.getX() - startNode.getX())
                + (obst.getY() - startNode.getY()) * (obst.getY() - startNode.getY()));
        newdist -= obst.getRadius() + radius; // Es interessiert uns der nchstmgliche Kreis, nicht das nchste Hinderniss
        if (newdist < min) {
            min = newdist;
            minObstacle = obst;
        }
    }
    // Punkt auf Laufkreis finden
    Vector direct = new Vector(startNode.getX() - minObstacle.getX(), startNode.getY() - minObstacle.getY());
    direct = direct.normalize().multiply(minObstacle.getRadius() + radius);

    SubSectorNode minNode = new SubSectorNode(minObstacle.getX() + direct.getX(),
            minObstacle.getY() + direct.getY(), minObstacle);

    // In das Hinderniss integrieren:
    minObstacle.lateIntegrateNode(minNode);
    SubSectorEdge startEdge = new SubSectorEdge(startNode, minNode, min);

    if (!startNode.equals(minNode)) {

        startNode.addEdge(startEdge);
        minNode.addEdge(startEdge);

    } else {
        // Wir stehen schon auf dem minNode.
        // Die Einsprungkante ist nicht notwendig.
        startNode = minNode;
    }

    double min2 = Double.POSITIVE_INFINITY;
    SubSectorObstacle minObstacle2 = null;
    for (SubSectorObstacle obst : graph) {
        double newdist = Math.sqrt((obst.getX() - targetNode.getX()) * (obst.getX() - targetNode.getX())
                + (obst.getY() - targetNode.getY()) * (obst.getY() - targetNode.getY()));
        newdist -= obst.getRadius() + radius; // Es interessiert uns der nchstmgliche Kreis, nicht das nchste Hinderniss
        if (newdist < min2) {
            min2 = newdist;
            minObstacle2 = obst;
        }
    }
    // Punkt auf Laufkreis finden
    Vector direct2 = new Vector(targetNode.getX() - minObstacle2.getX(),
            targetNode.getY() - minObstacle2.getY());
    direct2 = direct2.normalize().multiply(minObstacle2.getRadius() + radius);

    SubSectorNode minNode2 = new SubSectorNode(minObstacle2.getX() + direct2.getX(),
            minObstacle2.getY() + direct2.getY(), minObstacle2);

    // In das Hinderniss integrieren:
    minObstacle2.lateIntegrateNode(minNode2);
    SubSectorEdge targetEdge = new SubSectorEdge(minNode2, targetNode, min2);

    if (!targetNode.equals(minNode2)) {

        targetNode.addEdge(targetEdge);
        minNode2.addEdge(targetEdge);

    } else {
        // Das Ziel ist schon auf dem Laufkreis.
        // Die Aussprungkante ist nicht ntig.
        targetNode = minNode2;
    }

    /**
     * Hier jetzt einen Weg suchen von startNode nach targetNode.
     * Die Kanten sind in node.myEdges
     * Die Ziele bekommt man mit edge.getOther(startNode)
     * Die Lnge (Wegkosten) stehen in edge.length (vorsicht: double-Wert!)
     */
    PriorityBuffer open = new PriorityBuffer(); // Liste fr entdeckte Knoten
    LinkedHashSet<SubSectorNode> containopen = new LinkedHashSet<SubSectorNode>(); // Auch fr entdeckte Knoten, hiermit kann viel schneller festgestellt werden, ob ein bestimmter Knoten schon enthalten ist.
    LinkedHashSet<SubSectorNode> closed = new LinkedHashSet<SubSectorNode>(); // Liste fr fertig bearbeitete Knoten

    double cost_t = 0; //Movement Kosten (gerade 5, diagonal 7, wird spter festgelegt)

    open.add(startNode);

    while (open.size() > 0) {
        SubSectorNode current = (SubSectorNode) open.remove();
        containopen.remove(current);

        if (current.equals(targetNode)) { //Abbruch, weil Weg von Start nach Ziel gefunden wurde
            //targetNode.setParent(current.getParent());   //"Vorgngerfeld" von Ziel bekannt
            break;
        }

        // Aus der open wurde current bereits gelscht, jetzt in die closed verschieben
        closed.add(current);

        ArrayList<SubSectorEdge> neighbors = current.getMyEdges();

        for (SubSectorEdge edge : neighbors) {

            SubSectorNode node = edge.getOther(current);

            if (closed.contains(node)) {
                continue;
            }

            // Kosten dort hin berechnen
            cost_t = edge.getLength();

            if (containopen.contains(node)) { //Wenn sich der Knoten in der openlist befindet, muss berechnet werden, ob es einen krzeren Weg gibt

                if (current.getCost() + cost_t < node.getCost()) { //krzerer Weg gefunden?

                    node.setCost(current.getCost() + cost_t); //-> Wegkosten neu berechnen
                    //node.setValF(node.cost + node.getHeuristic());  //F-Wert, besteht aus Wegkosten vom Start + Luftlinie zum Ziel
                    node.setParent(current); //aktuelles Feld wird zum Vorgngerfeld
                }
            } else {
                node.setCost(current.getCost() + cost_t);
                //node.setHeuristic(Math.sqrt(Math.pow(Math.abs((targetNode.getX() - node.getX())), 2) + Math.pow(Math.abs((targetNode.getY() - node.getY())), 2)));   // geschtzte Distanz zum Ziel
                //Die Zahl am Ende der Berechnung ist der Aufwand der Wegsuche
                //5 ist schnell, 4 normal, 3 dauert lange

                node.setParent(current); // Parent ist die RogPosition, von dem der aktuelle entdeckt wurde
                //node.setValF(node.cost + node.getHeuristic());  //F-Wert, besteht aus Wegkosten vom Start aus + Luftlinie zum Ziel
                open.add(node); // in openlist hinzufgen
                containopen.add(node);
            }
        }
    }

    if (targetNode.getParent() == null) { //kein Weg gefunden
        return null;
    }

    ArrayList<SubSectorNode> pathrev = new ArrayList<SubSectorNode>(); //Pfad aus parents erstellen, von Ziel nach Start
    while (!targetNode.equals(startNode)) {
        pathrev.add(targetNode);
        targetNode = targetNode.getParent();
    }
    pathrev.add(startNode);

    ArrayList<SubSectorNode> path = new ArrayList<SubSectorNode>(); //Pfad umkehren, sodass er von Start nach Ziel ist
    for (int k = pathrev.size() - 1; k >= 0; k--) {
        path.add(pathrev.get(k));
    }

    // Nachbearbeitung:
    // Wir brauchen eine Kanten-Liste mit arc/direct Informationen

    ArrayList<SubSectorEdge> finalPath = new ArrayList<SubSectorEdge>();
    for (int i = 0; i < path.size() - 1; i++) {
        SubSectorNode from = path.get(i);
        SubSectorNode to = path.get(i + 1);
        SubSectorEdge edge = shortestCommonEdge(from, to);
        if (edge != null) {
            finalPath.add(edge);
        } else {
            throw new RuntimeException("ERROR Cannot find edge from " + from + " to " + to
                    + " but it is part of the calculated path!!!");
        }
    }

    return finalPath; //Pfad zurckgeben
}