Java SortedSet类代码示例

import java.util.SortedSet; //导入依赖的package包/类
public static SortedSet<File> listMediaFiles(File dir)
{
	SortedSet<File> files = listFiles(dir);
	Iterator<File> iterator = files.iterator();

	while (iterator.hasNext())
	{
		File file = iterator.next();

		if (!file.isDirectory() && !isMediaFile(file))
		{
			iterator.remove();
		}
	}

	return files;
}
 

import java.util.SortedSet; //导入依赖的package包/类
@Test(expected = NullPointerException.class)
public void testNoProperties2() throws Exception {
    try (XmlFileStorageAdapter storage = new XmlFileStorageAdapter()) {
        storage.persistConfig(new ConfigSnapshotHolder() {
            @Override
            public String getConfigSnapshot() {
                return mock(String.class);
            }

            @Override
            public SortedSet<String> getCapabilities() {
                return new TreeSet<>();
            }
        });
    }
}
 

import java.util.SortedSet; //导入依赖的package包/类
private void setLineMap(Code_attribute attr) {
    SortedMap<Integer, SortedSet<Integer>> map =
            new TreeMap<Integer, SortedSet<Integer>>();
    SortedSet<Integer> allLines = new TreeSet<Integer>();
    for (Attribute a: attr.attributes) {
        if (a instanceof LineNumberTable_attribute) {
            LineNumberTable_attribute t = (LineNumberTable_attribute) a;
            for (LineNumberTable_attribute.Entry e: t.line_number_table) {
                int start_pc = e.start_pc;
                int line = e.line_number;
                SortedSet<Integer> pcLines = map.get(start_pc);
                if (pcLines == null) {
                    pcLines = new TreeSet<Integer>();
                    map.put(start_pc, pcLines);
                }
                pcLines.add(line);
                allLines.add(line);
            }
        }
    }
    lineMap = map;
    lineList = new ArrayList<Integer>(allLines);
}
 

import java.util.SortedSet; //导入依赖的package包/类
/**
 * Decodes the <code>inclusiveNamespaces</code> String and returns all
 * selected namespace prefixes as a Set. The <code>#default</code>
 * namespace token is represented as an empty namespace prefix
 * (<code>"xmlns"</code>).
 * <BR/>
 * The String <code>inclusiveNamespaces=" xenc    ds #default"</code>
 * is returned as a Set containing the following Strings:
 * <UL>
 * <LI><code>xmlns</code></LI>
 * <LI><code>xenc</code></LI>
 * <LI><code>ds</code></LI>
 * </UL>
 *
 * @param inclusiveNamespaces
 * @return A set to string
 */
public static SortedSet<String> prefixStr2Set(String inclusiveNamespaces) {
    SortedSet<String> prefixes = new TreeSet<String>();

    if ((inclusiveNamespaces == null) || (inclusiveNamespaces.length() == 0)) {
        return prefixes;
    }

    String[] tokens = inclusiveNamespaces.split("\\s");
    for (String prefix : tokens) {
        if (prefix.equals("#default")) {
            prefixes.add("xmlns");
        } else {
            prefixes.add(prefix);
        }
    }

    return prefixes;
}
 

import java.util.SortedSet; //导入依赖的package包/类
public ConfigSnapshotHolder toConfigSnapshot(final ConfigSnapshot configSnapshot) {
    return new ConfigSnapshotHolder() {
        @Override
        public String getConfigSnapshot() {
            return configSnapshot.getConfigSnapshot();
        }

        @Override
        public SortedSet<String> getCapabilities() {
            return configSnapshot.getCapabilities();
        }

        @Override
        public String toString() {
            return configSnapshot.toString();
        }
    };
}
 

import java.util.SortedSet; //导入依赖的package包/类
public static final boolean isDescending(SortedSet<?> set) {
    if (null == set.comparator()) {
        // natural order
        return false;
    }

    if (Collections.reverseOrder() == set.comparator()) {
        // reverse natural order.
        return true;
    }

    if (set.comparator().equals(Collections.reverseOrder(Collections.reverseOrder(set.comparator())))) {
        // it's a Collections.reverseOrder(Comparator).
        return true;
    }

    throw new IllegalStateException("can't determine ordering for " + set);
}
 

import java.util.SortedSet; //导入依赖的package包/类
@Override
   public SortedSet<Group> getGroupsNotAssignedToBranch(Long branchingActivityID) throws LessonServiceException {

BranchingActivity branchingActivity = (BranchingActivity) getActivityById(branchingActivityID);
if (branchingActivity == null) {
    String error = "getGroupsNotAssignedToBranch: Branching Activity missing missing. ActivityID was "
	    + branchingActivityID;
    MonitoringService.log.error(error);
    throw new MonitoringServiceException(error);
}

TreeSet<Group> unassignedGroups = new TreeSet<Group>();

Grouping grouping = branchingActivity.getGrouping();
Iterator groupIterator = grouping.getGroups().iterator();
while (groupIterator.hasNext()) {
    Group group = (Group) groupIterator.next();
    if ((group.getBranchActivities() == null) || (group.getBranchActivities().size() == 0)) {
	unassignedGroups.add(group);
    }
}

return unassignedGroups;

   }
 

import java.util.SortedSet; //导入依赖的package包/类
public List<SpaceDTO> loadSpaces(String namespace) {
    List<SpaceDTO> answer = new ArrayList<>();
    if (namespace != null) {
        try {
            Spaces spacesValue = Spaces.load(kubernetesClient, namespace);
            if (spacesValue != null) {
                SortedSet<Space> spaces = spacesValue.getSpaceSet();
                for (Space space : spaces) {
                    answer.add(new SpaceDTO(space.getName(), space.getName()));
                }
            }
        } catch (Exception e) {
            LOG.warn("Failed to load spaces: " + e, e);
        }
    }
    return answer;
}
 

import java.util.SortedSet; //导入依赖的package包/类
public void testSubSetContents2() {
    NavigableSet set = set5();
    SortedSet sm = set.subSet(two, three);
    assertEquals(1, sm.size());
    assertEquals(two, sm.first());
    assertEquals(two, sm.last());
    assertFalse(sm.contains(one));
    assertTrue(sm.contains(two));
    assertFalse(sm.contains(three));
    assertFalse(sm.contains(four));
    assertFalse(sm.contains(five));
    Iterator i = sm.iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(two, k);
    assertFalse(i.hasNext());
    Iterator j = sm.iterator();
    j.next();
    j.remove();
    assertFalse(set.contains(two));
    assertEquals(4, set.size());
    assertEquals(0, sm.size());
    assertTrue(sm.isEmpty());
    assertFalse(sm.remove(three));
    assertEquals(4, set.size());
}
 

import java.util.SortedSet; //导入依赖的package包/类
/**
    * Updates SessionMap using Notebook content.
    *
    * @param notebook
    * @param mode
    */
   private SessionMap<String, Object> createSessionMap(Notebook notebook, ToolAccessMode mode, String contentFolderID,
    Long toolContentID) {

SessionMap<String, Object> map = new SessionMap<String, Object>();

map.put(AuthoringAction.KEY_MODE, mode);
map.put(AuthoringAction.KEY_CONTENT_FOLDER_ID, contentFolderID);
map.put(AuthoringAction.KEY_TOOL_CONTENT_ID, toolContentID);
map.put(NotebookConstants.ATTR_DELETED_CONDITION_LIST, new ArrayList<NotebookCondition>());

SortedSet<NotebookCondition> set = new TreeSet<NotebookCondition>(new TextSearchConditionComparator());

if (notebook.getConditions() != null) {
    set.addAll(notebook.getConditions());
}
map.put(NotebookConstants.ATTR_CONDITION_SET, set);
return map;
   }
 

import java.util.SortedSet; //导入依赖的package包/类
/**
 * auto Adaptation List, NavigableSet, SortedSet, Set and Collection.
 * 
 * @param <T>
 *            the element type
 * @param collection
 *            the target collection
 * @return a unmodifiable collection
 */
public static <T> Collection<T> unmodifiable(Collection<T> collection) {

	if (collection instanceof List) {
		return Collections.unmodifiableList((List<? extends T>) collection);
	}
	/*
	 * else if (collection instanceof NavigableSet) {
	 * if(JDKVersion.isJdK18()){ //jdk1.8 return
	 * Collections.unmodifiableNavigableSet((NavigableSet<T>) collection); }
	 * }
	 */
	else if (collection instanceof SortedSet) {
		return Collections.unmodifiableSortedSet((SortedSet<T>) collection);
	} else if (collection instanceof Set) {
		return Collections.unmodifiableSet((Set<? extends T>) collection);
	}
	return Collections.unmodifiableCollection(collection);
}
 

import java.util.SortedSet; //导入依赖的package包/类
public Set<File> getProjectLibraries() {
	Set<File> classpath = new HashSet<>();

	SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");

	if (sourceSets != null) {
		SortedSet<String> availableSourceSetNames = sourceSets.getNames();
		for (String sourceSetName : Arrays.asList("main", "test", "integrationTest")) {
			if (availableSourceSetNames.contains(sourceSetName)) {
				SourceSet sourceSet = sourceSets.getByName(sourceSetName);
				classpath.add(sourceSet.getOutput().getClassesDir());
			}
		}
	}

	// add  dependencies from configured gradle configuration to url (usually test or integrationTest)
	TSGeneratorConfig generatorConfiguration = project.getExtensions().getByType(TSGeneratorConfig.class);
	String configurationName = generatorConfiguration.getRuntime().getConfiguration();

	ConfigurationContainer configurations = project.getConfigurations();
	Configuration runtimeConfiguration = configurations.findByName(configurationName + "Runtime");
	if (runtimeConfiguration == null) {
		runtimeConfiguration = configurations.getByName(configurationName);
	}
	classpath.addAll(runtimeConfiguration.getFiles());

	for (File file : classpath) {
		LOGGER.debug("classpath entry: {}", file);
	}

	return classpath;
}
 

import java.util.SortedSet; //导入依赖的package包/类
/**
 * Returns the set of nodes in this cell. Only call after
 * the cell has been completely fixed.
 */
public SortedSet<RuleNode> getNodes() {
    setFixed();
    if (this.nodes == null) {
        this.nodes = computeNodes();
    }
    return this.nodes;
}
 

import java.util.SortedSet; //导入依赖的package包/类
private static void assertNotEqualLenient(
    TreeSet<?> unexpected, SortedSet<?> actual) {
  try {
    assertThat(actual).isNotEqualTo(unexpected);
  } catch (ClassCastException accepted) {
  }
}
 

import java.util.SortedSet; //导入依赖的package包/类
@Test
public void testNullSafeAddAllWithEmptySet(){
	SortedSet<String> set = new TreeSet<>();
	set.add("b");
	Set<String> toAdd = new HashSet<>();
	toAdd.add("a");
	set = nullSafeSortedAddAll(set, toAdd);
	set.add("c");
	Assert.assertEquals(new String[]{"a", "b", "c"}, set.toArray());
}