Exemplo n.º 1
1
  public static void main(String[] args) throws FileNotFoundException {
    ArrayList<String> names = new ArrayList<>();
    File f = new File("people.csv");
    Scanner scanner = new Scanner(f);
    scanner.nextLine();
    while (scanner.hasNext()) {
      String line = scanner.nextLine();
      String[] columns = line.split(",");
      String name = columns[1] + " " + columns[2];
      names.add(name);
    }
    String searchTerm = "ali";
    ArrayList<String> results = new ArrayList<>();
    for (String name : names) {
      if (name.toLowerCase().contains(searchTerm)) {
        results.add(name);
      }
    }
    System.out.println(results);

    // To use stream:
    results =
        names
            .stream()
            .filter(
                (name) -> {
                  return name.toLowerCase().contains(searchTerm);
                })
            .collect(Collectors.toCollection(ArrayList<String>::new));
    System.out.println(results);
  }
  public static void main(String[] args)
      throws InterruptedException, AlreadyConnectedException, JIException, IOException,
          NotConnectedException, DuplicateGroupException, AddFailedException {

    final FileWriter fileWriter = new FileWriter("data.csv");
    fileWriter.write("sep=,\n");
    fileWriter.flush();
    CSVWriter writer = new CSVWriter(fileWriter, ',', '\0');
    writer.writeNext(
        Tag.TAG_TO_ID_MAPPING
            .entrySet()
            .stream()
            .map(tagStringEntry -> tagStringEntry.getKey().toString())
            .collect(Collectors.toCollection(LinkedList::new))
            .toArray(new String[0]));

    final OPCDataReader opcDataReader = new OPCDataReader(Tag.TAG_TO_ID_MAPPING).startReading();

    Thread.sleep(2000);

    while (true) {
      final Map<Tag, Double> actualValues = opcDataReader.getActualValues();
      System.out.println(actualValues);
      final String[] data =
          Tag.TAG_TO_ID_MAPPING
              .entrySet()
              .stream()
              .map(tagStringEntry -> "" + actualValues.get(tagStringEntry.getKey()))
              .collect(Collectors.toCollection(LinkedList::new))
              .toArray(new String[0]);
      writer.writeNext(data);
      writer.flush();
      Thread.sleep(1000);
    }
  }
Exemplo n.º 3
0
  static <T> T unwrapOtherMonadTypes(Comprehender<T> comp, Object apply) {

    if (comp.instanceOfT(apply)) return (T) apply;

    if (apply instanceof Optional) {
      if (((Optional) apply).isPresent()) return comp.of(((Optional) apply).get());
      return comp.empty();
    }

    if (apply instanceof Stream) {
      return comp.of(((Stream) apply).collect(Collectors.toCollection(MaterializedList::new)));
    }

    if (apply instanceof IntStream) {
      return comp.of(
          ((IntStream) apply).boxed().collect(Collectors.toCollection(MaterializedList::new)));
    }
    if (apply instanceof DoubleStream) {
      return comp.of(
          ((DoubleStream) apply).boxed().collect(Collectors.toCollection(MaterializedList::new)));
    }
    if (apply instanceof LongStream) {
      return comp.of(
          ((LongStream) apply).boxed().collect(Collectors.toCollection(MaterializedList::new)));
    }
    if (apply instanceof CompletableFuture) {
      return comp.of(((CompletableFuture) apply).join());
    }
    if (apply instanceof StreamT) return comp.of(((StreamT) apply).unwrap());

    return (T)
        new ComprehenderSelector()
            .selectComprehender(apply)
            .resolveForCrossTypeFlatMap(comp, apply);
  }
  @Override
  public void loadData(String fileName, String sheetName) throws RestLoaderException, IOException {

    // Initialize
    init();

    // Read
    log.info("Reading data from the file..");
    List<FileData<PatientVisitDTO>> patientVisits = excelFileReader.readData(fileName, sheetName);
    log.info("Data read complete..");

    // Transform
    log.info("Transforming the data read..");
    patientVisits = patientVisitDataTransformer.populateModelList(patientVisits);
    log.info("Data transformation complete..");

    // Load
    log.info("Loading the data into PIM..");
    List<FileData<PatientVisitDTO>> post =
        patientVisits
            .stream()
            .filter(
                data ->
                    DataLoaderConstants.POST_OPERATION.equalsIgnoreCase(data.getOperationType()))
            .collect(Collectors.toCollection(ArrayList::new));

    List<FileData<PatientVisitDTO>> put =
        patientVisits
            .stream()
            .filter(
                data -> DataLoaderConstants.PUT_OPERATION.equalsIgnoreCase(data.getOperationType()))
            .collect(Collectors.toCollection(ArrayList::new));

    Map<String, List<FileData<PatientVisitDTO>>> groupedPostData = convertToMap(post);
    post = doPost(groupedPostData);

    List<FileData<PatientVisitDTO>> putList = new ArrayList<>();
    put.forEach(
        dataSheet -> {
          try {
            addPathParam(
                env.getProperty(DataLoaderConstants.PATIENT_ID_KEY),
                dataSheet.getEntity().getPatientNumber());
            addPathParam(
                env.getProperty(DataLoaderConstants.PATIENT_VISIT_ID_KEY),
                dataSheet.getEntity().getId());
            putList.add(doPut(dataSheet));
          } catch (RestLoaderException e) {
          }
        });

    patientVisits = Stream.concat(post.stream(), putList.stream()).collect(Collectors.toList());
    log.info("Data loading complete..");

    // Write
    log.info("Writing the results back to the file..");
    excelFileWriter.writeResult(fileName, patientVisits, sheetName);
    log.info("Writing results complete..");
  }
  @Override
  protected GetFieldMappingsResponse shardOperation(
      final GetFieldMappingsIndexRequest request, ShardId shardId) {
    assert shardId != null;
    IndexService indexService = indicesService.indexServiceSafe(shardId.getIndex());
    Collection<String> typeIntersection;
    if (request.types().length == 0) {
      typeIntersection = indexService.mapperService().types();

    } else {
      typeIntersection =
          indexService
              .mapperService()
              .types()
              .stream()
              .filter(type -> Regex.simpleMatch(request.types(), type))
              .collect(Collectors.toCollection(ArrayList::new));
      if (typeIntersection.isEmpty()) {
        throw new TypeMissingException(shardId.getIndex(), request.types());
      }
    }

    MapBuilder<String, Map<String, FieldMappingMetaData>> typeMappings = new MapBuilder<>();
    for (String type : typeIntersection) {
      DocumentMapper documentMapper = indexService.mapperService().documentMapper(type);
      Map<String, FieldMappingMetaData> fieldMapping =
          findFieldMappingsByType(documentMapper, request);
      if (!fieldMapping.isEmpty()) {
        typeMappings.put(type, fieldMapping);
      }
    }

    return new GetFieldMappingsResponse(
        singletonMap(shardId.getIndexName(), typeMappings.immutableMap()));
  }
  static ApplyChangesOptions fromInputAndConfigFiles(
      ApplyChangesInput input,
      FileSystem fileSystem,
      DataFormats dataFormats,
      Path defaultConfigPath) {
    ApplyChangesOptions options = fromInput(input, fileSystem, dataFormats);

    List<Path> configPaths =
        input
            .getConfigPaths()
            .stream()
            .map(fileSystem::getPath)
            .collect(Collectors.toCollection(ArrayList::new));

    configPaths.add(defaultConfigPath);

    for (Path configPath : configPaths) {
      if (Files.exists(configPath)) {
        // TODO: eventually maybe don't assume YAML
        options = options.fallingBackTo(ApplyChangesOptions.fromYaml(configPath));
      }
    }

    return options;
  }
Exemplo n.º 7
0
  public void testFind() throws IOException {
    PathBiPredicate pred = new PathBiPredicate((path, attrs) -> true);

    try (Stream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, pred)) {
      Set<Path> result = s.collect(Collectors.toCollection(TreeSet::new));
      assertEquals(pred.visited(), all);
      assertEquals(result.toArray(new Path[0]), pred.visited());
    }

    pred = new PathBiPredicate((path, attrs) -> attrs.isSymbolicLink());
    try (Stream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, pred)) {
      s.forEach(path -> assertTrue(Files.isSymbolicLink(path)));
      assertEquals(pred.visited(), all);
    }

    pred = new PathBiPredicate((path, attrs) -> path.getFileName().toString().startsWith("e"));
    try (Stream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, pred)) {
      s.forEach(path -> assertEquals(path.getFileName().toString(), "empty"));
      assertEquals(pred.visited(), all);
    }

    pred =
        new PathBiPredicate(
            (path, attrs) ->
                path.getFileName().toString().startsWith("l") && attrs.isRegularFile());
    try (Stream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, pred)) {
      s.forEach(path -> fail("Expect empty stream"));
      assertEquals(pred.visited(), all);
    }
  }
  public static void main(String[] args) {
    List<Participante> participantes = ParticipantesTdc.listaTodos();

    // Operações Simples
    participantes.stream().count();
    boolean participantInscrito = participantes.stream().anyMatch(Participante::isInscrito);
    Optional<String> optionalEmail2 = participantes.stream().map(Participante::getEmail).findAny();

    // Collectors
    List<String> emailsList =
        participantes.stream().map(Participante::getEmail).collect(Collectors.toList());
    List<String> emailsLinkedList =
        participantes
            .stream()
            .map(Participante::getEmail)
            .collect(Collectors.toCollection(LinkedList::new));
    Set<String> emailsSet =
        participantes.stream().map(Participante::getEmail).collect(Collectors.toSet());

    Map<TamanhoCamisa, List<Participante>> participantesPorTamanho =
        participantes.stream().collect(Collectors.groupingBy(Participante::getTamanhoCamisa));

    Map<TamanhoCamisa, List<String>> emailsPorTamanho =
        participantes
            .stream()
            .collect(
                Collectors.groupingBy(
                    Participante::getTamanhoCamisa,
                    Collectors.mapping(Participante::getEmail, Collectors.toList())));
  }
Exemplo n.º 9
0
 private ArrayList<FakeNode> getNeighbours(long id) {
   ArrayList<FakeNode> retNodes = new ArrayList<>();
   ArrayList<Segment> neighbours =
       this.segments
           .stream()
           .filter(
               (Segment s) -> {
                 return s.mOrigin == id;
               })
           .collect(Collectors.toCollection(ArrayList<Segment>::new));
   neighbours.addAll(
       this.fakeSegments
           .stream()
           .filter(
               (Segment s) -> {
                 return s.mOrigin == id;
               })
           .collect(Collectors.toCollection(ArrayList<Segment>::new)));
   FakeNode node;
   for (Segment s : neighbours) {
     if (fakeNodes.containsKey(s.mDestination)) {
       node = fakeNodes.get(s.mDestination);
     } else {
       node = new FakeNode(nodes.get(s.mDestination));
       fakeNodes.put(s.mDestination, node);
     }
     ArrayList<CostFunction> functions =
         costs
             .stream()
             .filter(
                 (CostFunction c) -> {
                   return c.getSegmentId() == s.mId;
                 })
             .collect(Collectors.toCollection(ArrayList<CostFunction>::new));
     functions.addAll(
         fakeCosts
             .stream()
             .filter(
                 (CostFunction c) -> {
                   return c.getSegmentId() == s.mId;
                 })
             .collect(Collectors.toCollection(ArrayList<CostFunction>::new)));
     node.node.cost = functions.get(0);
     retNodes.add(fakeNodes.get(s.mDestination));
   }
   return retNodes;
 }
 @Override
 public ArrayList<ChatRoomDTO> findByUserId(Token token, UserId userId) {
   return chatRoomRepository
       .findChatRoomsByUserId(userId.id)
       .stream()
       .map(chatRoom -> new ChatRoomDTO(chatRoom.getId(), chatRoom.getName(), 0, 0))
       .collect(Collectors.toCollection(ArrayList<ChatRoomDTO>::new));
 }
Exemplo n.º 11
0
 public Set<Module> getModulesByPid(String pid) {
   Set<Module> modules =
       getModules()
           .stream()
           .filter(module -> pid.equals(module.getParentId()))
           .collect(Collectors.toCollection(() -> new LinkedHashSet<>()));
   return modules;
 }
Exemplo n.º 12
0
 private List<Point> generatePoints(Point point) {
   int x = point.getX();
   int y = point.getY();
   return Arrays.asList(
           new Point(x - 1, y), new Point(x + 1, y), new Point(x, y - 1), new Point(x, y + 1))
       .stream()
       .filter(p -> isInRange(p))
       .collect(Collectors.toCollection(ArrayList::new));
 }
Exemplo n.º 13
0
 @Nonnull
 protected Set<MinecraftPlayer> commandSourceCollectionToMinecraftPlayer(
     @Nonnull Collection<? extends CommandSource> collection) {
   return collection
       .stream()
       .filter(source -> source instanceof Player)
       .map(player -> new MinecraftPlayer(player.getName(), ((Player) player).getUniqueId()))
       .collect(Collectors.toCollection(HashSet::new));
 }
Exemplo n.º 14
0
  public LineListTool(final List<T> raw, final Function<T, List<String>> extractor) {
    Set<String> set =
        raw.stream()
            .flatMap(w -> extractor.apply(w).stream())
            .collect(Collectors.toCollection(LinkedHashSet::new));

    lines = new ArrayList<>(set);
    indices =
        IntStream.range(0, lines.size()).boxed().collect(Collectors.toMap(lines::get, identity()));
  }
Exemplo n.º 15
0
 public Set<Module> getModulesByPid(String pid, String level) {
   Set<Module> modules =
       getModules()
           .stream()
           .filter(
               module ->
                   module.getParentId().equals(pid)
                       && hasAccessModuleAction(module.getId(), level))
           .collect(Collectors.toCollection(() -> new LinkedHashSet<>()));
   return modules;
 }
Exemplo n.º 16
0
 public MapArray<K, V> where(BiFunction<K, V, Boolean> func) {
   try {
     return pairs
         .stream()
         .filter(pair -> func.apply(pair.key, pair.value))
         .collect(Collectors.toCollection(MapArray::new));
   } catch (Exception ignore) {
     throwRuntimeException(ignore);
     return null;
   }
 }
Exemplo n.º 17
0
 public RestrictConstraint(
     final List<String[]> roleGroups,
     final Optional<String> content,
     final ConstraintLogic constraintLogic) {
   this.content = content;
   roleGroups
       .stream()
       .filter(group -> group != null)
       .collect(Collectors.toCollection(() -> this.roleGroups));
   this.constraintLogic = constraintLogic;
 }
Exemplo n.º 18
0
 public Graph(String line) {
   map =
       Arrays.stream(
               (line.trim() + " " + new StringBuilder(line.trim()).reverse().toString())
                   .split(" "))
           .collect(
               Collectors.groupingBy(
                   x -> ((String) x).charAt(0),
                   Collectors.mapping(
                       x -> ((String) x).charAt(1),
                       Collectors.toCollection(LinkedHashSet<Character>::new))));
 }
Exemplo n.º 19
0
  protected Set<AssociationValue> loadAssociationValues(
      EntityManager entityManager, Class<?> sagaType, String sagaIdentifier) {
    List<AssociationValueEntry> associationValueEntries =
        entityManager
            .createNamedQuery(FIND_ASSOCIATIONS_NAMED_QUERY, AssociationValueEntry.class)
            .setParameter("sagaType", getSagaTypeName(sagaType))
            .setParameter("sagaId", sagaIdentifier)
            .getResultList();

    return associationValueEntries
        .stream()
        .map(AssociationValueEntry::getAssociationValue)
        .collect(Collectors.toCollection(HashSet::new));
  }
Exemplo n.º 20
0
  @Test
  public void alleVerschiedenenVornamenDerMaiersSortiertAlsLinkedList() {
    LinkedList<String> alleVornamenDerMaiers =
        newPersonenStream() //
            .filter(where(Person::getNachname).is("Maier")) //
            .map(Person::getVorname) //
            .distinct() //
            .sorted() //
            .collect(Collectors.toCollection(LinkedList::new));

    assertThat(alleVornamenDerMaiers, hasSize(559));
    assertThat(alleVornamenDerMaiers.get(0), is("Agnes"));
    assertThat(alleVornamenDerMaiers.get(558), is("Yvonne"));
  }
 public List<Prediction> createPredictions(SecurityContext sec, List<Prediction> preds) {
   int originalSize = preds.size();
   List<Prediction> filtered =
       preds
           .stream()
           .filter(p -> p.getText() != null && !p.getText().isEmpty())
           .filter(p -> p.getText().length() > MIN_PREDICTION_LENGTH)
           .collect(Collectors.toCollection(ArrayList::new));
   int newSize = filtered.size();
   if (newSize != originalSize)
     LOGGER.info("Filtered predictions with large/small bodies: {}", originalSize - newSize);
   filtered.stream().forEach(p -> createPrediction(sec, p));
   return preds;
 }
Exemplo n.º 22
0
  public List<ChainOfStone> getChainsOfStones() {
    List<Stone> stones = getStonesByPoint(point);
    List<ChainOfStone> chainOfStones = new ArrayList<>();
    ChainOfStone tmpChainOfStone;
    for (Stone s : stones) {
      tmpChainOfStone = s.getChainOfStone();
      if (tmpChainOfStone != null) {
        chainOfStones.add(tmpChainOfStone);
      }
    }

    GameLogger.getInstance().logg("dlugosc listy ");

    return chainOfStones.stream().distinct().collect(Collectors.toCollection(ArrayList::new));
  }
  @Override
  public void dequeue(Long branchId, Long userId) {
    List<QueueTransaction> queue = queues.getOrDefault(branchId, new LinkedList<>());
    if (queue.stream().noneMatch(t -> t.getUserId() == userId)) {
      throw new NoSuchUserInQueueException();
    }

    queues.computeIfPresent(
        branchId,
        (k, v) ->
            queue
                .stream()
                .filter(t -> t.getUserId() != userId)
                .collect(Collectors.toCollection(LinkedList::new)));
  }
Exemplo n.º 24
0
  @Override
  public void writeObjectArray(
      final String label, final Collection<? extends SerializableEntity> objects) {
    this.pushLabel(label);
    if (null == objects) {
      return;
    }

    final JSONArray jsonObjects =
        objects
            .stream()
            .map(this::serializeObject)
            .collect(Collectors.toCollection(JSONArray::new));

    this.object.put(label, jsonObjects);
  }
Exemplo n.º 25
0
 /** GET /ordenCompras -> get all the ordenCompras. */
 @RequestMapping(
     value = "/ordenCompras",
     method = RequestMethod.GET,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 @Transactional(readOnly = true)
 public ResponseEntity<List<OrdenCompraDTO>> getAllOrdenCompras(Pageable pageable)
     throws URISyntaxException {
   Page<OrdenCompra> page = ordenCompraRepository.findAll(pageable);
   HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, "/api/ordenCompras");
   return new ResponseEntity<>(
       page.getContent()
           .stream()
           .map(ordenCompraMapper::ordenCompraToOrdenCompraDTO)
           .collect(Collectors.toCollection(LinkedList::new)),
       headers,
       HttpStatus.OK);
 }
Exemplo n.º 26
0
 /** GET /fases -> get all the fases. */
 @RequestMapping(
     value = "/fases",
     method = RequestMethod.GET,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 @Transactional(readOnly = true)
 public ResponseEntity<List<FaseDTO>> getAll(
     @RequestParam(value = "page", required = false) Integer offset,
     @RequestParam(value = "per_page", required = false) Integer limit)
     throws URISyntaxException {
   Page<Fase> page = faseRepository.findAll(PaginationUtil.generatePageRequest(offset, limit));
   HttpHeaders headers =
       PaginationUtil.generatePaginationHttpHeaders(page, "/api/fases", offset, limit);
   return new ResponseEntity<>(
       page.getContent()
           .stream()
           .map(faseMapper::faseToFaseDTO)
           .collect(Collectors.toCollection(LinkedList::new)),
       headers,
       HttpStatus.OK);
 }
  private List<Long> loadPossibleTargetsIds() {
    WebElement table = webDriver.findElement(By.id(TABLE_ID));
    List<WebElement> authors = table.findElements(By.className(AUTHOR_CELL_CLASS_NAME));

    List<String> targetsUrls =
        authors
            .stream()
            .skip(1) // skip first player who is game admin or something
            .limit(MAX_AMOUNT_OF_TARGETS_IN_A_ROW)
            .map(e -> e.findElements(By.tagName("a")))
            .filter(list -> list.size() == 1) // no <a> or more than one found? skip it.
            .map(list -> list.get(0))
            .map(e -> e.getAttribute("href"))
            .collect(Collectors.toList());

    return targetsUrls
        .stream()
        .map(this::extractTargetIdFromUrl)
        .filter(id -> id != 0)
        .collect(Collectors.toCollection(LinkedList::new));
  }
Exemplo n.º 28
0
  @Test
  public void testCollectors() {

    ArrayList<Person> people = new ArrayList<>();
    ArrayList<Integer> things = new ArrayList<>();
    ArrayList<Employee> employees = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();

    // Accumulate names into a List
    List<String> list = people.stream().map(Person::getName).collect(Collectors.toList());

    // Accumulate names into a TreeSet
    Set<String> list2 =
        people.stream().map(Person::getName).collect(Collectors.toCollection(TreeSet::new));

    // Convert elements to strings and concatenate them, separated by commas
    String joined = things.stream().map(Object::toString).collect(Collectors.joining(", "));

    // Find highest-paid employee
    Optional<Employee> highestPaid =
        employees.stream().collect(Collectors.maxBy(Comparator.comparingInt(Employee::getSalary)));

    // Group employees by department
    Map<Department, List<Employee>> byDept =
        employees.stream().collect(Collectors.groupingBy(Employee::getDepartment));

    // Find highest-paid employee by department
    Map<Department, Optional<Employee>> highestPaidByDept =
        employees
            .stream()
            .collect(
                Collectors.groupingBy(
                    Employee::getDepartment,
                    Collectors.maxBy(Comparator.comparingInt(Employee::getSalary))));

    // Partition students into passing and failing
    Map<Boolean, List<Student>> passingFailing =
        students.stream().collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));
  }
Exemplo n.º 29
0
    /**
     * Flattens out the provided metrics, collates them by "sample", and merges those collations.
     */
    private static Collection<MendelianViolationMetrics> mergeMetrics(
        final Collection<Collection<MendelianViolationMetrics>> resultsToReduce) {
      final Collection<MendelianViolationMetrics> allMetrics = new ArrayList<>();
      resultsToReduce.forEach(allMetrics::addAll);

      final Map<String, List<MendelianViolationMetrics>> sampleToMetricsMap =
          allMetrics
              .stream()
              .collect(
                  Collectors.groupingBy(
                      m ->
                          String.format(
                              "%s|%s|%s|%s", m.FAMILY_ID, m.FATHER, m.MOTHER, m.OFFSPRING)));

      return sampleToMetricsMap
          .values()
          .stream()
          .map(a -> (MendelianViolationMetrics) new MendelianViolationMetrics().merge(a))
          .collect(
              Collectors.<MendelianViolationMetrics, List<MendelianViolationMetrics>>toCollection(
                  ArrayList<MendelianViolationMetrics>::new));
    }
Exemplo n.º 30
0
 /** GET /account -> get the current user. */
 @RequestMapping(
     value = "/account",
     method = RequestMethod.GET,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 public ResponseEntity<UserDTO> getAccount() {
   return Optional.ofNullable(userService.getUserWithAuthorities())
       .map(
           user ->
               new ResponseEntity<>(
                   new UserDTO(
                       user.getLogin(),
                       null,
                       user.getFirstName(),
                       user.getLastName(),
                       user.getEmail(),
                       user.getLangKey(),
                       user.getAuthorities()
                           .stream()
                           .map(Authority::getName)
                           .collect(Collectors.toCollection(LinkedList::new))),
                   HttpStatus.OK))
       .orElse(new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
 }