Java LinkedList.contains方法代码示例

import java.util.LinkedList; //导入方法依赖的package包/类
public static LinkedList<Entity> getAllEntitiesCarriedBySimEventsAtCurrentClockNoTrash(){
  LinkedList<Entity> returnList = new LinkedList<Entity>();
  LinkedList<Integer> entityTags = new LinkedList<Integer>();
  
  Iterator<SimEvent> itrEvents = ((HybridEventQueue)SimSystem.getFutureQueue()).getCurrentList().iterator();
  while(itrEvents.hasNext()){
    SimEvent anEvent = itrEvents.next();
    if(anEvent.eventTime() == SimSystem.clock()){
      Job job = (Job)anEvent.getData();
      
      if(job == null) 
      	continue;
      
      Entity entity = job.qnactrEntity;
      if(!entityTags.contains(entity.Tag) && !entity.Trash){
        entityTags.addLast(entity.Tag);
        returnList.addLast(entity);
      }
    }
    
  }
  
  return returnList;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public double calculate(NetworkStack stack) {
	
	LinkedList<Integer> vnetslayers = new LinkedList<Integer>();
	for (SubstrateNode sn : stack.getSubstrate().getVertices()) {
		for (AbstractResource r : sn.get()) {
			for (Mapping m : r.getMappings()) {
				if (m.getDemand().getOwner() != null) {
					if (!vnetslayers.contains(m.getDemand().getOwner().getLayer())) {
						vnetslayers.add(m.getDemand().getOwner().getLayer());
					}
				}
			}
		}
	}
	
	return vnetslayers.size();
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public static Collection<LinkedList<SubstrateLink>> getShortestPathsALinkGoesThrough(
		SubstrateNetwork sNetwork,
		SubstrateLink l,
		Transformer<SubstrateLink, Double> t) {
	
	Collection<LinkedList<SubstrateLink>> result = new LinkedList<LinkedList<SubstrateLink>>();
	
	Map<SubstrateNode, Collection<LinkedList<SubstrateLink>>> all =
			Utils.findAllShortestPaths(sNetwork, t);
	
	for (Entry<SubstrateNode, Collection<LinkedList<SubstrateLink>>> e : all.entrySet()) {
		for (LinkedList<SubstrateLink> path : e.getValue()) {
			
			if (path.contains(l)) {
				result.add(path);
				break;
			}
		}
	}
	
	return result;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public static void main(String args[]) throws Exception {

        LinkedList<String> options = new LinkedList<>(Arrays.asList(Utils.getTestJavaOpts()));

        // Need to consider the effect of TargetPLABWastePct=1 for G1 GC
        if (options.contains("-XX:+UseG1GC")) {
            VARIANCE = 2;
        } else {
            VARIANCE = 1;
        }

        negativeTest(-1, options);
        negativeTest(101, options);

        positiveTest(20, options);
        positiveTest(30, options);
        positiveTest(55, options);
        positiveTest(70, options);
    }
 

import java.util.LinkedList; //导入方法依赖的package包/类
public static String getCredentials(String smbPath, boolean forceCheck){
    if (!forceCheck && smbPath.indexOf('@') != -1){
        return smbPath;
    }
    LinkedList<String> credentialsList = getSingleSettingList();
    String noCreds = getNoCredentialsPath(smbPath);
    String path = noCreds;
    int position;
    while((position = path.lastIndexOf('/')) > 5){
        if (credentialsList.contains(path.substring(5, position+1))){
            String section = handleCredentials(path.substring(0, position+1));
            section = section.substring(0, section.length());
            return section+noCreds.substring(position+1);
        }
        path = path.substring(0, position);
    }
    return smbPath;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public static void removeClientId(String clientId) {
    Iterator<LinkedList<Message>> collection = container.values().iterator();
    LinkedList<Message> messages;
    Message message = new Message();
    message.setClientId(clientId);
    while (collection.hasNext()) {
        messages = collection.next();
        if (messages.contains(message)) {
            messages.remove(message);
        }
    }
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public static void saveCache(Context context, String... strs) {
    final ArrayList<String> hotCaches = CollectionUtil.toArrayList(loadHotCache(context.getResources()));
    final LinkedList<String> localCache = loadCache(context);

    // 避免重复添加
    for (String str : strs) {
        if (TextUtils.isEmpty(str) || TextUtils.isEmpty(str = str.trim()))
            continue;
        if (!hotCaches.contains(str) && !localCache.contains(str)) {
            localCache.addFirst(str);
        }
    }

    // 至多存储15条
    while (localCache.size() > 15) {
        localCache.removeLast();
    }

    CacheManager.saveToJson(context, CACHE_FILE, localCache);
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
private LinkedList<String> stringToList(String str) {
    LinkedList<String> ll = new LinkedList<>();

    // comma and space are valid delimites
    StringTokenizer st = new StringTokenizer(str, ", ");
    while (st.hasMoreTokens()) {
        String s = st.nextToken();
        if (!ll.contains(s)) {
            ll.add(s);
        }
    }
    return ll;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
/**
 * Finds all edge instances in the given array of faces, and returns
 * them in an array.  Each edge appears in the array once, although it
 * should be part of multiple faces.  Used by constructor.
 */
private static LineSegment[] allEdges(Polygon[] faces) {
    LinkedList list = new LinkedList();
    for(int i=0; i<faces.length; i++) {
        LineSegment[] edges= faces[i].getEdges();
        for(int j=0; j<edges.length; j++) {
            if(!list.contains(edges[j])) {
                list.add(edges[j]);
            }
        }
    }
    return (LineSegment[])list.toArray(new LineSegment[0]);
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
/**
 * Returns a list of all vertices appearing in the given array of
 * polytopes.  Each vertex appears in the list only once.  Used
 * by constructor.
 */
private static Vector[] allVertices(Polytope[] hyperPlanes) {
    LinkedList list = new LinkedList();
    for (int i = 0; i < hyperPlanes.length; i++) {
        Vector[] vertices = hyperPlanes[i].vertices;
        for (int j = 0; j < vertices.length; j++) {
            if (!list.contains(vertices[j])) {
                list.add(vertices[j]);
            }
        }
    }
    return (Vector[]) list.toArray(new Vector[0]);
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public List<AbstractNodeLoc> searchByClosest(Node start, Node end)
{
	// Always continues checking from the closest to target non-blocked
	// node from to_visit list. There's extra length in path if needed
	// to go backwards/sideways but when moving generally forwards, this is extra fast
	// and accurate. And can reach insane distances (try it with 800 nodes..).
	// Minimum required node count would be around 300-400.
	// Generally returns a bit (only a bit) more intelligent looking routes than
	// the basic version. Not a true distance image (which would increase CPU
	// load) level of intelligence though.

	// List of Visited Nodes
	FastNodeList visited = new FastNodeList(550);

	// List of Nodes to Visit
	LinkedList<Node> to_visit = new LinkedList<Node>();
	to_visit.add(start);
	short targetx = end.getLoc().getNodeX();
	short targety = end.getLoc().getNodeY();
	int dx, dy;
	boolean added;
	int i = 0;
	while (i < 550)
	{
		Node node;
		try
		{
			 node = to_visit.removeFirst();
		}
		catch (Exception e)
		{
			// No Path found
			return null;
		}
		if (node.equals(end)) //path found!
			return constructPath(node);
		else
		{
			i++;
			visited.add(node);
			node.attacheNeighbors();
			Node[] neighbors = node.getNeighbors();
			if (neighbors == null) continue;
			for (Node n : neighbors)
			{
				if (!visited.containsRev(n) && !to_visit.contains(n))
				{
					added = false;
					n.setParent(node);
					dx = targetx - n.getLoc().getNodeX();
					dy = targety - n.getLoc().getNodeY();
					n.setCost(dx*dx+dy*dy);
					for (int index = 0; index < to_visit.size(); index++)
					{
						// supposed to find it quite early..
						if (to_visit.get(index).getCost() > n.getCost())
						{
							to_visit.add(index, n);
							added = true;
							break;
						}
					}
					if (!added) to_visit.addLast(n);
				}
			}
		}
	}
	//No Path found
	return null;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
private static LinkedList<Project> URLs2Projects( Collection<URL> URLs ) {
    LinkedList<Project> result = new LinkedList<Project>();
        
    for(URL url: URLs) {
        FileObject dir = URLMapper.findFileObject( url );
        if ( dir != null && dir.isFolder() ) {
            try {
                Project p = ProjectManager.getDefault().findProject( dir );
                if ( p != null && !result.contains(p)) { //#238093, #238811 if multiple entries point to the same project we end up with the same instance multiple times in the linked list. That's wrong.
                    result.add( p );
                }
            }       
            catch ( Throwable t ) {
                //something bad happened during loading the project.
                //log the problem, but allow the other projects to be load
                //see issue #65900
                if (t instanceof ThreadDeath) {
                    throw (ThreadDeath) t;
                }
                
                ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, t);
            }
        }
    }
    
    return result;
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public final void addFileStatusListener (FileStatusListener l, FileObject mfo) {
    synchronized (listeners) {
        LinkedList<FileObject> lst = null;
        if (!listeners.containsKey (l)) {
            lst = new LinkedList<FileObject> ();
            listeners.put (l, lst);
        }
        else
            lst = listeners.get (l);
        
        if (!lst.contains (mfo))
            lst.add (mfo);
    }
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
@SuppressWarnings("unchecked") 
private void fireFileStatusChanged (FileObject mfo) {
    HashMap<FileStatusListener,LinkedList<FileObject>> h = null;
    
    synchronized (listeners) {
        h = (HashMap<FileStatusListener,LinkedList<FileObject>>)listeners.clone ();
    }
    
    for (Entry<FileStatusListener,LinkedList<FileObject>> entry: h.entrySet()) {
        FileStatusListener l = entry.getKey();
        LinkedList<FileObject> lst = entry.getValue();
        if (lst.contains (mfo))
            l.fileStatusChanged (mfo);
    }
}
 

import java.util.LinkedList; //导入方法依赖的package包/类
public void addEdge(StationGraphVO fromVertex, StationGraphVO... toVertice) {
	if (!edgesByVertices.containsKey(fromVertex))
		throw new NullPointerException("The fromVertex is not exists.");

	for(StationGraphVO toVertex : toVertice) {
		if (!edgesByVertices.containsKey(toVertex))
			throw new NullPointerException("The toVertex is not exists.");
		
		toVertex.setIdentifier(Identifier.NEXT);
		fromVertex.setIdentifier(Identifier.PREVIOUS);
		
		
		LinkedList<Edge> edges = edgesByVertices.get(fromVertex);
		Edge newEdge = new Edge(fromVertex, toVertex);
		// 중복 추가 방지 (정점 하나에 이어진 정점이 2개 이상 포함될 수가 없으므로)
		if(edges.contains(newEdge))
			return;
		
		edges.add(newEdge);
		
		// 무방향 그래프 대칭 처리
		if (graphType == GraphType.UNDIRECTED)
			addVertexForUndirectGraph(toVertex, fromVertex);
	}

	// fromVertex만 현재역으로 변환
	for(LinkedList<Edge> vertex : edgesByVertices.values()) {
		for(Edge edge : vertex) {
			edge.fromVertex.setIdentifier(Identifier.CURRENT);
		}
	}
}