code: public int approximateCount(T item) {
  		BucketAndTag pos = hasher.generate(item);
  		long i1 = pos.index;
  		long i2 = hasher.altIndex(pos.index, pos.tag);
  		int tagCount = 0;
  		bucketLocker.lockBucketsRead(i1, i2);
  		try {
  			tagCount = table.countTag(i1, i2, pos.tag);
  		} finally {
  			bucketLocker.unlockBucketsRead(i1, i2);
  		}
  		if (checkIsVictim(pos))
  			tagCount++;
  		return tagCount;
  	}
docs: This method returns the approximate number of times an item was added to
  the filter. This count is probabilistic like the rest of the filter, so
  it may occasionally over-count. Since the filter has no false negatives,
  <i>the approximate count will always be equal or greater than the actual
  count(unless you've been deleting non-existent items)</i>. That is, this
  method may return a higher count than the true value, but never lower.
  The false inflation chance of the count depends on the filter's false
  positive rate, but is generally low for sane configurations.
  <p>
  NOTE: Inserting the same key more than 7 times will cause a bucket
  overflow, greatly decreasing the performance of the filter and making
  early insertion failure (less than design load factor) very likely. For
  this reason the filter should only be used to count small values.
  
  <p>
  Also note that getting the count is generally about half as fast as
  checking if a filter contains an item.
  
  @param item
  item to check
  @return Returns a positive integer representing the number of times an
  item was probably added to the filter. Returns zero if the item
  is not in the filter, behaving exactly like
  {@code #mightContain(Object)} in this case.