Java HashSet.add方法代码示例

import java.util.HashSet; //导入方法依赖的package包/类
@SuppressWarnings({"unchecked"})
private <T extends PIMEntity> HashSet<T> entitiesSwitch(T t){
    HashSet<T> items = new HashSet<T>();
    for(PIMEntity item : this){
        if(item.getClass().equals(t.getClass())){
            items.add((T)item);
        }
    }
    return items;
    /*原先的基于C#的泛型写法
    HashSet<T> items = new HashSet<T>();
    for(PIMEntity item : this){
        if(item instaceof T){
            items.add((T)item);
        }
    }
    return items;

     */
}
 

import java.util.HashSet; //导入方法依赖的package包/类
private HashMap<Tag, List<Integer>> getSnippetAnnotationRanks(
		List<List<Pair<ScoredAnnotation, HashMap<String, Double>>>> snippetAnnotations) {
	HashMap<Tag, List<Integer>> res = new HashMap<>();
	for (int rank=0; rank<snippetAnnotations.size(); rank ++){
		HashSet<Tag> alreadyInserted = new HashSet<>();
		for (Pair<ScoredAnnotation, HashMap<String, Double>> annAndInfo : snippetAnnotations.get(rank)){
			ScoredAnnotation ann = annAndInfo.first;
			Tag t = new Tag(ann.getConcept());
			if (alreadyInserted.contains(t))
				continue;
			alreadyInserted.add(t);
			if (!res.containsKey(t))
				res.put(t, new Vector<Integer>());
			res.get(t).add(rank);
		}
	}
	return res;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
/**
 * 
 */
private HashSet<TypeDescriptor> removeExistingImports(
        HashSet<TypeDescriptor> newImports,
        ArrayList<ImportInfo> curImports) {
    
    HashSet<TypeDescriptor> newSet = null;
    Iterator<TypeDescriptor> iterator = newImports.iterator();
    
    while (iterator.hasNext()) {
        TypeDescriptor curType = iterator.next();
        
        if (!containsType(curImports,curType)) {
            if (newSet == null) {
                newSet = new HashSet<>();
            }
            
            newSet.add(curType);
        }
    }
    
    return newSet;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
public HashSet<ScoredAnnotation> getUpperBoundMentions(String query,
		HashSet<Annotation> goldStandardAnn, BindingGenerator bg, SmaphDebugger debugger)
				throws Exception {
	QueryInformation qi = getQueryInformation(query, debugger);
	List<Triple<HashSet<Annotation>, BindingFeaturePack, Double>> bindingToFtrsAndF1 = getLBBindingToFtrsAndF1(
			query, qi, goldStandardAnn,
			new StrongMentionAnnotationMatch(), qi.allCandidates(), debugger);
	HashSet<Annotation> bestBinding = null;
	double bestF1 = Double.NEGATIVE_INFINITY;
	for (Triple<HashSet<Annotation>, BindingFeaturePack, Double> bindingAndFtrsAndF1 : bindingToFtrsAndF1) {
		double f1 = bindingAndFtrsAndF1.getRight();
		if (f1 > bestF1) {
			bestBinding = bindingAndFtrsAndF1.getLeft();
			bestF1 = f1;
		}
	}

	if (bestBinding == null) return null;

	HashSet<ScoredAnnotation> bestBindingScored= new HashSet<>();
	for (Annotation a : bestBinding)
		bestBindingScored.add(new ScoredAnnotation(a.getPosition(), a.getLength(), a.getConcept(), 1.0f));
	return bestBindingScored;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
@Test
public void getFormattedElement() {
  AccessLogParam param = new AccessLogParam();
  RoutingContext mockContext = Mockito.mock(RoutingContext.class);
  HashSet<Cookie> cookieSet = new HashSet<>();
  String cookieValue = "cookieValue";
  CookieImpl cookie = new CookieImpl(COOKIE_NAME, cookieValue);

  cookieSet.add(cookie);
  Mockito.when(mockContext.cookieCount()).thenReturn(1);
  Mockito.when(mockContext.cookies()).thenReturn(cookieSet);
  param.setRoutingContext(mockContext);

  String result = ELEMENT.getFormattedElement(param);

  Assert.assertEquals(cookieValue, result);
}
 

import java.util.HashSet; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private HashSet<PitClass> findAllPitClassesWithContactHoursForDepartmentsAndSubjectAreas(
		PointInTimeData pointInTimeData, Session hibSession) {
	
	HashSet<PitClass> pitClasses = new HashSet<PitClass>();
			
	for(Long deptId : getDepartmentIds()) {
		List<PitClass> pitClassesQueryResult = findAllPitClassesWithContactHoursForDepartment(pointInTimeData, deptId, hibSession);
		for(PitClass pc : pitClassesQueryResult) {
			if(pc.getPitSchedulingSubpart().getPitInstrOfferingConfig().getPitInstructionalOffering().getControllingPitCourseOffering().isIsControl().booleanValue() 
					&& getSubjectAreaIds().contains(pc.getPitSchedulingSubpart().getPitInstrOfferingConfig().getPitInstructionalOffering().getControllingPitCourseOffering().getSubjectArea().getUniqueId())) {
				pitClasses.add(pc);
			};
		}
	}
	return(pitClasses);

}
 

import java.util.HashSet; //导入方法依赖的package包/类
/**
 * invokeAll(collection) invokes all tasks in the collection
 */
public void testInvokeAllCollection() {
    RecursiveAction a = new CheckedRecursiveAction() {
        protected void realCompute() {
            AsyncFib f = new AsyncFib(8);
            AsyncFib g = new AsyncFib(9);
            AsyncFib h = new AsyncFib(7);
            HashSet set = new HashSet();
            set.add(f);
            set.add(g);
            set.add(h);
            invokeAll(set);
            assertEquals(21, f.number);
            assertEquals(34, g.number);
            assertEquals(13, h.number);
            checkCompletedNormally(f);
            checkCompletedNormally(g);
            checkCompletedNormally(h);
        }};
    testInvokeOnPool(mainPool(), a);
}
 

import java.util.HashSet; //导入方法依赖的package包/类
@Override
public Collection<? extends Point> find(Point from, Point destination, DistanceComparator distanceComparator,
		CollisionDetector collisionDetector)
{
	Map<Point, Point> parents = new HashMap<>();
	TreeSet<Point> openList = new TreeSet<>(distanceComparator);
	HashSet<Point> closedList = new HashSet<>();
	openList.add(from);
	Point n = null; 
	Point closestNode = from;
	while (!openList.isEmpty())
	{
		n = openList.pollFirst();

		if(distanceComparator.compare(closestNode, n) > 0)
			closestNode = n;
		if (n.equals(destination))
			return createPath(from, destination, parents);
		
		closedList.add(n);
		List<Point> successors = createSuccessors(n, collisionDetector);
		for (Point successor: successors)
		{
			if (!closedList.contains(successor))
			{
				openList.add(successor);
				if (!parents.containsKey(successor)) 
					parents.put(successor, n);
			}
		}
	}

	return createPath(from, closestNode, parents);
}
 

import java.util.HashSet; //导入方法依赖的package包/类
private HashSet<Course> toCourseSet(Collection<Long> courseIds) { // lazyload persistentset prevention
	HashSet<Course> result = new HashSet<Course>(courseIds.size());
	Iterator<Long> it = courseIds.iterator();
	while (it.hasNext()) {
		result.add(this.load(it.next()));
	}
	return result;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
/**
 * Adds any unique x-values from 'series' to the dataset, and also adds any x-values that are
 * in the dataset but not in 'series' to the series.
 *
 * @param series  the series (<code>null</code> not permitted).
 */
private void updateXPoints(XYSeries series) {
    if (series == null) {
        throw new IllegalArgumentException("Null 'series' not permitted.");
    }
    HashSet seriesXPoints = new HashSet();
    boolean savedState = this.propagateEvents;
    this.propagateEvents = false;
    for (int itemNo = 0; itemNo < series.getItemCount(); itemNo++) {
        Number xValue = series.getX(itemNo);
        seriesXPoints.add(xValue);
        if (!this.xPoints.contains(xValue)) {
            this.xPoints.add(xValue);
            for (int seriesNo = 0; seriesNo < this.data.size(); seriesNo++) {
                XYSeries dataSeries = (XYSeries) this.data.get(seriesNo);
                if (!dataSeries.equals(series)) {
                    dataSeries.add(xValue, null);
                } 
            }
        }
    }
    Iterator iterator = this.xPoints.iterator();
    while (iterator.hasNext()) {
        final Number xPoint = (Number) iterator.next();
        if (!seriesXPoints.contains(xPoint)) {
            series.add(xPoint, null);
        }
    }
    this.propagateEvents = savedState;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
@Override
public void generate() {
    HashSet<MethodSpec> methodSpecs = new LinkedHashSet<>();

    MethodSpec methodDelete = MethodSpec.methodBuilder(REMOVE_ALL)
            .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
            .returns(TypeName.VOID)
            .addAnnotation(AnnotationSpec.builder(Apply.class).build())
            .addJavadoc(REMOVE_ALL_METHOD_JAVA_DOC)
            .build();

    methodSpecs.add(methodDelete);

    TypeSpec typeSpec = TypeSpec.interfaceBuilder(Constants.IHANDLE)
            .addModifiers(Modifier.PUBLIC)
            .addMethods(methodSpecs)
            .addJavadoc(CLASS_JAVA_DOC)
            .build();

    try {
        JavaFile.builder(Constants.PACKAGE_NAME, typeSpec)
                .build()
                .writeTo(EnvironmentManager.getManager().getFiler());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

import java.util.HashSet; //导入方法依赖的package包/类
/**
 * @return list of recipients who did not receive the message because they left the view (null if
 *         all received it or it was sent to {@link DistributionMessage#ALL_RECIPIENTS}).
 * @throws NotSerializableException If content cannot be serialized
 */
public Set send(InternalDistributedMember[] destinations, DistributionMessage content,
    DistributionManager dm, DistributionStats stats) throws NotSerializableException {
  if (membershipManager == null) {
    logger.warn(LocalizedMessage.create(
        LocalizedStrings.DistributionChannel_ATTEMPTING_A_SEND_TO_A_DISCONNECTED_DISTRIBUTIONMANAGER));
    if (destinations.length == 1 && destinations[0] == DistributionMessage.ALL_RECIPIENTS)
      return null;
    HashSet result = new HashSet();
    for (int i = 0; i < destinations.length; i++)
      result.add(destinations[i]);
    return result;
  }
  return membershipManager.send(destinations, content, stats);
}
 

import java.util.HashSet; //导入方法依赖的package包/类
private static HashSet<Badge> restore(Bundle bundle) {
	HashSet<Badge> badges = new HashSet<>();

	String[] names = bundle.getStringArray(BADGES);
	for (int i = 0; i < names.length; i++) {
		try {
			badges.add(Badge.valueOf(names[i]));
		} catch (Exception e) {
		}
	}

	return badges;
}
 

import java.util.HashSet; //导入方法依赖的package包/类
@Test
public void testGapAckGen() {
    HashSet<Long> ls = new HashSet<>();
    ls.add(0L);
    ls.add(1L);
    ls.add(2L);
    ls.add(3L);
    ls.add(4L);

    ls.add(6L);
    ls.add(7L);

    ls.add(10L);

    List<SackUtil.GapAck> ackList = SackUtil.getGapAckList(ls);

    assertEquals(3,ackList.size());

    SackUtil.GapAck a = ackList.get(0);
    SackUtil.GapAck b = ackList.get(1);
    SackUtil.GapAck c = ackList.get(2);

    assertEquals(a.start,0L);
    assertEquals(a.end,4L);

    assertEquals(b.start,6L);
    assertEquals(b.end,7L);

    assertEquals(c.start,10L);
    assertEquals(c.end,10L);

}
 

import java.util.HashSet; //导入方法依赖的package包/类
/**
 * Returns all available external SD-Card roots in the system.
 *
 * @return paths to all available external SD-Card roots in the system.
 */
private List<String> getStorageDirectories() {
    final HashSet<String> out = new HashSet<String>();
    String reg = "(?i).*vold.*(vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*";
    String s = "";
    try {
        final Process process = new ProcessBuilder().command("mount")
                .redirectErrorStream(true).start();
        process.waitFor();
        final InputStream is = process.getInputStream();
        final byte[] buffer = new byte[1024];
        while (is.read(buffer) != -1) {
            s = s + new String(buffer);
        }
        is.close();
    } catch (final Exception e) {
        e.printStackTrace();
    }

    // parse output
    final String[] lines = s.split("\n");
    for (String line : lines) {
        if (!line.toLowerCase(Locale.US).contains("asec")) {
            if (line.matches(reg)) {
                String[] parts = line.split(" ");
                for (String part : parts) {
                    if (part.startsWith("/"))
                        if (!part.toLowerCase(Locale.US).contains("vold"))
                            out.add(part);
                }
            }
        }
    }
    return new ArrayList<>(out);
}