java.util.LinkedHashMap#size ( )源码实例Demo

/**
 * Writes {@link LinkedHashMap}.
 *
 * @param map Map.
 * @param loadFactorFieldOff Load factor field offset.
 * @param accessOrderFieldOff access order field offset.
 * @param set Whether writing underlying map from {@link LinkedHashSet}.
 * @throws IOException In case of error.
 */
@SuppressWarnings("TypeMayBeWeakened")
void writeLinkedHashMap(LinkedHashMap<?, ?> map, long loadFactorFieldOff, long accessOrderFieldOff, boolean set)
    throws IOException {
    int size = map.size();

    writeInt(size);
    writeFloat(getFloat(map, loadFactorFieldOff));

    if (accessOrderFieldOff >= 0)
        writeBoolean(getBoolean(map, accessOrderFieldOff));
    else
        writeBoolean(false);

    for (Map.Entry<?, ?> e : map.entrySet()) {
        writeObject0(e.getKey());

        if (!set)
            writeObject0(e.getValue());
    }
}
 

public ArrayList<LinearConstraint> getFullPolytope(RCTuple conf){
    //Includes both atomic contact and voxel boundary constraints
    //DEBUG!!!  I think full polytope already has voxel constr??
    LinkedHashMap<DegreeOfFreedom,double[]> DOFBounds = calcDOFBounds(conf);
    ArrayList<DegreeOfFreedom> DOFs = new ArrayList<>(DOFBounds.keySet());

    //Much like VoxelVDWListChecker.voxelPolygon
    ArrayList<LinearConstraint> polytope = getFullStericPolytope(conf, DOFs);
    if(polytope==null)
        return null;
    
    int dof=0;
    for(DegreeOfFreedom curDOF : DOFs){
        double unitVec[] = new double[DOFBounds.size()];
        unitVec[dof] = 1;
        double[] bounds = DOFBounds.get(curDOF);
        polytope.add(new LinearConstraint(unitVec,Relationship.GEQ,bounds[0]));
        polytope.add(new LinearConstraint(unitVec,Relationship.LEQ,bounds[1]));
        dof++;
    }
    
    return polytope;
}
 

public void putProfile(String name, LinkedHashMap < String, String > commands) {
    try {

        JSONObject items = new JSONObject();
        items.put("name", name);

        JSONArray commandArray = new JSONArray();
        for (int i = 0; i < commands.size(); i++) {
            JSONObject item = new JSONObject();
            item.put("path", commands.keySet().toArray()[i]);
            item.put("command", commands.values().toArray()[i]);
            commandArray.put(item);
        }

        items.put("commands", commandArray);

        items.put("id", UUID.randomUUID());

        putItem(items);
    } catch (JSONException e) {
        e.printStackTrace();
    }
}
 

/**
 * 把 名=值 参数表转换成字符串 (a=1,b=2 =>a=1&b=2)
 * 
 * @param map
 * @return
 */
public static String linkedHashMapToString(LinkedHashMap<String, String> map) {
	if (map != null && map.size() > 0) {
		String result = "";
		Iterator it = map.keySet().iterator();
		while (it.hasNext()) {
			String name = (String) it.next();
			String value = (String) map.get(name);
			result += (result.equals("")) ? "" : "&";
			result += String.format("%s=%s", name, value);
		}
		return result;
	}
	return null;
}
 

private static NodeIdentifierWithPredicates reorderPredicates(final List<QName> keys,
        final NodeIdentifierWithPredicates arg) {
    if (Iterables.elementsEqual(keys, arg.keySet())) {
        // Iteration order matches key order, reuse the identifier
        return arg;
    }

    // We care about iteration order here!
    final LinkedHashMap<QName, Object> map = Maps.newLinkedHashMapWithExpectedSize(arg.size());
    for (QName qname : keys) {
        final Object value = arg.getValue(qname);
        if (value != null) {
            map.put(qname, value);
        }
    }
    if (map.size() < arg.size()) {
        // Okay, this should not happen, but let's handle that anyway
        LOG.debug("Extra predicates in {} while expecting {}", arg, keys);
        for (Entry<QName, Object> entry : arg.entrySet()) {
            map.putIfAbsent(entry.getKey(), entry.getValue());
        }
    }

    // This copy retains iteration order and since we have more than one argument, it should always be
    // and ImmutableOffsetMap -- which is guaranteed to be taken as-is
    final Map<QName, Object> copy = ImmutableOffsetMap.orderedCopyOf(map);
    verify(copy instanceof ImmutableOffsetMap);
    return NodeIdentifierWithPredicates.of(arg.getNodeType(), (ImmutableOffsetMap<QName, Object>) copy);
}
 

private static LinkedHashMap<String, Field> deepCopy(LinkedHashMap<String, Field> listMap) {
  LinkedHashMap<String, Field> copy = new LinkedHashMap<>(listMap.size());
  for (Map.Entry<String, Field> entry: listMap.entrySet()) {
    Field field = entry.getValue();
    Utils.checkNotNull(field, Utils.formatL("ListMap has null element at '{}' pos", entry.getKey()));
    copy.put(entry.getKey(), field.clone());
  }
  return copy;
}
 

/**
 * Creates a {@link PojoSerializerSnapshotData} from configuration of a {@link PojoSerializer}.
 *
 * <p>This factory method is meant to be used in regular write paths, i.e. when taking a snapshot
 * of the {@link PojoSerializer}. All registered subclass classes, and non-registered
 * subclass classes are all present. Some POJO fields may be absent, if the originating
 * {@link PojoSerializer} was a restored one with already missing fields, and was never replaced
 * by a new {@link PojoSerializer} (i.e. because the serialized old data was never accessed).
 */
static <T> PojoSerializerSnapshotData<T> createFrom(
		Class<T> pojoClass,
		Field[] fields,
		TypeSerializer<?>[] fieldSerializers,
		LinkedHashMap<Class<?>, TypeSerializer<?>> registeredSubclassSerializers,
		Map<Class<?>, TypeSerializer<?>> nonRegisteredSubclassSerializers) {

	final LinkedOptionalMap<Field, TypeSerializerSnapshot<?>> fieldSerializerSnapshots = new LinkedOptionalMap<>(fields.length);

	for (int i = 0; i < fields.length; i++) {
		Field field = fields[i];
		String fieldName = (field == null) ? getDummyNameForMissingField(i) : field.getName();
		fieldSerializerSnapshots.put(fieldName, field, TypeSerializerUtils.snapshotBackwardsCompatible(fieldSerializers[i]));
	}

	LinkedHashMap<Class<?>, TypeSerializerSnapshot<?>> registeredSubclassSerializerSnapshots = new LinkedHashMap<>(registeredSubclassSerializers.size());
	registeredSubclassSerializers.forEach((k, v) -> registeredSubclassSerializerSnapshots.put(k, TypeSerializerUtils.snapshotBackwardsCompatible(v)));

	Map<Class<?>, TypeSerializerSnapshot<?>> nonRegisteredSubclassSerializerSnapshots = new HashMap<>(nonRegisteredSubclassSerializers.size());
	nonRegisteredSubclassSerializers.forEach((k, v) -> nonRegisteredSubclassSerializerSnapshots.put(k, TypeSerializerUtils.snapshotBackwardsCompatible(v)));

	return new PojoSerializerSnapshotData<>(
		pojoClass,
		fieldSerializerSnapshots,
		optionalMapOf(registeredSubclassSerializerSnapshots, Class::getName),
		optionalMapOf(nonRegisteredSubclassSerializerSnapshots, Class::getName));
}
 

static void capCache(LinkedHashMap<String, ?> map) {
    Iterator<String> it = map.keySet().iterator();
    while (map.size() > MAX_CACHE_SIZE && it.hasNext()) {
        it.next();
        it.remove();
    }
}
 

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 );
}
 

/**
 * for attribute valueLinkedMapStringBean serialization
 */
public static byte[] serializeValueLinkedMapStringBean(LinkedHashMap<String, Bean64> value) {
  if (value==null) {
    return null;
  }
  KriptonJsonContext context=KriptonBinder.jsonBind();
  try (KriptonByteArrayOutputStream stream=new KriptonByteArrayOutputStream(); JacksonWrapperSerializer wrapper=context.createSerializer(stream)) {
    JsonGenerator jacksonSerializer=wrapper.jacksonGenerator;
    jacksonSerializer.writeStartObject();
    int fieldCount=0;
    if (value!=null)  {
      fieldCount++;
      // write wrapper tag
      if (value.size()>0) {
        jacksonSerializer.writeFieldName("element");
        jacksonSerializer.writeStartArray();
        for (Map.Entry<String, Bean64> item: value.entrySet()) {
          jacksonSerializer.writeStartObject();
          jacksonSerializer.writeStringField("key", item.getKey());
          if (item.getValue()==null) {
            jacksonSerializer.writeNullField("value");
          } else {
            jacksonSerializer.writeFieldName("value");
            bean64BindMap.serializeOnJackson(item.getValue(), jacksonSerializer);
          }
          jacksonSerializer.writeEndObject();
        }
        jacksonSerializer.writeEndArray();
      } else {
        jacksonSerializer.writeNullField("element");
      }
    }
    jacksonSerializer.writeEndObject();
    jacksonSerializer.flush();
    return stream.toByteArray();
  } catch(Exception e) {
    e.printStackTrace();
    throw(new KriptonRuntimeException(e.getMessage()));
  }
}
 

public int flatNestedLinkedHashMap() {
	String notation = ".";
	ArrayList<String> list = Lists.newArrayList();
	list.add("AVX");
	Map<String, Object> map = Maps.newHashMap();
	map.put("name", "ABC");
	Map<String, Object> nestedParentMap = Maps.newHashMap();
	nestedParentMap.put("childString", "name");
	nestedParentMap.put("childList", list);
	nestedParentMap.put("childMap", map);
	LinkedHashMap<String, Object> value =  CommonUtils.flatNestedLinkedHashMap(notation, nestedParentMap);
	CommonUtils.flatNestedMap(notation, nestedParentMap);
	return value.size();
}
 

/**
 * for attribute valueLinkedMapStringBean serialization
 */
protected String serializeValueLinkedMapStringBean(LinkedHashMap<String, Bean64> value) {
  if (value==null) {
    return null;
  }
  KriptonJsonContext context=KriptonBinder.jsonBind();
  try (KriptonByteArrayOutputStream stream=new KriptonByteArrayOutputStream(); JacksonWrapperSerializer wrapper=context.createSerializer(stream)) {
    JsonGenerator jacksonSerializer=wrapper.jacksonGenerator;
    jacksonSerializer.writeStartObject();
    int fieldCount=0;
    if (value!=null)  {
      fieldCount++;
      // write wrapper tag
      if (value.size()>0) {
        jacksonSerializer.writeFieldName("valueLinkedMapStringBean");
        jacksonSerializer.writeStartArray();
        for (Map.Entry<String, Bean64> item: value.entrySet()) {
          jacksonSerializer.writeStartObject();
          jacksonSerializer.writeStringField("key", item.getKey());
          if (item.getValue()==null) {
            jacksonSerializer.writeNullField("value");
          } else {
            jacksonSerializer.writeFieldName("value");
            bean64BindMap.serializeOnJackson(item.getValue(), jacksonSerializer);
          }
          jacksonSerializer.writeEndObject();
        }
        jacksonSerializer.writeEndArray();
      } else {
        jacksonSerializer.writeNullField("valueLinkedMapStringBean");
      }
    }
    jacksonSerializer.writeEndObject();
    jacksonSerializer.flush();
    return stream.toString();
  } catch(Exception e) {
    e.printStackTrace();
    throw(new KriptonRuntimeException(e.getMessage()));
  }
}
 

/**
 * 存储Map集合
 *
 * @param key 键
 * @param map 存储的集合
 * @param <K> 指定Map的键
 * @param <T> 指定Map的值
 */

public static <K, T> void setMap(String key, LinkedHashMap<K, T> map) {
    if (map == null || map.isEmpty() || map.size() < 1) {
        return;
    }

    Gson gson = new Gson();
    String strJson = gson.toJson(map);
    editor.putString(key, strJson);
    editor.commit();
}
 

private void trim(int scale) {
	LinkedHashMap<Point2i, Image> scaleEntry = pool.get(scale);
	if (scaleEntry.size() <= tileMap.getVisibleTiles() * poolSize) {
		return;
	}
	Iterator<Point2i> it = scaleEntry.keySet().iterator();
	while (it.hasNext() && scaleEntry.size() > tileMap.getVisibleTiles() * poolSize) {
		it.next();
		it.remove();
	}
}
 

@Override
public void onClick(DialogInterface dialog, int which) {
	if (which == 0) {
		BackupManager.makeBackup(getActivity());
	} else if (which == 1) {
		LinkedHashMap<File, String> filesMap = BackupManager.getAvailableBackups(getActivity());
		if (filesMap != null && filesMap.size() > 0) {
			new RestoreFragment(filesMap).show(getFragmentManager(), RestoreFragment.class.getName());
		} else {
			ToastUtils.show(getActivity(), R.string.message_no_backups);
		}
	}
}
 

/**
 * 重定向页面
 *
 * @param locationClass 目标
 * @param mReqParams    附带参数 key ->value haspMap
 */
public void locationPage(Class<?> locationClass, LinkedHashMap<String, Object> mReqParams, boolean _target) {

    Intent intent = new Intent(this, locationClass);
    if (mReqParams != null && mReqParams.size() > 0) {

        Bundle bundle = new Bundle();
        for (String key : mReqParams.keySet()) {
            Object param = mReqParams.get(key);

            if (param instanceof Integer) {
                bundle.putInt(key, Integer.parseInt(param.toString()));
            } else if (param instanceof String) {
                bundle.putString(key, param.toString());
            } else if (param instanceof Double) {
            } else if (param instanceof Float) {
            } else if (param instanceof Long) {
            } else if (param instanceof Boolean) {
            } else if (param instanceof Date) {
            }
        }
        intent.putExtras(bundle);
    }
    if (_target) {
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    } else {
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    }
    intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

    this.startActivity(intent);

}
 

OptimizerResult(LinkedHashMap<Goal, ClusterModelStats> statsByGoalPriority,
                Set<String> violatedGoalNamesBeforeOptimization,
                Set<String> violatedGoalNamesAfterOptimization,
                Set<ExecutionProposal> proposals,
                BrokerStats brokerStatsBeforeOptimization,
                BrokerStats brokerStatsAfterOptimization,
                ModelGeneration modelGeneration,
                ClusterModelStats clusterModelStats,
                Map<Integer, String> capacityEstimationInfoByBrokerId,
                OptimizationOptions optimizationOptions,
                Map<String, Double> balancednessCostByGoal) {
  _clusterModelStatsComparatorByGoalName = new LinkedHashMap<>(statsByGoalPriority.size());
  _statsByGoalName = new LinkedHashMap<>(statsByGoalPriority.size());
  for (Map.Entry<Goal, ClusterModelStats> entry : statsByGoalPriority.entrySet()) {
    String goalName = entry.getKey().name();
    Goal.ClusterModelStatsComparator comparator = entry.getKey().clusterModelStatsComparator();
    _clusterModelStatsComparatorByGoalName.put(goalName, comparator);
    _statsByGoalName.put(goalName, entry.getValue());
  }

  _violatedGoalNamesBeforeOptimization = violatedGoalNamesBeforeOptimization;
  _violatedGoalNamesAfterOptimization = violatedGoalNamesAfterOptimization;
  _proposals = proposals;
  _brokerStatsBeforeOptimization = brokerStatsBeforeOptimization;
  _brokerStatsAfterOptimization = brokerStatsAfterOptimization;
  _modelGeneration = modelGeneration;
  _clusterModelStats = clusterModelStats;
  _capacityEstimationInfoByBrokerId = capacityEstimationInfoByBrokerId;
  _optimizationOptions = optimizationOptions;
  // Populate on-demand balancedness score before and after.
  _onDemandBalancednessScoreBefore = onDemandBalancednessScore(balancednessCostByGoal, _violatedGoalNamesBeforeOptimization);
  _onDemandBalancednessScoreAfter = onDemandBalancednessScore(balancednessCostByGoal, _violatedGoalNamesAfterOptimization);
}
 

/**
 * From R in residuals.coxph.S rowsum(rr, collapse)
 *
 * @param rr
 * @param sets
 * @return
 */
private static double[][] rowsum(double[][] rr, ArrayList<String> sets) throws Exception {
	LinkedHashMap<String, Double> sumMap = new LinkedHashMap<String, Double>();
	if (rr.length != sets.size()) {
		throw new Exception("Cluster value for each sample are not of equal length n=" + rr.length + " cluster length=" + sets.size());
	}
	double[][] sum = null;
	for (int j = 0; j < rr[0].length; j++) {
		for (int i = 0; i < sets.size(); i++) {
			String s = sets.get(i);
			Double v = sumMap.get(s); //get in order
			if (v == null) {
				v = 0.0;
			}
			v = v + rr[i][j];
			sumMap.put(s, v);

		}
		if (sum == null) {
			sum = new double[sumMap.size()][rr[0].length];
		}

		ArrayList<String> index = new ArrayList<String>(sumMap.keySet());
		//sorting does seem to make a difference in test cases at the .0000000001
   //     ArrayList<Integer> in = new ArrayList<Integer>();
   //     for (String s : index) {
   //         in.add(Integer.parseInt(s));
   //     }
   //     Collections.sort(index);

		for (int m = 0; m < index.size(); m++) {
			String key = index.get(m);
			sum[m][j] = sumMap.get(key);
		}

		sumMap.clear();
	}

	return sum;

}
 

private static DoubleMatrixDataset<String, String> generateRandomNormalizedPheno(LinkedHashMap<String, Integer> sampleHash, final int numberRandomPhenotypes) {

		LinkedHashMap<String, Integer> phenoHash = new LinkedHashMap<>();

		for (int i = 0; i < numberRandomPhenotypes; ++i) {
			phenoHash.put("RanPheno" + (i + 1), i);
		}

		DoubleMatrixDataset<String, String> phenoData = new DoubleMatrixDataset<>(sampleHash, phenoHash);

		DoubleMatrix2D phenoMatrix = phenoData.getMatrix();

		final int sampleCount = sampleHash.size();

		IntStream.range(0, numberRandomPhenotypes).parallel().forEach(pi -> {

			final ThreadLocalRandom rnd = ThreadLocalRandom.current();
			for (int s = 0; s < sampleCount; ++s) {
				phenoMatrix.setQuick(s, pi, rnd.nextGaussian());
			}

		});

		phenoData.normalizeColumns();

		return phenoData;

	}
 

/**
 * Return a copy of the source list.
 * 
 * @param src
 *            The source list.
 * @param variablesToKeep
 *            When non-<code>null</code>, only the bindings for the
 *            variables listed in this array will copied.
 * 
 * @return The copy.
 */
private LinkedHashMap<IVariable, IConstant> copy(
		final LinkedHashMap<IVariable, IConstant> src,
		final IVariable[] variablesToKeep) {

	final LinkedHashMap<IVariable, IConstant> dst = new LinkedHashMap<IVariable, IConstant>(
			variablesToKeep != null ? variablesToKeep.length : src.size());

	final Iterator<Map.Entry<IVariable, IConstant>> itr = src.entrySet()
			.iterator();

	while (itr.hasNext()) {

		final Map.Entry<IVariable, IConstant> e = itr.next();

		boolean keep = true;

		if (variablesToKeep != null) {
		
			keep = false;
			
			for (IVariable<?> x : variablesToKeep) {
			
				if (x == e.getKey()) {
				
					keep = true;
					
					break;
					
				}
				
			}
			
		}

		if (keep)
			dst.put(e.getKey(), e.getValue());

       }

	return dst;
	
}