Java Code Examples for java.util.TreeSet#retainAll()

/**
 * Compare sequence dictionaries of 2 objects containing SDs
 * @param o1
 * @param description1 For including in messages
 * @param o2
 * @param description2 For including in messages
 */
public SequenceDictionaryIntersection(final Object o1, final String description1, final Object o2, final String description2) {
    final ObjectType type1 = getObjectType(o1, description1);
    final ObjectType type2 = getObjectType(o2, description2);
    this.description1 = (description1 != null? description1: type1.name());
    this.description2 = (description2 != null? description2: type2.name());;
    sequences1 = Collections.unmodifiableSet(getSequenceSet(getSequenceDictionary(o1, type1)));
    sequences2 = Collections.unmodifiableSet(getSequenceSet(getSequenceDictionary(o2, type2)));
    final TreeSet<String> intersection = new TreeSet<>(sequences1);
    intersection.retainAll(sequences2);
    this.intersection = Collections.unmodifiableSet(intersection);
    final TreeSet<String> onlyIn1 = new TreeSet<>(sequences1);
    onlyIn1.removeAll(sequences2);
    this.sequencesOnlyIn1 = Collections.unmodifiableSet(onlyIn1);
    final TreeSet<String> onlyIn2 = new TreeSet<>(sequences2);
    onlyIn1.removeAll(sequences1);
    this.sequencesOnlyIn2 = Collections.unmodifiableSet(onlyIn2);
}
 

/**
 * retainAll(c) retains only those elements of c and reports true if changed
 */
public void testRetainAll() {
    TreeSet q = populatedSet(SIZE);
    TreeSet p = populatedSet(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        boolean changed = q.retainAll(p);
        if (i == 0)
            assertFalse(changed);
        else
            assertTrue(changed);

        assertTrue(q.containsAll(p));
        assertEquals(SIZE - i, q.size());
        p.pollFirst();
    }
}
 

@Override
public void setResult(CKClassResult result) {
	
	/*
	 * LCOM = |P| - |Q| if |P| - |Q| > 0
	 * where
	 * P = set of all empty set intersections
	 * Q = set of all nonempty set intersections
	 */
	
	// extracted from https://github.com/dspinellis/ckjm
	int lcom = 0;
	for (int i = 0; i < methods.size(); i++)
	    for (int j = i + 1; j < methods.size(); j++) {
	    	
			TreeSet<?> intersection = (TreeSet<?>)methods.get(i).clone();
			intersection.retainAll(methods.get(j));
			if (intersection.size() == 0) lcom++;
			else lcom--;
	    }
	result.setLcom(lcom > 0 ? lcom : 0);
}
 

/**
 * retainAll(c) retains only those elements of c and reports true if changed
 */
public void testRetainAll() {
    TreeSet q = populatedSet(SIZE);
    TreeSet p = populatedSet(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        boolean changed = q.retainAll(p);
        if (i == 0)
            assertFalse(changed);
        else
            assertTrue(changed);

        assertTrue(q.containsAll(p));
        assertEquals(SIZE - i, q.size());
        p.pollFirst();
    }
}
 

@Override
public List<ArtifactMetadata> getConflictingArtifacts( MetadataRepository metadataRepository, String sourceRepo,
                                                       String targetRepo )
    throws RepositoryMergerException
{
    try(RepositorySession session = repositorySessionFactory.createSession())
    {
        TreeSet<ArtifactMetadata> targetArtifacts = new TreeSet<>(META_COMPARATOR);
        targetArtifacts.addAll(metadataRepository.getArtifacts(session , targetRepo ));
        TreeSet<ArtifactMetadata> sourceArtifacts = new TreeSet<>(META_COMPARATOR);
        sourceArtifacts.addAll(metadataRepository.getArtifacts(session , sourceRepo ));
        sourceArtifacts.retainAll(targetArtifacts);

        return new ArrayList<>(sourceArtifacts);
    }
    catch ( MetadataRepositoryException e )
    {
        throw new RepositoryMergerException( e.getMessage(), e );
    }
}
 

/**
 * 
 * @param textualUnit
 * @param spanType
 * @return A new <code>TreeSet</code> with the selected Spans 
 */
public TreeSet<Span> getSpans(Span textualUnit, String spanType){
	TreeSet<Span> spans = new TreeSet<>();
	spans.addAll(getSpans(textualUnit));
	spans.retainAll(getSpans(spanType));
	return spans;
}
 

public static void main (String [] args) throws Exception {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	int testCaseCount=Integer.parseInt(br.readLine());
	for (int i=0;i<testCaseCount;i++) {
		TreeMap<String,String> oldDict=new TreeMap<>();
		TreeMap<String,String> newDict=new TreeMap<>();
		
		updateDict(oldDict,br.readLine());
		updateDict(newDict,br.readLine());
		
		TreeSet<String> newKeys=new TreeSet<>();
		newKeys.addAll(newDict.keySet());
		newKeys.removeAll(oldDict.keySet());
		
		TreeSet<String> removedKeys=new TreeSet<>();
		removedKeys.addAll(oldDict.keySet());
		removedKeys.removeAll(newDict.keySet());
		
		TreeSet<String> changedKeys=new TreeSet<>();
		changedKeys.addAll(oldDict.keySet());
		changedKeys.retainAll(newDict.keySet());
		String [] changedKeysAry=changedKeys.toArray(new String [changedKeys.size()]);
		for (String s : changedKeysAry) if (oldDict.get(s).equals(newDict.get(s))) changedKeys.remove(s);
		
		StringBuilder sb=new StringBuilder();
		sb.append(toStr("+",newKeys));
		sb.append(toStr("-",removedKeys));
		sb.append(toStr("*",changedKeys));
		
		if (sb.length()==0) sb.append("No changes\n");
		
		System.out.println(sb.toString());
	}
}
 

private Set<Integer> removeNonExistentCycles(final int[] cycles) {

        final TreeSet<Integer> inputCyclesSet = new TreeSet<Integer>();
        for (final Integer inputCycle : cycles) {
            inputCyclesSet.add(inputCycle);
        }

        inputCyclesSet.retainAll(detectedCycles);

        return inputCyclesSet;
    }