添加查询约束条件，查找key类型是数组，该数组的长度匹配提供的数值。

@since 2.0.2
@param key 查询的key
@param size 数组的长度
@return
542525
public AVQuery<T> whereSizeEqual(String key, int size) {
    conditions.whereSizeEqual(key, size);
    return this;
  }
1306165
public static String fill(char c, int size) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            builder.append(c);
        }
        return builder.toString();
    }
1324333
public static RSAKeyString keyGen(int keySize) {
        try {
            RSAKey keys = RSA.keyGen(keySize);
            return new RSAKeyString(
                    Base64Util.encode2String(keys.getPublicKey().getEncoded()),
                    Base64Util.encode2String(keys.getPrivateKey().getEncoded())
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
30829
public long getCapacityBytesOnTiersOrThrow(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, java.lang.Long> map =
        internalGetCapacityBytesOnTiers().getMap();
    if (!map.containsKey(key)) {
      throw new java.lang.IllegalArgumentException();
    }
    return map.get(key);
  }
510045
public static void size(Map<?, ?> parameter, int size, String name) throws IllegalArgumentException {
		if (parameter.size() != size) {
			throw new IllegalArgumentException(String.format("%s size is not %d.", name, size));
		}
	}
111380
protected <K, V> Map<K, V> allocMap(int size) {
      return size == 0 ? Collections.emptyMap() : new HashMap<>(size * 4/3, 0.75f);
   }
772978
private static byte[] withCorrectBlockSize(final byte[] key) {
        if (key.length != CcAes.BLOCK) {
            throw new IllegalArgumentException(
                String.format(
                    "the length of the AES key must be exactly %d bytes",
                    CcAes.BLOCK
                )
            );
        }
        return key;
    }
1024657
public CacheManagerBuilder<T> withDefaultSizeOfMaxObjectGraph(long size) {
    DefaultSizeOfEngineProviderConfiguration configuration = configBuilder.findServiceByClass(DefaultSizeOfEngineProviderConfiguration.class);
    if (configuration == null) {
      return new CacheManagerBuilder<>(this, configBuilder.addService(new DefaultSizeOfEngineProviderConfiguration(DEFAULT_MAX_OBJECT_SIZE, DEFAULT_UNIT, size)));
    } else {
      ConfigurationBuilder builder = configBuilder.removeService(configuration);
      return new CacheManagerBuilder<>(this, builder.addService(new DefaultSizeOfEngineProviderConfiguration(configuration
        .getMaxObjectSize(), configuration.getUnit(), size)));
    }
  }
906285
public long sizeOf()
    {
        return INSTANCE_SIZE + SizeOf.sizeOf(key) + SizeOf.sizeOf(value) + SizeOf.sizeOf(used);
    }
447706
public static String formatSize(long size) {
        if (size < ValueConsts.KB) {
            return size + " B";
        } else if (size < ValueConsts.MB) {
            return formatDecimal((double) size / ValueConsts.KB) + " KB";
        } else if (size < ValueConsts.GB) {
            return formatDecimal((double) size / ValueConsts.MB) + " MB";
        } else if (size < ValueConsts.TB) {
            return formatDecimal((double) size / ValueConsts.GB) + " GB";
        } else {
            return formatDecimal((double) size / ValueConsts.TB) + " TB";
        }
    }
1099681
public Cell<C,T> size (Value<C,T> size) {
		minWidth = size;
		minHeight = size;
		prefWidth = size;
		prefHeight = size;
		maxWidth = size;
		maxHeight = size;
		return this;
	}
1205422
public void add(K key, V value)
  {
    if (key == null) {
      return;
    }

    K []keys = _keys;
    final int size = _size;
    
    for (int i = size - 1; i >= 0; i--) {
      if (key.equals(keys[i])) {
        _values[i].add(value);
        return;
      }
    }

    if (! ensureCapacity(size)) {
      return;
    }
    
    _keys[size] = key;
    _values[size] = new ArrayList<V>();
    _values[size].add(value);
    
    _size = size + 1;
  }
231671
public static final int getKeySize(Key key) {
        int size = -1;

        if (key instanceof Length) {
            try {
                Length ruler = (Length)key;
                size = ruler.length();
            } catch (UnsupportedOperationException usoe) {
                // ignore the exception
            }

            if (size >= 0) {
                return size;
            }
        }

        // try to parse the length from key specification
        if (key instanceof SecretKey) {
            SecretKey sk = (SecretKey)key;
            String format = sk.getFormat();
            if ("RAW".equals(format) && sk.getEncoded() != null) {
                size = (sk.getEncoded().length * 8);
            }   // Otherwise, it may be a unextractable key of PKCS#11, or
                // a key we are not able to handle.
        } else if (key instanceof RSAKey) {
            RSAKey pubk = (RSAKey)key;
            size = pubk.getModulus().bitLength();
        } else if (key instanceof ECKey) {
            ECKey pubk = (ECKey)key;
            ECParameterSpec params = pubk.getParams();
            // According to RFC 3279 section 2.3.5, EC keys are allowed
            // to inherit parameters in an X.509 certificate issuer's
            // key parameters, so the parameters may be null. The parent
            // key will be rejected if its parameters don't pass, so this
            // is okay.
            if (params != null) {
                size = params.getOrder().bitLength();
            }
        } else if (key instanceof DSAKey) {
            DSAKey pubk = (DSAKey)key;
            DSAParams params = pubk.getParams();
            // According to RFC 3279 section 2.3.2, DSA keys are allowed
            // to inherit parameters in an X.509 certificate issuer's
            // key parameters, so the parameters may be null. The parent
            // key will be rejected if its parameters don't pass, so this
            // is okay.
            if (params != null) {
                size = params.getP().bitLength();
            }
        } else if (key instanceof DHKey) {
            DHKey pubk = (DHKey)key;
            size = pubk.getParams().getP().bitLength();
        }   // Otherwise, it may be a unextractable key of PKCS#11, or
            // a key we are not able to handle.

        return size;
    }
1127177
public final void setToSize(int size) {
    
    Object newMap[] = new Object[size];
    
    System.arraycopy(m_map, 0, newMap, 0, m_firstFree);
    m_mapSize = size;

    m_map = newMap;
    
  }
460791
public int size(Key low, Key high) {
	if (low.compareTo(high) > 0)
	    return 0;
	if (contains(high))
	    return rank(high) - rank(low) + 1;
	else
	    return rank(high) - rank(low);
    }
1256918
public static KeySize getKeySize(final PrivateKey privateKey)
	{
		int length = getKeyLength(privateKey);
		if (length == 1024)
		{
			return KeySize.KEYSIZE_1024;
		}
		if (length == 2048)
		{
			return KeySize.KEYSIZE_2048;
		}
		if (length == 4096)
		{
			return KeySize.KEYSIZE_4096;
		}
		if (length == 8192)
		{
			return KeySize.KEYSIZE_8192;
		}
		return null;
	}
721401
private static function expandKey($key,$size)
	{
		$expandedKeySize = (16*(self::numberOfRounds($size)+1));

		/* current expanded keySize, in bytes */
		$currentSize = 0;
		$rconIteration = 1;
		$t = array();   // temporary 4-byte variable

		$expandedKey = array();
		for($i = 0;$i < $expandedKeySize;$i++)
			$expandedKey[$i] = 0;

		/* set the 16,24,32 bytes of the expanded key to the input key */
		for ($j = 0; $j < $size; $j++)
			$expandedKey[$j] = $key[$j];
		$currentSize += $size;

		while ($currentSize < $expandedKeySize)
		{
			/* assign the previous 4 bytes to the temporary value t */
			for ($k = 0; $k < 4; $k++)
				$t[$k] = $expandedKey[($currentSize - 4) + $k];

			/* every 16,24,32 bytes we apply the core schedule to t
			 * and increment rconIteration afterwards
			 */
			if($currentSize % $size == 0)
				$t = self::core($t, $rconIteration++);

			/* For 256-bit keys, we add an extra sbox to the calculation */
			if($size == self::keySize_256 && (($currentSize % $size) == 16))
				for($l = 0; $l < 4; $l++)
					$t[$l] = self::$sbox[$t[$l]];

			/* We XOR t with the four-byte block 16,24,32 bytes before the new expanded key.
			 * This becomes the next four bytes in the expanded key.
			 */
			for($m = 0; $m < 4; $m++) {
				$expandedKey[$currentSize] = $expandedKey[$currentSize - $size] ^ $t[$m];
				$currentSize++;
			}
		}
		return $expandedKey;
	}