Java ListX类代码示例

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
private List<RegisterEntry> findDir(File dir) {
    List<RegisterEntry> result = new ArrayList<>();

    Stream.of(dir.listFiles()).forEach(
        (next) -> {

            if (next.isDirectory()) {
                result.addAll(findDir(next));
            }
            if (next.isFile()) {
                try {
                    String fileString = FileUtils.readFileToString(next);
                    result.add(JacksonUtil.convertFromJson(fileString, RegisterEntry.class));
                } catch (Exception e) {
                    logger.error("Error loading service entry from disk {}", e,
                        next.getAbsolutePath());

                }
            }
        });
    return ListX.fromIterable(result);
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void addRemove(){
   ListX.of(1,2,3)
        .add(1);
   //[1,2,3,4]

   ListX.of(1,2,3)
           .plus(1);
   //[1,2,3,4]

   ListX.of(1,2,3)
           .remove(1);
   //[2,3]

   ListX.of(1,2,3)
           .removeValue((Object)1);
   //[2,3]
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void testSorted() {

    AnyM.fromList(ListX.of(tuple(2, 2), tuple(1, 1))).printOut();
    Traversable<Tuple2<Integer, Integer>> t1 = of(tuple(2, 2), tuple(1, 1));

    List<Tuple2<Integer, Integer>> s1 = t1.sorted().stream().toList();
    assertEquals(tuple(1, 1), s1.get(0));
    assertEquals(tuple(2, 2), s1.get(1));

    Traversable<Tuple2<Integer, String>> t2 = of(tuple(2, "two"), tuple(1, "one"));
    List<Tuple2<Integer, String>> s2 = t2.sorted(comparing(t -> t._1())).stream().toList();
    assertEquals(tuple(1, "one"), s2.get(0));
    assertEquals(tuple(2, "two"), s2.get(1));

    Traversable<Tuple2<Integer, String>> t3 = of(tuple(2, "two"), tuple(1, "one"));
    List<Tuple2<Integer, String>> s3 = t3.sorted(t -> t._1()).stream().toList();
    assertEquals(tuple(1, "one"), s3.get(0));
    assertEquals(tuple(2, "two"), s3.get(1));
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void triplicateFanOut() {

    for (int k = 0; k < ITERATIONS; k++) {
        System.out.println("******************Triplicate & product.. " + k);
        System.out.println("******************Triplicate & product.. " + k);
        System.out.println("******************Triplicate & product.. " + k);
        System.out.println("******************Triplicate & product.. " + k);
        ListX<Integer> res = of(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .fanOut(s1 -> s1.peek(System.out::println).filter(i -> i % 3 == 0).map(i -> i * 2),
                        s2 -> s2.filter(i -> i % 3 == 1).map(i -> i * 100),
                        s3 -> s3.filter(i -> i % 3 == 2).map(i -> i * 1000))
                .toListX();
        assertThat("List is "  + res,res, Matchers.hasItems(6, 100, 2000, 12, 400, 5000, 18, 700, 8000));
    }

}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void duplicateDuplicateDuplicate(){
    for(int k=0;k<ITERATIONS;k++) {
        assertThat(of(1, 2, 3).duplicate()
                ._1().duplicate()._1().duplicate()._1().duplicate()._1().toListX(), equalTo(ListX.of(1, 2, 3)));
    }

}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void splitLimit() {
    ReactiveSeq<Integer> stream = of(1);
    final Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> t = stream.duplicate();
    assertThat(stream.limit(1).toList(), equalTo(ListX.of(1)));
    assertThat(t._1().limit(1).toList(), equalTo(ListX.of(1)));
    assertThat(t._1().limit(1).toList(), equalTo(ListX.of(1)));
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void broadcastTest() {
    Topic<Integer> topic = of(1, 2, 3)
            .broadcast();


    ReactiveSeq<Integer> stream1 = topic.stream();
    ReactiveSeq<Integer> stream2 = topic.stream();
    assertThat(stream1.toListX(), Matchers.equalTo(ListX.of(1, 2, 3)));
    assertThat(stream2.stream().toListX(), Matchers.equalTo(ListX.of(1, 2, 3)));

}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Bean
public MultiDataWriter<?> defaultMultiDataWriter() {
    if (multiWriterOn)
        return new MultiDataWriter(
                                   ListX.fromIterable(defaultComparators)
                                        .map(mc -> new AsyncDataWriter(
                                                                       asyncDataWriterThreadPool(), mc, bus)));
    return new MultiDataWriter(
                               ListX.empty());
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Override
public void contextInitialized(ServletContextEvent arg0) {
	JerseyRestApplication.getResourcesMap().put(serverData.getModule().getContext(), ListX.fromIterable(serverData.getResources()));
	JerseyRestApplication.getPackages().put(serverData.getModule().getContext(), serverData.getModule().getDefaultJaxRsPackages());
	JerseyRestApplication.getResourcesClasses().put(serverData.getModule().getContext(), serverData.getModule().getDefaultResources());
	JerseyRestApplication.getResourceConfigManager().put(serverData.getModule().getContext(), serverData.getModule().getResourceConfigManager());
	JerseyRestApplication.getServerPropertyMap().put(serverData.getModule().getContext(), serverData.getModule().getServerProperties());
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@org.junit.Test
public void cycleTests(){
    System.out.println(ListX.of(1,2,3)
            .cycle(2));

    System.out.println(ListX.of(5,6,7)
            .cycleWhile(i->i*times++<100));
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
/**
 * This will construct a Spring context for this Microserver instance.
 * The calling class will be used to determine the base package to auto-scan from for Spring Beans
 * It will attempt to pick up an @Microservice annotation first, if not present the package of the calling class
 * will be used.
 * 
 * @param modules Multiple Microservice end points that can be deployed within a single Spring context
 */
public MicroserverApp(Module... modules) {
    this.modules = ListX.of(modules);
    GlobalState.state.setModules(this.modules);
    initSpringProperties(modules[0]);
    Class c = extractClass();
    springContext = new SpringContextFactory(
                                             new MicroserverConfigurer().buildConfig(c), extractClass(),
                                             modules[0].getSpringConfigurationClasses()).createSpringContext();

}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void cycleIterateIterable(){
	Iterator<Integer> it = ReactiveSeq.fromIterable(Arrays.asList(1)).stream().cycle(2).iterator();
	List<Integer> list2 = new ArrayList<>();
	while(it.hasNext())
		list2.add(it.next());
	assertThat(list2,equalTo(ListX.of(1,1)));
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Override
public List<String> getDefaultJaxRsPackages() {
    if (defaultJaxRsPackages != null)
        return ListX.fromIterable(concat(defaultJaxRsPackages, extract(() -> Module.super.getDefaultJaxRsPackages())));

    return ListX.fromIterable(Module.super.getDefaultJaxRsPackages());
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void batchBySizeAndTimeTime(){

	for(int i=0;i<10;i++){
		System.out.println(i);
		List<ListX<Integer>> list = of(1,2,3,4,5,6)
				.groupedBySizeAndTime(10,1,TimeUnit.MICROSECONDS)
				.toList();

		assertThat(list
						.get(0)
						,not(hasItem(6)));
	}
}
 

import cyclops.collections.mutable.ListX; //导入依赖的package包/类
@Test
public void splitLimit2(){
    ReactiveSeq<Integer> stream = of(1);
    final Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> t = stream.duplicate();
    assertThat(stream.limit(1).toList(),equalTo(ListX.of(1)));

    assertThat(t._1().limit(1).toList(),equalTo(ListX.of(1)));
}