import edu.uci.ics.jung.algorithms.filters.VertexPredicateFilter; //导入依赖的package包/类
public static  <V, E> Graph<V, E> filter(Graph<V, E> graph, final Collection<V> vertices) {
	
	Predicate<V> predicate = new Predicate<V>() {
		@Override
		public boolean evaluate(V vertex) {
			if(vertices.contains(vertex))
				return true;
		
			return false;
		}
	};

	//Filter graph
	Filter<V, E> verticesFilter = new VertexPredicateFilter<V, E>(predicate);
	graph = verticesFilter.transform(graph);

	return graph;
}
 

import edu.uci.ics.jung.algorithms.filters.VertexPredicateFilter; //导入依赖的package包/类
private G transformCurrentGraph(final FilterType filter, Map<String, DataMatcher> matcherMap, final Integer hops, final Set<String> pickedVertexes){
    final Map<String, GraphMLMetadata<String>> edgeMetadatas1 = graphmlLoader.getEdgeMetadatas();
    EdgePredicateFilter<String, String> edgeFilter = EdgeFilterFactory.createEdgeFilter(filter, matcherMap,edgeMetadatas1);
    final Graph<String, String> graph1 = edgeFilter.transform(currentGraph);

    VertexPredicateFilter<String, String> filterV = VertexFilterFactory.createVertexFilter(filter,matcherMap ,graphmlLoader.getVertexMetadatas(), graph1);

    G graph2 = (G) filterV.transform(graph1);
    HashSet<String> set = new HashSet<String>(graph2.getVertices());
    if (pickedVertexes != null) {
        if (pickedVertexes.size() != 0) {
            set.retainAll(pickedVertexes);
        }
    }
    KNeighborhoodFilter<String, String> f = new KNeighborhoodFilter<String, String>(set, hops, KNeighborhoodFilter.EdgeType.IN_OUT);
    return (G) f.transform(graph2);
}
 

import edu.uci.ics.jung.algorithms.filters.VertexPredicateFilter; //导入依赖的package包/类
/*******************************************************
 * Constructor.
 * 
 * @param tactic
 *            The {@link TreeQualityItem} that represents a tactic.
 *******************************************************/
public TacticVertexFilter(final TreeQualityItem tactic)
{
	mFilter = new VertexPredicateFilter<ICompilationUnit, EdgeWrapper>(new Predicate<ICompilationUnit>()
	{
		private final TreeQualityItem mTactic = tactic;

		/*******************************************************
		 * This predicate will determine whether to include the vertex in
		 * the filtered graph or not.
		 * 
		 * @param vertex
		 *            The vertex currently being processed
		 * @return ture if the vertex to be included in the filtered graph,
		 *         false otherwise.
		 *******************************************************/
		@Override
		public boolean evaluate(ICompilationUnit vertex)
		{
			boolean result = false;

			String fullPath = new File(vertex.getResource().getLocationURI()).getAbsolutePath();
			
			if (mTactic.containsFile(fullPath))
			{
				result = true;
			}

			return result;
		}
	});
}
 

import edu.uci.ics.jung.algorithms.filters.VertexPredicateFilter; //导入依赖的package包/类
private GenericNubiSaveComponent getGenericNubiSaveComponentByName(final String name) {
    Graph<AbstractNubisaveComponent, Object> nubisaveComponentGraph = new VertexPredicateFilter(new Predicate() {
        @Override
        public boolean evaluate(Object vertex) {
            return vertex instanceof GenericNubiSaveComponent &&
                    ((GenericNubiSaveComponent)vertex).getUniqueName().equals(name);
        }
    }).transform(graph);
    if(! nubisaveComponentGraph.getVertices().iterator().hasNext() ){
        return null;
    }
    return (GenericNubiSaveComponent)nubisaveComponentGraph.getVertices().iterator().next();
}
 

import edu.uci.ics.jung.algorithms.filters.VertexPredicateFilter; //导入依赖的package包/类
public static DirectedGraph<SEMOSSVertex, SEMOSSEdge>
		condense( DirectedGraph<SEMOSSVertex, SEMOSSEdge> graph,
				URI toremove, URI endpoint, EdgePropertySource strat ) {

	MultiMap<SEMOSSVertex, CondenserTuple> triples
			= findNodesToCondense( graph, toremove, endpoint );

	final VertexPredicateFilter<SEMOSSVertex, SEMOSSEdge> nomiddles
			= new VertexPredicateFilter<>( new Predicate<SEMOSSVertex>() {

				@Override
				public boolean apply( SEMOSSVertex input ) {
					return !triples.containsKey( input );
				}
			} );

	DirectedGraph<SEMOSSVertex, SEMOSSEdge> newgraph
			= (DirectedGraph<SEMOSSVertex, SEMOSSEdge>) nomiddles.apply( graph );

	// finally, makes the new edges from the condensed nodes
	for ( Map.Entry<SEMOSSVertex, List<CondenserTuple>> en : triples.entrySet() ) {
		SEMOSSVertex middle = en.getKey();

		for ( CondenserTuple tup : en.getValue() ) {
			SEMOSSVertex from = graph.getSource( tup.in );
			SEMOSSVertex to = graph.getDest( tup.out );

			SEMOSSEdge edge = new SEMOSSEdgeImpl( middle.getURI() );

			Map<URI, Value> props;
			switch ( strat ) {
				case NODE:
					props = middle.getValues();
					break;
				case INEDGE:
					props = tup.in.getValues();
					break;
				case OUTEDGE:
					props = tup.out.getValues();
					break;
				default:
					throw new IllegalArgumentException( "no edge property source provided!" );
			}

			for ( Map.Entry<URI, Value> prop : props.entrySet() ) {
				edge.setValue( prop.getKey(), prop.getValue() );
			}
			edge.setType( middle.getType() );

			newgraph.addEdge( edge, from, to, EdgeType.DIRECTED );
		}
	}

	return newgraph;
}