Java Code Examples for java.util.PrimitiveIterator.OfInt#hasNext()

@Test
public void reference() {
	final int size = 5000;
	final double p = 0.5;

	final Random random1 = new Random(0);
	final Random random2 = new Random(0);

	for (int j = 0; j < 1; ++j) {
		final OfInt it = indexes(random1, size, p).iterator();
		final IndexStream stream2 = ReferenceRandomStream(
			size, p, random2
		);

		while (it.hasNext()) {
			Assert.assertEquals(it.nextInt(), stream2.next());
		}

		Assert.assertFalse(it.hasNext());
		Assert.assertEquals(stream2.next(), -1);
	}
}
 

/**
 * underline -> camel e.g. __a_bc_d__e_ -> _ABcD_E_
 * 
 * @param str
 * @return
 */
public static String underline2upper(String str) {
    StringBuilder sb = new StringBuilder();
    boolean mode = false;
    IntStream intStream = str.chars();
    OfInt iterator = intStream.iterator();
    while (iterator.hasNext()) {
        int c = iterator.nextInt();
        char cc = (char) c;
        if (mode) {
            if (cc >= 'a' && cc <= 'z') {
                sb.append(((char) (cc - 32)));
                mode = false;
                continue;
            }
            if (cc == '_') {
                sb.append('_');
                continue;
            }
            sb.append((char) cc);
            mode = false;
        } else {
            if (cc == '_') {
                mode = true;
            } else {
                sb.append((char) cc);
            }
        }
    }
    if (mode) {
        sb.append('_');
    }
    return sb.toString();
}
 

private Iterable<int[]> getRecords(IntCollection leftMatches) {
	int size = leftMatches.size();
	Collection<int[]> left = new ArrayList<>(size);
	OfInt it = leftMatches.iterator();
	while (it.hasNext()) {
		int leftId = it.nextInt();
		int[] record = leftRecords.get(leftId);
		left.add(record);
	}
	return left;
}
 

private Int2ObjectMultimap<int[]> groupByValue(IntIterable matching) {
	Int2ObjectMultimap<int[]> map = new Int2ObjectHashMultimap<>();
	OfInt it = matching.iterator();
	while (it.hasNext()) {
		int id = it.nextInt();
		int[] right = getRightRecord(id);
		int rightValue = getRightValue(right);
		map.put(rightValue, right);
	}
	return map;
}
 

@Override
public double calculateMinSimilarity(IntIterable matching) {
	OfInt it = matching.iterator();
	//does order have an impact on runtime?
	while (it.hasNext() && shouldUpdate(minSimilarity)) {
		int id = it.nextInt();
		updateMinSimilarity(id);
	}
	return minSimilarity;
}
 

Iterable<int[]> getRecords(IntCollection ids) {
	int size = ids.size();
	Collection<int[]> result = new ArrayList<>(size);
	OfInt it = ids.iterator();
	while (it.hasNext()) {
		int id = it.nextInt();
		int[] record = records.get(id);
		result.add(record);
	}
	return result;
}
 

public static boolean equals(OfInt a, OfInt b) {
  while (a.hasNext()) {
    if (a.nextInt() != b.nextInt()) {
      return false;
    }
  }
  return true;
}
 

/**
 * @param it an iterator
 * @param f a predicate
 * @return an iterator which only yields values that satisfy the predicate
 */
public static OfInt filter(OfInt it, IntPredicate f) {
  return new OfInt() {

    private int next = 0;
    private boolean primed = false;
    private boolean done = false;

    private void prime() {
      if (!primed && !done) {
        while (it.hasNext()) {
          next = it.nextInt();
          if (f.test(next)) {
            primed = true;
            return;
          }
        }
        done = true;
      }
    }

    @Override
    public boolean hasNext() {
      prime();
      return !done;
    }

    @Override
    public int nextInt() {
      prime();
      if (!primed) {
        throw new NoSuchElementException();
      }

      primed = false;
      return next;
    }
  };
}
 

/**
 * @param it an iterator
 * @param f a function which transforms values
 * @return an iterator which yields the transformed values
 */
public static OfInt map(OfInt it, IntUnaryOperator f) {
  return new OfInt() {
    @Override
    public boolean hasNext() {
      return it.hasNext();
    }

    @Override
    public int nextInt() {
      return f.applyAsInt(it.nextInt());
    }
  };
}
 

/**
 * Version of forEach that doesn't box
 * @param action -
 */
public void forEach(IntConsumer action) {
  OfInt ii = iterator();
  while (ii.hasNext()) {
    action.accept(ii.nextInt());
  }
}