Java ListUtils类代码示例

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Checks if column is modifiable.
 * 
 * @param groupSelectionMap
 *            the group selection map
 * @param selectionList
 *            the selection list
 * @return true, if is column modifiable
 */
public boolean isColumnModifiable(TreeMap<Integer,List<List<Integer>>> groupSelectionMap,List<Integer> selectionList){
	boolean retValue = false;
	for(int i=groupSelectionMap.lastKey();i>=0;i--){
		retValue=true;
		List<List<Integer>> groups = new ArrayList<>(groupSelectionMap.get(i));
		for (List<Integer> grp : groups) {
			if (ListUtils.intersection(selectionList, grp).size()>0) {
				retValue=false;
			}
	    }
	
		if(retValue){
			groupSelectionMap.get(i).add(selectionList);
			break;
		}
	}
	return retValue;
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
public void checkRoles(HttpSession httpSession, Role[] requiredRoles) throws AuthenticationException {
	List<Role> lRequiredRoles = Arrays.asList(requiredRoles);
	
	Role[] userRoles = roles(httpSession);
	if (userRoles == null) {
		throw new AuthenticationException("Authentication failure: no role defined");
	}
	
	List<Role> lUserRoles = Arrays.asList(userRoles);
	
	Engine.logAdmin.debug("User roles: " + lUserRoles);
	Engine.logAdmin.debug("Required roles: " + lRequiredRoles);

	// Check if the user has one (or more) role(s) in common with the required roles list
	if (!ListUtils.intersection(lUserRoles, lRequiredRoles).isEmpty()) {
		return;
	}
	
	throw new AuthenticationException("Authentication failure: user has not sufficient rights!");
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * 
 * @param keyValues
 * @param keyList
 * @param incomingList2 
 */
private void checkAndAdjustRowsColumns(List<HivePartitionFields> keyValues,List<String> keyList, List<InputHivePartitionColumn> incomingList)
{
	Set<String> colNames= new HashSet<>();
	for (int i=0; i < incomingList.size();i++) {
		
		colNames=extractColumnNamesFromObject(incomingList.get(i), colNames);
		 
		List<String> notAvailableFields = ListUtils.subtract(keyList,new ArrayList<>(colNames));   
		
	    if(null!=notAvailableFields&&notAvailableFields.size()>0){
	     for(String fieldName:notAvailableFields){
	    	 
	    	keyValues.get(i).getRowFields().add(keyList.indexOf(fieldName), "");
	     }
		}
	     colNames.clear();
	}

}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
@Override
protected void okPressed() {
	this.excelFormattingDataStructure = new ExcelFormattingDataStructure();
	
	if(StringUtils.isNotBlank(combo.getText())){
		excelFormattingDataStructure.setCopyOfField(combo.getText());
	}
	
	if(!StringUtils.equals(combo.getText(),"Select")){
		if(schemaFields !=null && !schemaFields.isEmpty() && draggedFields !=null && !draggedFields.isEmpty()){
			List remainingFields = ListUtils.subtract(schemaFields, draggedFields);
			excelFormattingDataStructure.setCopyFieldList(remainingFields);
		}
	}else{
		excelFormattingDataStructure.setCopyFieldList(new ArrayList<>());
	}
	
	
	
	if(targetTableViewer.getInput() !=null){
		excelFormattingDataStructure.setListOfExcelConfiguration((List<ExcelConfigurationDataStructure>) targetTableViewer.getInput());
	}
	super.okPressed();
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Rearrange groups.
 * 
 * @param groupSelectionMap
 *            the group selection map
 * @param selectionList
 *            the selection list
 */
public void rearrangeGroups(TreeMap<Integer, List<List<Integer>>> groupSelectionMap,List<Integer> selectionList) {
	List<Integer> tempList = new ArrayList<>();
	int lastKey=groupSelectionMap.lastKey();
	for (int i = lastKey; i >= 0; i--) {
		List<List<Integer>> groups =groupSelectionMap.get(i);
		for (int j=0; j<=groups.size()-1;j++) {
			if (selectionList.size()< groups.get(j).size()&& 
					ListUtils.intersection(selectionList, groups.get(j)).size() > 0) {
				tempList.addAll(groups.get(j));
				groups.get(j).clear();
				groups.set(j,new ArrayList<Integer>(selectionList));					
				selectionList.clear();
				selectionList.addAll(tempList);
			}
			tempList.clear();
		}
	}
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Rearrange groups after delete row.
 * 
 * @param groupSelectionMap
 *            the group selection map
 * @param selectionList
 *            the selection list
 * @return true, if successful
 */
public boolean rearrangeGroupsAfterDeleteRow(TreeMap<Integer, List<List<Integer>>> groupSelectionMap,
		List<Integer> selectionList) {
	boolean retValue = false;
	int lastKey = groupSelectionMap.lastKey();
	int count = 0;
	for (int i = lastKey; i >= 0; i--) {
		List<List<Integer>> groups = groupSelectionMap.get(i);
		for (int j = 0; j <= groups.size() - 1; j++) {
			if (selectionList.size() == groups.get(j).size() && ListUtils.isEqualList(selectionList, groups.get(j))) {
				count++;
				if (count >= 2) {
					retValue = true;
				}
			}
		}
	}
	return retValue;
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
public Mutect(GenomeLocParser genomeLocParser,
              RefContentProvider refContentProvider,
              SamContentProvider tumorContentProvider,
              SamContentProvider normalContentProvider,
              List<RODContentProvider> rodContentProviderList,
              List<GenomeLoc> intervals) {
    super(genomeLocParser, refContentProvider, tumorContentProvider, rodContentProviderList, intervals);
    if (normalContentProvider != null) {
        hasNormalBam = true;
        normalSamTraverser = getNormalLocusSamTraverser(normalContentProvider, intervals);
    } else {
        normalSamTraverser = getNormalLocusSamTraverser(
                new SamContentProvider(ListUtils.EMPTY_LIST, tumorContentProvider.getSamFileHeader()), intervals);
    }

    initialize();
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
@Override
public GroupIdList getAllGroupIds( List<String> selectedRepos )
    throws ArchivaRestServiceException
{
    List<String> observableRepos = getObservableRepos();
    List<String> repos = ListUtils.intersection( observableRepos, selectedRepos );
    if ( repos == null || repos.isEmpty() )
    {
        return new GroupIdList( Collections.<String>emptyList() );
    }
    try
    {
        return new GroupIdList( new ArrayList<>( repositorySearch.getAllGroupIds( getPrincipal(), repos ) ) );
    }
    catch ( RepositorySearchException e )
    {
        log.error( e.getMessage(), e );
        throw new ArchivaRestServiceException( e.getMessage(), e );
    }

}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Prepares the list of the group search base for a dynamic binding in Spring MVC.
 */
@SuppressWarnings("unchecked")
private void prepareGroupSearchBases() {
    List<LdapSearchBaseDefinition> searchBases = ListUtils.lazyList(
            new ArrayList<LdapSearchBaseDefinition>(), new Factory() {
                @Override
                public Object create() {
                    return LdapSearchBaseDefinition.Factory.newInstance();
                }
            });

    if (groupSyncConfig.getGroupSearch().getSearchBases().isEmpty()) {
        searchBases.add(LdapSearchBaseDefinition.Factory.newInstance());

    } else {
        searchBases.addAll(groupSyncConfig.getGroupSearch().getSearchBases());
    }
    groupSyncConfig.getGroupSearch().setSearchBases(searchBases);
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Prepares the list of the user search base for a dynamic binding in Spring MVC.
 */
@SuppressWarnings("unchecked")
private void prepareUserSearchBases() {
    List<LdapSearchBaseDefinition> searchBases = ListUtils.lazyList(
            new ArrayList<LdapSearchBaseDefinition>(), new Factory() {
                @Override
                public Object create() {
                    return LdapSearchBaseDefinition.Factory.newInstance();
                }
            });

    if (config.getUserSearch().getSearchBases().isEmpty()) {
        searchBases.add(LdapSearchBaseDefinition.Factory.newInstance());

    } else {
        searchBases.addAll(config.getUserSearch().getSearchBases());
    }
    config.getUserSearch().setSearchBases(searchBases);
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * check if the schema provided is a valid schema:
 * <li>schema is not indicated (only one element in the names list)<li/>
 *
 * @param names             list of schema and table names, table name is always the last element
 * @return throws a userexception if the schema is not valid.
 */
private void isValidSchema(final List<String> names) throws UserException {
  SchemaPlus defaultSchema = session.getDefaultSchema(this.rootSchema);
  String defaultSchemaCombinedPath = SchemaUtilites.getSchemaPath(defaultSchema);
  List<String> schemaPath = Util.skipLast(names);
  String schemaPathCombined = SchemaUtilites.getSchemaPath(schemaPath);
  String commonPrefix = SchemaUtilites.getPrefixSchemaPath(defaultSchemaCombinedPath,
          schemaPathCombined,
          parserConfig.caseSensitive());
  boolean isPrefixDefaultPath = commonPrefix.length() == defaultSchemaCombinedPath.length();
  List<String> fullSchemaPath = Strings.isNullOrEmpty(defaultSchemaCombinedPath) ? schemaPath :
          isPrefixDefaultPath ? schemaPath : ListUtils.union(SchemaUtilites.getSchemaPathAsList(defaultSchema), schemaPath);
  if (names.size() > 1 && (SchemaUtilites.findSchema(this.rootSchema, fullSchemaPath) == null &&
          SchemaUtilites.findSchema(this.rootSchema, schemaPath) == null)) {
    SchemaUtilites.throwSchemaNotFoundException(defaultSchema, schemaPath);
  }
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * Performs any filtering necessary on the collection before building the collection fields.
 *
 * <p>If showInactive is set to false and the collection line type implements {@code Inactivatable},
 * invokes the active collection filter. Then any {@link CollectionFilter} instances configured for the collection
 * group are invoked to filter the collection. Collections lines must pass all filters in order to be
 * displayed</p>
 *
 * @param view view instance that contains the collection
 * @param model object containing the views data
 * @param collectionGroup collection group component instance that will display the collection
 * @param collection collection instance that will be filtered
 */
protected List<Integer> performCollectionFiltering(View view, Object model, CollectionGroup collectionGroup,
        Collection<?> collection) {
    List<Integer> filteredIndexes = new ArrayList<Integer>();
    for (int i = 0; i < collection.size(); i++) {
        filteredIndexes.add(Integer.valueOf(i));
    }

    if (Inactivatable.class.isAssignableFrom(collectionGroup.getCollectionObjectClass()) && !collectionGroup
            .isShowInactiveLines()) {
        List<Integer> activeIndexes = collectionGroup.getActiveCollectionFilter().filter(view, model,
                collectionGroup);
        filteredIndexes = ListUtils.intersection(filteredIndexes, activeIndexes);
    }

    for (CollectionFilter collectionFilter : collectionGroup.getFilters()) {
        List<Integer> indexes = collectionFilter.filter(view, model, collectionGroup);
        filteredIndexes = ListUtils.intersection(filteredIndexes, indexes);
        if (filteredIndexes.isEmpty()) {
            break;
        }
    }

    return filteredIndexes;
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/** 
 * The accepted data types of a group item is the same as of the underlying base item.
 * If none is defined, the intersection of all sets of accepted data types of all group
 * members is used instead.
 * 
 * @return the accepted data types of this group item
 */
@SuppressWarnings("unchecked")
public List<Class<? extends State>> getAcceptedDataTypes() {
	if(baseItem!=null) {
		return baseItem.getAcceptedDataTypes();
	} else {
		List<Class<? extends State>> acceptedDataTypes = null;
		
		for(Item item : members) {
			if(acceptedDataTypes==null) {
				acceptedDataTypes = item.getAcceptedDataTypes();
			} else {
				acceptedDataTypes = ListUtils.intersection(acceptedDataTypes, item.getAcceptedDataTypes());
			}
		}
		return acceptedDataTypes == null ? ListUtils.EMPTY_LIST : acceptedDataTypes;
	}
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/** 
 * The accepted command types of a group item is the same as of the underlying base item.
 * If none is defined, the intersection of all sets of accepted command types of all group
 * members is used instead.
 * 
 * @return the accepted command types of this group item
 */
@SuppressWarnings("unchecked")
public List<Class<? extends Command>> getAcceptedCommandTypes() {
	if(baseItem!=null) {
		return baseItem.getAcceptedCommandTypes();
	} else {
		List<Class<? extends Command>> acceptedCommandTypes = null;
		
		for(Item item : members) {
			if(acceptedCommandTypes==null) {
				acceptedCommandTypes = item.getAcceptedCommandTypes();
			} else {
				acceptedCommandTypes = ListUtils.intersection(acceptedCommandTypes, item.getAcceptedCommandTypes());
			}
		}
		return acceptedCommandTypes == null ? ListUtils.EMPTY_LIST : acceptedCommandTypes;
	}
}
 

import org.apache.commons.collections.ListUtils; //导入依赖的package包/类
/**
 * get node evaluated to true with respect to formula (\neg arg1 \land \neg arg2) freshly
 * 
 * @param eu EU sub-formula in the form of E(arg1 U arg2)
 * @param arg1 the first argument of eu sub-formula
 * @param arg2 the second argument of eu sub-formula
 * 
 * @return list of ids of nodes
 */
@SuppressWarnings("unchecked")
private List<String> getUpdatedAlnsID4AUorEU(Composite arg1, Composite arg2)
{
	List<String> falArg1Alns = fal4SubFormula.get(arg1);
	List<String> falNewArg1Alns = falNew4SubFormula.get(arg1);
	List<String> falArg2Alns = fal4SubFormula.get(arg2);
	List<String> falNewArg2Alns = falNew4SubFormula.get(arg2);
	
	List<String> arg1_newArg2 = ListUtils.intersection(falArg1Alns, falNewArg2Alns);
	List<String> arg2_newArg1 = ListUtils.intersection(falNewArg1Alns, falArg2Alns);
	List<String> newArg1_newArg2 = ListUtils.intersection(falNewArg1Alns, falNewArg2Alns);
	
	List<String> arg1_arg2 = ListUtil.union(newArg1_newArg2,ListUtil.union(arg1_newArg2, arg2_newArg1));

	return arg1_arg2;
}