public static PackageInfo[] chooseModulePackages() { ClassInfo[] classes = Converter.rootClasses(); SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>(); for (ClassInfo cl : classes) { if (!cl.isModule()) { continue; } PackageInfo pkg = cl.containingPackage(); String name; if (pkg == null) { name = ""; } else { name = pkg.name(); } sorted.put(name, pkg); } ArrayList<PackageInfo> result = new ArrayList<PackageInfo>(); for (String s : sorted.keySet()) { PackageInfo pkg = sorted.get(s); result.add(pkg); } return result.toArray(new PackageInfo[result.size()]); }
/** * This method builds the custom data collections used on the form * * @param customAttributeGroups */ @SuppressWarnings("unchecked") public void buildCustomDataCollectionsOnNewDocument( SortedMap<String, List> customAttributeGroups) { for (Map.Entry<String, CustomAttributeDocument> customAttributeDocumentEntry : getCustomAttributeDocuments().entrySet()) { String temp = customAttributeDocumentEntry.getValue().getCustomAttribute().getValue(); String groupName = customAttributeDocumentEntry.getValue().getCustomAttribute().getGroupName(); T newCustomData = getNewCustomData(); newCustomData.setCustomAttribute( customAttributeDocumentEntry.getValue().getCustomAttribute()); newCustomData.setCustomAttributeId( customAttributeDocumentEntry.getValue().getCustomAttributeId().longValue()); newCustomData.setValue( customAttributeDocumentEntry.getValue().getCustomAttribute().getDefaultValue()); getCustomDataList().add(newCustomData); if (StringUtils.isEmpty(groupName)) { groupName = "No Group"; } List<CustomAttributeDocument> customAttributeDocumentList = customAttributeGroups.get(groupName); if (customAttributeDocumentList == null) { customAttributeDocumentList = new ArrayList<CustomAttributeDocument>(); customAttributeGroups.put(groupName, customAttributeDocumentList); } customAttributeDocumentList.add( getCustomAttributeDocuments() .get(customAttributeDocumentEntry.getValue().getCustomAttributeId().toString())); Collections.sort(customAttributeDocumentList, new LabelComparator()); } }
/** * Finds a suitable analyzer class for a magic signature * * @param signature the magic signature look up * @return the analyzer factory to use */ private static FileAnalyzerFactory find(byte[] signature) throws IOException { // XXX this assumes ISO-8859-1 encoding (and should work in most cases // for US-ASCII, UTF-8 and other ISO-8859-* encodings, but not always), // we should try to be smarter than this... char[] chars = new char[signature.length > 8 ? 8 : signature.length]; for (int i = 0; i < chars.length; i++) { chars[i] = (char) (0xFF & signature[i]); } String sig = new String(chars); FileAnalyzerFactory a = magics.get(sig); if (a == null) { String sigWithoutBOM = stripBOM(signature); for (Map.Entry<String, FileAnalyzerFactory> entry : magics.entrySet()) { if (sig.startsWith(entry.getKey())) { return entry.getValue(); } // See if text files have the magic sequence if we remove the // byte-order marker if (sigWithoutBOM != null && entry.getValue().getGenre() == Genre.PLAIN && sigWithoutBOM.startsWith(entry.getKey())) { return entry.getValue(); } } } return a; }
private void nastavPatterned() { if (blokujEventy) { return; } final RenderSettings.Patterned p = patterned.copy(); final int index = getSelectedIndex(); // aby tam vůbec vešel if (index >= 0) { final String key = keys.get(index); if (!geotaggingPatterns.isEmpty()) { // mame data geotaggingu p.setPatternNumberCilovy(key); if (souradnicovePatterns.containsKey(key)) { p.setPatternNumberPredbezny(key); } } else { // mame jen zakladni data p.setPatternNumberPredbezny(key); if (p.getPatternNumberCilovy() != null && souradnicovePatterns.containsKey(p.getPatternNumberCilovy())) { p.setPatternNumberCilovy(key); } } } p.setText((String) getSelectedItem()); setPatterned(p); }
/** * Returns the number of option values amongst all internal option containers. * * @return the number of option values amongst all internal option containers */ public int getNumberOfOptionValues() { SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet()); union.addAll(dependenciesResolvedOptionMap.keySet()); union.addAll(commandLineOptionMap.keySet()); union.addAll(optionFileOptionMap.keySet()); return union.size(); }
public CArray(Target t, int initialCapacity, Construct... items) { super("{}", ConstructType.ARRAY, t); if (initialCapacity == -1) { associative_mode = true; } else if (items != null) { for (Construct item : items) { if (item instanceof CEntry) { // it's an associative array associative_mode = true; break; } } } associative_array = new TreeMap<>(comparator); array = associative_mode ? new ArrayList<Construct>() : initialCapacity > 0 ? new ArrayList<Construct>(initialCapacity) : items != null ? new ArrayList<Construct>(items.length) : new ArrayList<Construct>(); if (associative_mode) { if (items != null) { for (Construct item : items) { if (item instanceof CEntry) { associative_array.put( normalizeConstruct(((CEntry) item).ckey), ((CEntry) item).construct); } else { int max = Integer.MIN_VALUE; for (String key : associative_array.keySet()) { try { int i = Integer.parseInt(key); max = java.lang.Math.max(max, i); } catch (NumberFormatException e) { } } if (max == Integer.MIN_VALUE) { max = -1; // Special case, there are no integer indexes in here yet. } associative_array.put(Integer.toString(max + 1), item); if (item instanceof CArray) { ((CArray) item).parent = this; } } } } } else { if (items != null) { for (Construct item : items) { array.add(item); if (item instanceof CArray) { ((CArray) item).parent = this; } } } this.next_index = array.size(); } regenValue(new HashSet<CArray>()); }
private DropdownMenu getDropDownOfQueries(String key, IWContext iwc) throws RemoteException, FinderException { SortedMap sortedMap = new TreeMap(new StringAlphabeticalComparator(iwc.getCurrentLocale())); DropdownMenu drp = new DropdownMenu(key); Iterator iterator = getQueryService(iwc).getQueries(iwc).iterator(); while (iterator.hasNext()) { EntityRepresentation userQuery = (EntityRepresentation) iterator.next(); String name = (String) userQuery.getColumnValue(QueryRepresentation.NAME_KEY); String id = userQuery.getPrimaryKey().toString(); if (sortedMap.containsKey(name)) { // usually the items have different names therefore we implement // a very simple solution name += " (1)"; } sortedMap.put(name, id); } Iterator sortedIterator = sortedMap.entrySet().iterator(); while (sortedIterator.hasNext()) { Map.Entry entry = (Map.Entry) sortedIterator.next(); String id = (String) entry.getValue(); String name = (String) entry.getKey(); drp.addMenuElement(id, name); } return drp; }
private void equivalent(int p1, int p2) { BitSet b = equivalence.get(p1); b.set(p2); b = equivalence.get(p2); b.set(p1); }
private void populateVMs(VirtualNetworkInfo vn, VmwareVirtualNetworkInfo vmwareVN) { SandeshObjectList<VirtualMachineInfo> vMachines = vn.getVMachines(); if (vMachines == null) { return; } SortedMap<String, VmwareVirtualMachineInfo> map = vmwareVN.getVmInfo(); if (map == null) { return; } for (Map.Entry<String, VmwareVirtualMachineInfo> entry : map.entrySet()) { VmwareVirtualMachineInfo vmwareVM = entry.getValue(); if (!vrouter.getEsxiHost().trim().equals(vmwareVM.getHostName().trim())) { continue; } VirtualMachineInfo vm = new VirtualMachineInfo(); vm.setName(vmwareVM.getName()); vm.setIpAddr(vmwareVM.getIpAddress()); vm.setMacAddr(vmwareVM.getMacAddress()); vm.setEsxiHost(vmwareVM.getHostName()); vm.setPowerState(vmwareVM.getPowerState().name()); vm.setNetwork(vn.getName()); vMachines.add(vm); } }
SortedMap<String, String> sortedFormattedHeaders(Header[] headers) { SortedMap<String, String> sortedHeaders = new TreeMap<>(); for (Header header : headers) { sortedHeaders.put(header.getName().toLowerCase(), header.getValue().trim()); } return sortedHeaders; }
private List<ChatMessage> sanitizeMap(final SortedMap<Date, ChatMessage> aMap) { if (aMap.isEmpty() || aMap.size() == 1) return Lists.newArrayList(aMap.values()); final LinkedList<ChatMessage> ret = Lists.newLinkedList(aMap.values()); final ListIterator<ChatMessage> i = ret.listIterator(); ChatMessage prevMsg = i.next(); do { ChatMessage msg = i.next(); if (!msg.getPreviousMessageDate().equals(prevMsg.getDate())) { if (msg.getPreviousMessageDate().before(prevMsg.getDate())) { msg.setPreviousMessageDate(prevMsg.getDate()); } else { final ChatMessage tmp = createLostMessageBetween( msg.getRoom(), prevMsg.getDate(), msg.getPreviousMessageDate()); aMap.put(tmp.getDate(), tmp); i.previous(); i.add(tmp); i.next(); msg = tmp; } } prevMsg = msg; } while (i.hasNext()); return ret; }
public SortedMap<String, T> getAsMap() { SortedMap<String, T> map = new TreeMap<String, T>(); for (T o : getStore()) { map.put(namer.determineName(o), o); } return map; }
protected static SortedMap<Integer, AgreementSummaryInstance> getAgreementSummaryList( List<Object[]> objects, boolean primary, boolean siteSearch) throws Exception { SortedMap<Integer, AgreementSummaryInstance> agreementMap = new TreeMap<Integer, AgreementSummaryInstance>(); AgreementSummaryInstance instance = null; for (Object[] row : objects) { if (row.length >= 1 && row[0] instanceof Agreement) { Agreement agreement = (Agreement) row[0]; if (agreementMap.containsKey(agreement.getId())) { instance = agreementMap.get(agreement.getId()); } else { instance = getAgreementSummaryInstance(agreement, primary, siteSearch); agreementMap.put(instance.getId(), instance); } } if (row.length == 2 && row[0] instanceof Agreement && row[1] != null && row[1] instanceof AgreementTerm) { AgreementTerm agreementTerm = (AgreementTerm) row[1]; applyAgreementTerm(instance, agreementTerm); } else if (row.length != 2 || !(row[0] instanceof Agreement) || !(row[1] == null || row[1] instanceof Agreement)) throw new Exception("Unexpected SQL result in getAgreementSummaryList"); } return agreementMap; // List<AgreementSummaryInstance> results = new ArrayList<AgreementSummaryInstance>(); // results.addAll(agreementMap.values()); // // return results; }
public static SortedMap<Integer, AgreementSummaryInstance> findAllAgreementSummaries( int ucn, List<Integer> ucns, boolean primary, char status, char neStatus) throws Exception { SortedMap<Integer, AgreementSummaryInstance> agreementMap = findBillAgreementSummaries(ucn, null, primary, status, neStatus); agreementMap.putAll(findSiteAgreementSummaries(ucn, primary, status, neStatus)); return agreementMap; }
/** * @param index * @param c */ public void set(Construct index, Construct c, Target t) { if (!associative_mode) { try { int indx = Static.getInt32(index, t); if (indx > next_index || indx < 0) { throw ConfigRuntimeException.BuildException( "", ExceptionType.IndexOverflowException, Target.UNKNOWN); } else if (indx == next_index) { this.push(c, t); } else { array.set(indx, c); } } catch (ConfigRuntimeException e) { // Not a number. Convert to associative. associative_array = new TreeMap<String, Construct>(comparator); for (int i = 0; i < array.size(); i++) { associative_array.put(Integer.toString(i), array.get(i)); } associative_mode = true; array = null; // null out the original array container so it can be GC'd } } if (associative_mode) { associative_array.put(normalizeConstruct(index), c); } if (c instanceof CArray) { ((CArray) c).parent = this; } regenValue(new HashSet<CArray>()); }
/** * return the contents of the buffer. The order of the chunks returned is determined by the * ejection policy, such that the chunk most likely to be given the book is first. */ @Override protected Collection<IChunk> getSourceChunksInternal(Collection<IChunk> container) { /* * there is nothing to return.. */ if (_sourceChunks.size() == 0) return container; List<IChunk> list = null; if (container instanceof List) list = (List<IChunk>) container; else list = new ArrayList<IChunk>(_sourceChunks.size()); list.addAll(_sourceChunks.values()); switch (getEjectionPolicy()) { case MostRecentlyAdded: case MostRecentlyMatched: case MostRecentlyUsed: Collections.reverse(list); break; } if (!(container instanceof List)) container.addAll(list); return container; }
@Override public Construct get(Construct index, Target t) { if (!associative_mode) { try { return array.get(Static.getInt32(index, t)); } catch (IndexOutOfBoundsException e) { throw ConfigRuntimeException.BuildException( "The element at index \"" + index.val() + "\" does not exist", ExceptionType.IndexOverflowException, t, e); } } else { if (associative_array.containsKey(normalizeConstruct(index))) { Construct val = associative_array.get(normalizeConstruct(index)); if (val instanceof CEntry) { return ((CEntry) val).construct(); } return val; } else { // Create this so we can at least attach a stacktrace. @SuppressWarnings({"ThrowableInstanceNotThrown", "ThrowableInstanceNeverThrown"}) IndexOutOfBoundsException ioobe = new IndexOutOfBoundsException(); throw ConfigRuntimeException.BuildException( "The element at index \"" + index.val() + "\" does not exist", ExceptionType.IndexOverflowException, t, ioobe); } } }
private String createParameterString() { // put required parameters for (OauthConstants constant : OauthConstants.values()) { String key = OAuth.percentEncode(constant.name()); String value = OAuth.percentEncode(properties.getProperty(constant.name())); if (constant.equals(OauthConstants.oauth_nonce)) { value = OAuth.percentEncode(nonce); } if (constant.equals(OauthConstants.oauth_timestamp)) { value = OAuth.percentEncode(String.valueOf(timestamp)); } parameterMap.put(key, value); } // put optional parameters for (Object key_ : optionalParameters.keySet()) { String keyStr = (String) key_; String key = OAuth.percentEncode(keyStr); String value = OAuth.percentEncode(optionalParameters.get(keyStr).toString()); parameterMap.put(key, value); } StringBuilder builder = new StringBuilder(); for (String s : parameterMap.keySet()) { builder.append(s).append('=').append(parameterMap.get(s)).append("&"); } builder.setLength(builder.lastIndexOf("&")); return builder.toString(); }
@Test public void testOrderBy() { final JPAEnvironment env = getEnvironment(); final EntityManager em = env.getEntityManager(); final SortedMap<String, Employee> attendeeMap = new TreeMap<String, Employee>(); try { env.beginTransaction(em); final Course course = createAndPersistCourse(em); final Long courseId = Long.valueOf(course.getCourseId()); final Employee employee1 = em.find(Employee.class, EMP_ID_DORIS); attendeeMap.put(employee1.getLastName(), employee1); final Employee employee2 = em.find(Employee.class, EMP_ID_SABINE); attendeeMap.put(employee2.getLastName(), employee2); env.commitTransactionAndClear(em); env.beginTransaction(em); final Course storedCourse = em.find(Course.class, courseId); verify(storedCourse != null, "didnt find course again"); final List<Employee> attendees = storedCourse.getAttendees(); verify(attendees != null, "course lost attendees"); final Iterator<Employee> orderedEmployees = attendees.iterator(); for (final String lastName : attendeeMap.keySet()) { Employee nextEmployee = orderedEmployees.next(); verify( nextEmployee.getLastName().equals(lastName), "wrong order of employees, expected name: " + lastName + ", but got name: " + nextEmployee.getLastName()); } env.commitTransactionAndClear(em); } finally { closeEntityManager(em); } }
public List<EntityKnowledge> getAllies() { List<EntityKnowledge> res = new LinkedList<>(); for (SortedMap<Integer, EntityKnowledge> map : allies.values()) { res.addAll(map.values()); } return res; }
/** * Takes a query string, separates the constituent name-value pairs, and stores them in a * SortedMap ordered by lexicographical order. * * @param queryString the query string * @return Null if there is no query string. */ private static SortedMap<String, String> createParameterMap(final String queryString) { if (queryString == null || queryString.isEmpty()) { return null; } final String[] pairs = queryString.split("&"); final SortedMap<String, String> params = new TreeMap<>(); for (final String pair : pairs) { if (pair.length() == 0) { continue; } String[] tokens = pair.split("=", 2); switch (tokens.length) { case 1: if (pair.charAt(0) == '=') { params.put("", tokens[0]); } else { params.put(tokens[0], ""); } break; case 2: params.put(tokens[0], tokens[1]); break; } } return params; }
@Override public synchronized void updateAccessData( String karafInstanceUrl, String karafInstanceUserName, String karafInstancePassword, Boolean remoteIsAccessible, Boolean allowUpdateMessages, String karafInstance) { if (karafInstance == null) throw new RuntimeException("karafInstance cannot be null"); if (karafInstanceUserName == null) throw new RuntimeException("username cannot be null"); if (karafInstancePassword == null) throw new RuntimeException("password cannot be null"); if (remoteIsAccessible == null) throw new RuntimeException("remoteIsAccessible cannot be null"); if (allowUpdateMessages == null) throw new RuntimeException("allowUpdateMessages cannot be null"); SortedMap<String, KarafManifestEntryJaxb> karafInstances = getKarafInstances(); if (!karafInstances.containsKey(karafInstance)) throw new RuntimeException("system does not know karafInstance=" + karafInstance); KarafManifestEntryJaxb ki = karafInstances.get(karafInstance); ki.setKarafInstancePassword(karafInstancePassword); ki.setKarafInstanceUserName(karafInstanceUserName); ki.setKarafInstanceUrl(karafInstanceUrl); ki.setRemoteIsAccessible(remoteIsAccessible); ki.setAllowUpdateMessages(allowUpdateMessages); persist(); }
public Channel getChannel(String name) { synchronized (channels) { Channel channel = channels.get(name); if (channel == null) { boolean resize = false; channel = channels.remove(INITIAL); if (channel == null) { channel = new Channel(name); resize = true; } else { channel.setName(name); } channels.put(name, channel); channelArray = channels.values().toArray(new Channel[channels.size()]); if (resize) { getDisplay() .syncExec( new Runnable() { public void run() { controlResized(null); } }); } } return channel; } }
public static Combo createEncodingCombo(Composite parent, String curCharset) { if (curCharset == null) { curCharset = GeneralUtils.getDefaultFileEncoding(); } Combo encodingCombo = new Combo(parent, SWT.DROP_DOWN); encodingCombo.setVisibleItemCount(30); SortedMap<String, Charset> charsetMap = Charset.availableCharsets(); int index = 0; int defIndex = -1; for (String csName : charsetMap.keySet()) { Charset charset = charsetMap.get(csName); encodingCombo.add(charset.displayName()); if (charset.displayName().equalsIgnoreCase(curCharset)) { defIndex = index; } if (defIndex < 0) { for (String alias : charset.aliases()) { if (alias.equalsIgnoreCase(curCharset)) { defIndex = index; } } } index++; } if (defIndex >= 0) { encodingCombo.select(defIndex); } else { log.warn("Charset '" + curCharset + "' is not recognized"); // $NON-NLS-1$ //$NON-NLS-2$ } return encodingCombo; }
/** * This method builds the custom data collections used on the form and populates the values from * the collection of AwardCustomData on the Award. * * @param customAttributeGroups */ @SuppressWarnings("unchecked") public void buildCustomDataCollectionsOnExistingDocument( SortedMap<String, List> customAttributeGroups) { for (Map.Entry<String, CustomAttributeDocument> customAttributeDocumentEntry : getCustomAttributeDocuments().entrySet()) { T loopAwardCustomData = null; for (T awardCustomData : getCustomDataList()) { if (awardCustomData.getCustomAttributeId() == (long) customAttributeDocumentEntry.getValue().getCustomAttribute().getId()) { loopAwardCustomData = awardCustomData; break; } } if (loopAwardCustomData != null) { String groupName = getCustomAttributeDocuments() .get(loopAwardCustomData.getCustomAttributeId().toString()) .getCustomAttribute() .getGroupName(); List<CustomAttributeDocument> customAttributeDocumentList = customAttributeGroups.get(groupName); if (customAttributeDocumentList == null) { customAttributeDocumentList = new ArrayList<CustomAttributeDocument>(); customAttributeGroups.put(groupName, customAttributeDocumentList); } customAttributeDocumentList.add( getCustomAttributeDocuments() .get(loopAwardCustomData.getCustomAttributeId().toString())); Collections.sort(customAttributeDocumentList, new LabelComparator()); } } }
private void resolveFields() { for (Method method : objectType.getMethods()) { if ((method.getModifiers() & Modifier.STATIC) != 0) { continue; } String fieldName = null; if (method.getName().startsWith("get")) { if (method.getName().equals("getId") || method.getName().length() <= 3) { continue; } // Found a field! fieldName = getFieldName(method.getName()); } else if (method.getName().startsWith("is")) { if (method.getName().length() <= 2) { continue; } // Found a field! fieldName = getFieldName(method.getName()); } if (fieldName != null) { fieldTypeMap.put(fieldName, method.getReturnType()); } } int index = 0; for (String fieldName : fieldTypeMap.keySet()) { fieldIndexMap.put(fieldName, index++); } }
private void printGameStats(HttpServletResponse resp) throws IOException { resp.setContentType(GAME_STATS_CONTENT_TYPE); PrintWriter writer = resp.getWriter(); SortedMap<Date, Game> games = db.getProcessedGames(); for (Entry<Date, Game> entry : games.entrySet()) { Game game = entry.getValue(); writer.println( entry.getKey() + GAME_STATS_DELIMITER + game.getHomeScore() + GAME_STATS_DELIMITER + game.getAwayScore()); for (String player : game.getHomeTeam()) writer.println( player + GAME_STATS_DELIMITER + num(game.getDeltaMu(), player) + GAME_STATS_DELIMITER + num(game.getDeltaSigma(), player)); writer.println(GAME_STATS_VERSUS); for (String player : game.getAwayTeam()) writer.println( player + GAME_STATS_DELIMITER + num(game.getDeltaMu(), player) + GAME_STATS_DELIMITER + num(game.getDeltaSigma(), player)); writer.println(); } }
/** * Pushes a new Construct onto the end of the array. If the index is specified, this works like a * "insert" operation, in that all values are shifted to the right, starting with the value at * that index. If the array is associative though, you MUST send null, otherwise an {@link * IllegalArgumentException} is thrown. Ideally, you should use {@link #set} anyways for an * associative array. * * @param c The Construct to add to the array * @throws IllegalArgumentException If index is not null, and this is an associative array. * @throws IndexOutOfBoundsException If the index is not null, and the index specified is out of * range. */ public void push(Construct c, Integer index, Target t) throws IllegalArgumentException, IndexOutOfBoundsException { if (!associative_mode) { if (index != null) { array.add(index, c); } else { array.add(c); } next_index++; } else { if (index != null) { throw new IllegalArgumentException("Cannot insert into an associative array"); } int max = 0; for (String key : associative_array.keySet()) { try { int i = Integer.parseInt(key); max = java.lang.Math.max(max, i); } catch (NumberFormatException e) { } } if (c instanceof CEntry) { associative_array.put(Integer.toString(max + 1), ((CEntry) c).construct()); } else { associative_array.put(Integer.toString(max + 1), c); } } if (c instanceof CArray) { ((CArray) c).parent = this; } regenValue(new HashSet<CArray>()); }
@Override protected void reportInContext( MetricContext context, SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { Assert.assertEquals(context.getName(), CONTEXT_NAME); Assert.assertEquals(gauges.size(), 1); Assert.assertTrue(gauges.containsKey(QUEUE_SIZE)); Assert.assertEquals(counters.size(), 1); Assert.assertTrue(counters.containsKey(RECORDS_PROCESSED)); Assert.assertEquals(histograms.size(), 1); Assert.assertTrue(histograms.containsKey(RECORD_SIZE_DISTRIBUTION)); Assert.assertEquals(meters.size(), 1); Assert.assertTrue(meters.containsKey(RECORD_PROCESS_RATE)); Assert.assertEquals(timers.size(), 2); Assert.assertTrue(timers.containsKey(TOTAL_DURATION)); }
/** * 删除节点。 @Title: removeCacheNode * * @author: zzh * @date: 2016年12月4日 下午8:34:15 * @version: v1.0.0 */ private static void removeCacheNode(String nodeIp) { // 删除当前IP的虚拟节点信息 CacheNode cacheNode = new CacheNode(nodeIp); // 获取当前节点的虚拟节点信息 List<VisualCacheNode> vNodesList = genVisualCacheNode(cacheNode); // 从hash环中删除虚拟节点信息 for (VisualCacheNode c : vNodesList) { String vNodeName = c.getNodeName(); String md5VisualNodeKey = DigestUtils.md5Hex(vNodeName); // 使用common-codec工具包 int hashNodeName = DJBHash(md5VisualNodeKey); visualNodeMap.remove(hashNodeName); System.out.println("删除虚拟节点,虚拟节点名称:" + vNodeName + ",真实节点:" + c.getRealCacheNode()); // 删除后,受到影响的节点:即数据和流量需要迁移到的节点信息 SortedMap<Integer, VisualCacheNode> vs = visualNodeMap.tailMap(hashNodeName); VisualCacheNode nodeInfo = null; if (vs != null && vs.size() > 0) { int affectVnshash = vs.firstKey(); nodeInfo = visualNodeMap.get(affectVnshash); } else { nodeInfo = visualNodeMap.get(visualNodeMap.firstKey()); } System.out.println("删除当前虚拟节点" + vNodeName + " , 受到影响的虚拟节点(原本虚拟节点的数据和流量将迁移到此节点):" + nodeInfo); } // 踢出真实节点 removeRealCache(nodeIp); }