Java Sequence.map方法代码示例

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
/**
 * Zipping
 * -------
 * 
 * Two sequences can be zipped into a single collection of pairs:
 */
@Test
public void zipExample() {
    Sequence<String> firstNames = sequence("Marge", "Maude");
    Sequence<String> lastNames = sequence("Simpson", "Flanders");

    Sequence<Pair<String, String>> namePairs = firstNames.zip(lastNames);
    assertEquals("Marge", namePairs.get(0).first());
    assertEquals("Simpson", namePairs.get(0).second());

    assertEquals("Maude", namePairs.get(1).first());
    assertEquals("Flanders", namePairs.get(1).second());

    // A more intersting way to use this feature:

    Sequence<String> fullNames = namePairs.map(pair -> pair.first() + " " + pair.second());
    assertEquals("Marge Simpson", fullNames.first());
    assertEquals("Maude Flanders", fullNames.second());
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
/**
 * Mapping
 * -------
 * 
 * The `map` method applies a function to every element of the
 * sequence and returns a sequence of these results:
 */
@Test
public void showMap() {
    Sequence<Integer> originalSequence = sequence(1, 2, 3);
    Sequence<Integer> squares = originalSequence.map(x -> x * x);

    assertEquals(sequence(1, 4, 9), squares);
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
/**
 * The `map` method can apply a function that has a different return
 * type than the original element type:
 */
@Test
public void showMapWithDifferentType() {
    Sequence<Integer> originalSequence = sequence(1, 2, 3);
    Sequence<String> stringSequence = originalSequence.map(x -> String.format("%d", x));

    assertEquals(sequence("1", "2", "3"), stringSequence);
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void works() throws Exception {
    String xml = "<stream>Hello &amp; World</stream>";
    Sequence<Context> contexts = contexts(xml).filter(xpath(child(name("stream"))));
    Sequence<Node> stream = contexts.map(DomConverter::convert);
    assertThat(stream.size(), is(1));
    assertThat(Xml.asString(stream.head()), is("<stream>Hello &amp; World</stream>"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
public static Sequence<String> contentsSequence(Sequence<Node> nodes) {
    return nodes.map(contents());
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
public static Sequence<String> textContents(Sequence<Node> nodes) {
    return nodes.map(textContent());
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
private FileSource(final Sequence<Pair<String, File>> sources) {
    closeables = closeableList(InputStream.class);
    this.sources = sources.map(pair ->
            Source.source(pair.first(), () -> new Date(pair.second().lastModified()), () -> inputStream(pair.second()), pair.second().isDirectory()));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canMapWithAField() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new FieldOn<User, String>() { { get(instance.firstName); } });
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canMapAMethod() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(method(on(User.class).firstName()));
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canMapAMethodWithAnArgument() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(method(on(User.class).say("Hello")));
    assertThat(firstNames, hasExactly("Dan says 'Hello'", "Matt says 'Hello'"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canUseInstanceInsteadOfCallForReadability() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{instance.firstName();}});
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canMapAMethod() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{call.firstName();}});
    assertThat(firstNames, hasExactly("Dan", "Matt"));
}
 

import com.googlecode.totallylazy.Sequence; //导入方法依赖的package包/类
@Test
public void canMapAMethodWithAnArgument() throws Exception {
    Sequence<User> users = sequence(user("Dan", "Bodart"), user("Matt", "Savage"));
    Sequence<String> firstNames = users.map(new CallOn<User, String>(){{call.say("Hello");}});
    assertThat(firstNames, hasExactly("Dan says 'Hello'", "Matt says 'Hello'"));
}