下面列出了java.util.LinkedHashMap#remove ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private static int patchDelta(JsonReader jsonReader, LinkedHashMap<Number, byte[]> map)
throws IOException {
jsonReader.beginArray();
int numModules = 0;
while (jsonReader.hasNext()) {
jsonReader.beginArray();
int moduleId = jsonReader.nextInt();
if (jsonReader.peek() == JsonToken.NULL) {
jsonReader.skipValue();
map.remove(moduleId);
} else {
map.put(moduleId, jsonReader.nextString().getBytes());
}
jsonReader.endArray();
numModules++;
}
jsonReader.endArray();
return numModules;
}
@Override
@SuppressWarnings("unchecked")
public Object apply(List<Object> list) {
if(list.size() < 1) {
return null;
}
LinkedHashMap<Object, Integer> ret = (LinkedHashMap<Object, Integer>)list.get(0);
if (ret == null) {
ret = new LinkedHashMap<>();
}
for (int i = 1;i < list.size();++i) {
Object o = list.get(i);
if (o != null) {
Integer cnt = ret.get(o);
if (cnt == null) {
continue;
}
if (cnt == 1) {
ret.remove(o);
} else {
ret.put(o, cnt - 1);
}
}
}
return ret;
}
@Override
public void add(final E element) {
// If element is in some queue but the last one, upgrade it.
for (int i = 0; i < elements_.size() - 1; i++) {
final LinkedHashMap<E, Boolean> iThQueue = elements_.get(i);
if (iThQueue.remove(element) != null) {
elements_.get(i + 1).put(element, true);
return;
}
}
// else if element is in the last queue, reinsert it.
final LinkedHashMap<E, Boolean> lastQueue = elements_
.get(elements_.size() - 1);
if (lastQueue.containsKey(element)) {
lastQueue.put(element, true);
return;
}
// else put it on the first queue.
elements_.get(0).put(element, true);
}
private void updatePersistentData(Bucket toDelete) {
if (toDelete == null) {
return;
}
long millis = toDelete.gotTimeStamps ? toDelete.toMillis : System.currentTimeMillis();
for (Map.Entry<String, List<Entry<Point, UntypedMetric>>> metric : toDelete.getValuesByMetricName().entrySet()) {
LinkedHashMap<Point, TimeStampedMetric> cachedPoints = getCachedMetric(metric.getKey());
for (Entry<Point, UntypedMetric> newestInterval : metric.getValue()) {
// overwriting an existing entry does not update the order
// in the map
cachedPoints.remove(newestInterval.getKey());
TimeStampedMetric toInsert = new TimeStampedMetric(millis, newestInterval.getValue());
cachedPoints.put(newestInterval.getKey(), toInsert);
}
}
}
private boolean deleteCheckDep(String id, Handler<ExtendedAsyncResult<Void>> fut,
LinkedHashMap<String, ModuleDescriptor> mods) {
if (!mods.containsKey(id)) {
fut.handle(new Failure<>(ErrorType.NOT_FOUND, messages.getMessage("10207")));
return true;
}
mods.remove(id);
String res = DepResolution.checkAllDependencies(mods);
if (!res.isEmpty()) {
fut.handle(new Failure<>(ErrorType.USER, messages.getMessage("10208", id, res)));
return true;
} else {
return false;
}
}
/**
* redirects to query handler by using xeditor input document
*/
private static void redirectToQueryHandler(Document input, HttpServletResponse resp)
throws IOException, TransformerException, SAXException {
LinkedHashMap<String, String[]> parameters = new LinkedHashMap<>();
List<Element> children = input.getRootElement().getChildren();
for (Element param : children) {
String attribute = param.getAttributeValue("name");
if (attribute != null) {
parameters.put(attribute, new String[] { param.getTextTrim() });
}
}
String queryHandlerPath = parameters.get(QUERY_HANDLER_PAR_NAME)[0];
parameters.remove("qt");
doRedirectToQueryHandler(resp, queryHandlerPath, parameters);
}
public LinkedHashSet<NamedParameter> getNamedParameters(String resource, boolean excludeOverriden) throws Exception {
LinkedHashMap<String, NamedParameter> namedParameters = new LinkedHashMap<String, NamedParameter>();
Method method = getAnnotatedMethod(resource);
if (method != null) {
MethodParameterNames annotation = method.getAnnotation(MethodParameterNames.class);
String[] parameterNames = null;
if (annotation != null) {
parameterNames = annotation.value();
}
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterNames != null && parameterTypes != null) {
for (int i = 0; i < parameterNames.length; i++) {
namedParameters.put(parameterNames[i], new NamedParameter(parameterNames[i], parameterTypes[i]));
}
}
}
Iterator<Entry<String, Object>> it = defaults.entrySet().iterator();
while (it.hasNext()) {
Entry<String, Object> defaultParameter = it.next();
if (!namedParameters.containsKey(defaultParameter.getKey())) {
namedParameters.put(defaultParameter.getKey(), new NamedParameter(defaultParameter.getKey(), defaultParameter.getValue().getClass()));
}
}
it = overrides.entrySet().iterator();
while (it.hasNext()) {
Entry<String, Object> overrideParameter = it.next();
namedParameters.put(overrideParameter.getKey(), new NamedParameter(overrideParameter.getKey(), overrideParameter.getValue().getClass()));
}
if (excludeOverriden) {
it = overrides.entrySet().iterator();
while (it.hasNext()) {
namedParameters.remove(it.next().getKey());
}
}
return new LinkedHashSet<NamedParameter>(namedParameters.values());
}
public static Long getPageTotalCount(final SqlToyConfig sqlToyConfig, String conditionsKey) {
LinkedHashMap<String, Object[]> map = pageOptimizeCache.get(sqlToyConfig.getId());
// sql初次执行查询
if (null == map) {
return null;
}
Object[] values = map.get(conditionsKey);
// 为null表示条件初次查询或已经全部过期移除
if (null == values)
return null;
// 总记录数
Long totalCount = (Long) values[1];
// 失效时间
long expireTime = (Long) values[0];
long nowTime = System.currentTimeMillis();
// 先移除(为了调整排列顺序)
map.remove(conditionsKey);
// 超时,返回null表示需要重新查询，并不需要定时检测
// 1、控制总记录数量,最早的始终会排在最前面，会最先排挤出去
// 2、每次查询时相同的条件会自动检测是否过期，过期则会重新执行
if (nowTime >= expireTime) {
return null;
}
// 重置过期时间
values[0] = nowTime + sqlToyConfig.getPageAliveSeconds() * 1000;
// 重新置于linkedHashMap的最后位置
map.put(conditionsKey, values);
return totalCount;
}
public static void registPageTotalCount(final SqlToyConfig sqlToyConfig, String pageQueryKey, Long totalCount) {
long nowTime = System.currentTimeMillis();
// 当前时间
long expireTime = nowTime + sqlToyConfig.getPageAliveSeconds() * 1000;
// 同一个分页查询sql保留的不同查询条件记录数量
int aliveMax = sqlToyConfig.getPageAliveMax();
LinkedHashMap<String, Object[]> map = pageOptimizeCache.get(sqlToyConfig.getId());
if (null == map) {
map = new LinkedHashMap<String, Object[]>(sqlToyConfig.getPageAliveMax());
map.put(pageQueryKey, new Object[] { expireTime, totalCount });
pageOptimizeCache.put(sqlToyConfig.getId(), map);
} else {
map.put(pageQueryKey, new Object[] { expireTime, totalCount });
// 长度超阀值,移除最早进入的
while (map.size() > aliveMax) {
map.remove(map.keySet().iterator().next());
}
// 剔除过期数据
Iterator<Map.Entry<String, Object[]>> iter = map.entrySet().iterator();
Map.Entry<String, Object[]> entry;
while (iter.hasNext()) {
entry = iter.next();
// 当前时间已经大于过期时间
if (nowTime >= ((Long) entry.getValue()[0])) {
iter.remove();
} else {
break;
}
}
}
}
public ImmutableRowsIndex<T> replacingRows(
@NonNull final DocumentIdsSelection oldRowIds,
@NonNull final List<T> newRows)
{
final LinkedHashMap<DocumentId, T> newRowsToAdd = newRows.stream()
.collect(GuavaCollectors.toMapByKey(LinkedHashMap::new, IViewRow::getId));
final ArrayList<T> resultRows = new ArrayList<>(rowIds.size());
for (final DocumentId rowId : this.rowIds)
{
if (oldRowIds.contains(rowId))
{
final T newRowToAdd = newRowsToAdd.remove(rowId);
if (newRowToAdd != null)
{
resultRows.add(newRowToAdd);
}
}
else
{
resultRows.add(rowsById.get(rowId));
}
}
resultRows.addAll(newRowsToAdd.values());
return new ImmutableRowsIndex<>(this.initialRowIds, resultRows);
}
/**
* Get all the values from the metadata for the command
* without the specified keys
*/
public Map<String, Object> getValuesExcluding(String... keys) {
getMapVal(null);
if (hasError()) return emptyMap();//just to verify the type is Map
@SuppressWarnings("unchecked")
LinkedHashMap<String, Object> cp = new LinkedHashMap<>((Map<String, Object>) commandData);
if (keys == null) return cp;
for (String key : keys) {
cp.remove(key);
}
return cp;
}
/**
* After a collection was initialized or evicted, we don't
* need to batch fetch it anymore, remove it from the queue
* if necessary
*/
public void removeBatchLoadableCollection(CollectionEntry ce) {
LinkedHashMap<CollectionEntry, PersistentCollection> map = batchLoadableCollections.get( ce.getLoadedPersister().getRole() );
if ( map != null ) {
map.remove( ce );
}
}
public void addSummary( JobConfiguration jobConfiguration, Object summary )
{
LinkedHashMap<String, Object> summaries = summariesWithType.get( jobConfiguration.getJobType() );
if ( summaries.size() >= MAX_POOL_TYPE_SIZE )
{
String key = (String) summaries.keySet().toArray()[0];
summaries.remove( key );
}
summaries.put( jobConfiguration.getUid(), summary );
}
private boolean isFileExistsInCache(File file, String fileName, int type) {
if (waitCacheSync()) {
return false;
}
LinkedHashMap<String, CacheItem> cacheItems = getCacheItems(type);
synchronized (cacheItems) {
CacheItem cacheItem = cacheItems.get(fileName.toLowerCase(Locale.US));
if (cacheItem != null && !file.exists()) {
cacheItems.remove(cacheItem.nameLc);
modifyCacheSize(type, -cacheItem.length);
cacheItem = null;
}
return cacheItem != null;
}
}
public static LinkedHashMap<String, ResourceFilter> getFilterMap(
boolean showEmptyFolderFilter )
{
if ( !showEmptyFolderFilter )
{
LinkedHashMap map = (LinkedHashMap) filterMap.clone( );
map.remove( ResourceFilter.FILTER_EMPTY_FOLDERS );
return map;
}
else
return filterMap;
}
public String updateByCriteria(Table model) {
model.resetQueryConditions();
SQL sql = new SQL();
sql.UPDATE(ColumnWrapperUtils.wrap(model.getTableName()));
LinkedHashMap<String, Object> params = model.getParams();
if(params != null){
Iterator<String> iter = params.keySet().iterator();
while(iter.hasNext()){
String key = iter.next();
if(!model.getPrimaryKey().getFields().contains(key.toLowerCase())){
if(null == params.get(key)){
sql.SET(key + " = null");
}else{
String vstr = String.valueOf(params.get(key)).trim();
if(vstr.startsWith("=")){
sql.SET(ColumnWrapperUtils.wrap(key) + params.get(key));
params.remove(key);
}else{
sql.SET(buildSingleParamSql(FieldSqlGenerator.PARAM_PREFIX, key, model, "="));
}
}
}
}
}
if(model.hasVersion()){
sql.SET(VersionWrapperUtils.wrapSetSql(model.getVersion()));
}
QueryCriteria queryCriteria = model.getQueryCriteria();
String indexName = null;
if(queryCriteria.getOredCriteria() != null && queryCriteria.getOredCriteria().size() > 0){
indexName = caculationQueryCriteria(sql, model);
}
if(model.hasVersion()){
Object value = queryCriteria.getVersion();
if(null == value){
throw new DalSqlException("Version is request.");
}
sql.AND();
sql.WHERE(VersionWrapperUtils.wrapWhereSql(model.getVersion(), value));
}
model.resetQueryCriteria();
LOG.debug(sql.toString());
if(LOG.isDebugEnabled()){
if(StringUtils.isNotEmpty(indexName)){
LOG.debug("命中索引："+indexName+model.getContent().getIndexs().get(indexName));
}else{
LOG.debug("命中索引：无");
}
}
return sql.toString();
}
private void removeLast(LinkedHashMap<?, ?> map) {
map.remove(map.keySet().toArray()[map.size() - 1]);
}
private static LinkedHashMap<String,HashMap<String, ArrayList<EncodeNarrowPeak>>> readMultipleTfbsInformation(String inputFolderTfbsData) throws IOException {
LinkedHashMap<String,HashMap<String, ArrayList<EncodeNarrowPeak>>> data = new LinkedHashMap<>();
File file = new File(inputFolderTfbsData);
File[] files = file.listFiles();
ArrayList<String> vecFiles = new ArrayList<>();
for (File f : files) {
// System.out.println(f.getAbsolutePath());
vecFiles.add(f.getAbsolutePath());
}
for (String fileToRead : vecFiles) {
TextFile reader = new TextFile(fileToRead, TextFile.R);
String[] storingInformation = fileToRead.split("_");
// String cellLine = storingInformation[1].replace("TFBS\\","");
String transcriptionFactor = storingInformation[2].replace(".narrowPeak","");
if(storingInformation.length>4){
for(int i=3;i<(storingInformation.length-1);++i){
transcriptionFactor = transcriptionFactor +"_"+storingInformation[i].replace(".narrowPeak","");
}
}
String row;
while((row=reader.readLine())!=null){
String[] parts = StringUtils.split(row, '\t');
if(!data.containsKey(transcriptionFactor)){
data.put(transcriptionFactor, new HashMap<String, ArrayList<EncodeNarrowPeak>>());
}
if(!data.get(transcriptionFactor).containsKey(parts[0])){
data.get(transcriptionFactor).put(parts[0], new ArrayList<EncodeNarrowPeak>());
}
data.get(transcriptionFactor).get(parts[0]).add(new EncodeNarrowPeak(parts, fileToRead));
}
reader.close();
}
ArrayList<String> cleanList = new ArrayList<>();
for(Entry<String,HashMap<String, ArrayList<EncodeNarrowPeak>>> tfInformation : data.entrySet()){
System.out.println("Transcription factor: "+tfInformation.getKey());
int counter = 0;
for(Entry<String, ArrayList<EncodeNarrowPeak>> tfEntry : tfInformation.getValue().entrySet()){
Collections.sort(tfEntry.getValue());
counter+=tfEntry.getValue().size();
}
System.out.println("\tcontacts: "+counter);
//remove all with less than 750 contacts
// if(counter<750){
// cleanList.add(tfInformation.getKey());
// }
}
for(String k : cleanList){
data.remove(k);
}
return data;
}
@Override
public void actionPerformed(AnActionEvent e) {
LOG.info("actionPerformed GenerateLexerRulesForLiteralsAction");
final Project project = e.getProject();
final PsiFile psiFile = e.getData(LangDataKeys.PSI_FILE);
if (psiFile == null) {
return;
}
String inputText = psiFile.getText();
ParsingResult results = ParsingUtils.parseANTLRGrammar(inputText);
final Parser parser = results.parser;
final ParseTree tree = results.tree;
Collection<ParseTree> literalNodes = XPath.findAll(tree, "//ruleBlock//STRING_LITERAL", parser);
LinkedHashMap<String, String> lexerRules = new LinkedHashMap<String, String>();
for (ParseTree node : literalNodes) {
String literal = node.getText();
String ruleText = String.format("%s : %s ;",
RefactorUtils.getLexerRuleNameFromLiteral(literal), literal);
lexerRules.put(literal, ruleText);
}
// remove those already defined
String lexerRulesXPath = "//lexerRule";
String treePattern = "<TOKEN_REF> : <STRING_LITERAL>;";
ParseTreePattern p = parser.compileParseTreePattern(treePattern, ANTLRv4Parser.RULE_lexerRule);
List<ParseTreeMatch> matches = p.findAll(tree, lexerRulesXPath);
for (ParseTreeMatch match : matches) {
ParseTree lit = match.get("STRING_LITERAL");
if (lexerRules.containsKey(lit.getText())) { // we have rule for this literal already
lexerRules.remove(lit.getText());
}
}
final LiteralChooser chooser =
new LiteralChooser(project, new ArrayList<String>(lexerRules.values()));
chooser.show();
List<String> selectedElements = chooser.getSelectedElements();
// chooser disposed automatically.
final Editor editor = e.getData(PlatformDataKeys.EDITOR);
final Document doc = editor.getDocument();
final CommonTokenStream tokens = (CommonTokenStream) parser.getTokenStream();
// System.out.println(selectedElements);
if (selectedElements != null) {
String text = doc.getText();
int cursorOffset = editor.getCaretModel().getOffset();
// make sure it's not in middle of rule; put between.
// System.out.println("offset "+cursorOffset);
Collection<ParseTree> allRuleNodes = XPath.findAll(tree, "//ruleSpec", parser);
for (ParseTree r : allRuleNodes) {
Interval extent = r.getSourceInterval(); // token indexes
int start = tokens.get(extent.a).getStartIndex();
int stop = tokens.get(extent.b).getStopIndex();
// System.out.println("rule "+r.getChild(0).getText()+": "+start+".."+stop);
if (cursorOffset < start) {
// before this rule, so must be between previous and this one
cursorOffset = start; // put right before this rule
break;
}
else if (cursorOffset >= start && cursorOffset <= stop) {
// cursor in this rule
cursorOffset = stop + 2; // put right before this rule (after newline)
if (cursorOffset >= text.length()) {
cursorOffset = text.length();
}
break;
}
}
String allRules = Utils.join(selectedElements.iterator(), "\n");
text =
text.substring(0, cursorOffset) +
"\n" + allRules + "\n" +
text.substring(cursorOffset, text.length());
MyPsiUtils.replacePsiFileFromText(project, psiFile, text);
}
}
private void doFlushDB(boolean shutdown) {
DispatchRequestCollections requests = dispatchRequestBufferQueue.poll();
if (requests == null) {
return;
}
if (!shutdown) {
putEmptyRequestList();
}
boolean addSuccess = false, removeSuccess = false;
LinkedHashMap<Long, TransactionRecord> prepareTrs = null;
LinkedHashMap<Long, Void> confirmTrs = null;
while (true) {
if (requests.latch.get() != requests.requestlist.size() && requests.latch.get() > 0) {
continue;
}
requests.latch.set(Integer.MIN_VALUE);
if (requests.requestlist.size() == 0) {
break;
}
try {
long transactionOffset = -1L;
//数据处理
if (prepareTrs == null && confirmTrs == null) {
prepareTrs = new LinkedHashMap<Long, TransactionRecord>();
confirmTrs = new LinkedHashMap<Long, Void>();
for (DispatchRequest request : requests.requestlist) {
final int tranType = MessageSysFlag.getTransactionValue(request.getSysFlag());
switch (tranType) {
case MessageSysFlag.TRANSACTION_NOT_TYPE:
break;
case MessageSysFlag.TRANSACTION_PREPARED_TYPE:
if (this.maxTransOffset.get() < request.getCommitLogOffset()) {
prepareTrs.put(request.getCommitLogOffset(), new TransactionRecord(request.getCommitLogOffset(),
request.getCheckImmunityTimeOutTimestamp(), request.getMsgSize(), request.getProducerGroup()));
this.maxTransOffset.set(request.getCommitLogOffset());
} else {
log.info("[PREPARED] request ignore offset =" + request.getCommitLogOffset());
}
if (request.getPreparedTransactionOffset() == 0L) {
break;
}
case MessageSysFlag.TRANSACTION_COMMIT_TYPE:
case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE:
if (this.maxTransOffset.get() < request.getCommitLogOffset()) {
if (prepareTrs.containsKey(request.getPreparedTransactionOffset())) {
prepareTrs.remove(request.getPreparedTransactionOffset());
} else {
confirmTrs.put(request.getPreparedTransactionOffset(), null);
}
} else {
log.info("[COMMIT] request ignore offset =" + request.getCommitLogOffset()
+ ",isCommitMessge=" + (tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE));
}
break;
}
}
transactionOffset = requests.requestlist.get(requests.requestlist.size() - 1).getCommitLogOffset();
}
long startTime = System.currentTimeMillis();
addSuccess = addSuccess || transactionStore.parpare(new ArrayList<>(prepareTrs.values()));
if (addSuccess && (removeSuccess = transactionStore.confirm(new ArrayList<>(confirmTrs.keySet())))) {
log.info("pull TransactionRecord consume {}ms ,size={},realParpareSize={},realConfirmSize:{}",
(System.currentTimeMillis() - startTime), requests.requestlist.size(), prepareTrs.size(), confirmTrs.size());
//更新最新的offset
if (transactionOffset > 0) {
transactionOffsetConifgService.putOffset(transactionOffset);
}
break;
}
} catch (Throwable e) {
log.error("transactionStore error:", e);
ThreadUtils.sleep(2000);
} finally {
if (addSuccess && removeSuccess) {
flowController.release(requests.requestlist.size());
}
}
}
}