0
votes

Filtrer des mots uniques sans changement de cas dans Java 8

Je veux filtrer la liste par des éléments uniques avec un filtrage insensible à la casse à l'aide de Java 8.

E.g: 1) Entrée: Au revoir au revoir au revoir World World World P>

Sortie: Au revoir Bye World P>

2) Entrée: Sam est allé à son entreprise P>

Sortie: Sam est allé à son entreprise p>

J'ai essayé par code suivant. J'ai utilisé des éléments distincts () pour des éléments et de la carte uniques (x-> x.tolowcase ()) de sorte que distinct () filtrera des éléments uniques en abaissant son boîtier. P>

    System.out.println("Enter the no of lines u will input:: ");
    Scanner sc = new Scanner(System.in);
    Integer noOfLines = sc.nextInt();
    sc.nextLine();
    List<String> listForInput;
    List<List<String>> allInputs = new ArrayList<>();
    for(int i =0; i<noOfLines; i++)
    {
        String receivedLine = sc.nextLine();

        String[] splittedInput = receivedLine.split(" ");

        List<String> list =  Stream.of(splittedInput)
                .map(x->x.toLowerCase())
                .distinct()
                .collect(Collectors.toList());

        list.forEach(x-> System.out.print(x+" "));

java distinct java-stream case-insensitive

0 commentaires

4 Réponses :

2
votes

Vous transformez tout en minuscules en utilisant .map (x-> x.tolowercase ()) .

Vous pouvez utiliser un arbreset pour maintenir unique et < Code> removedif pour supprimer de la liste xxx



                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Avez-vous testé votre code? Ce code jette un  non supportéOrsetexception , car  arrange.aslist  renvoie une liste sauvegardée par la matrice sous-jacente, sa taille ne peut donc pas être modifiée. (Utilisez  Nouvelle ArrayList <> (Arrays.Aslist (...))  Pour résoudre le problème.) En passant, la sortie est différente de la sortie attendue de l'OP, comme en ce que les mots sont triés. alphabétiquement.                                                

                                                
                                                                                            
                                                    @MCEnperor merci d'avoir souligné.  Liste  ne sera pas trié ici, ce sera le même ordre que OP souhaite.


                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vous pouvez essayer en dessous de la solution avec  java-8   xxx                                  


                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Fractionnement de la corde, y rejoignant, puis la divonorçant à nouveau? Cela me semble inutile. Si vous remplacez  m -> string.join ("", m.values ())  avec  m -> nouveau arraylist <> (m.values ()) , vous Peut supprimer le  flux.of ( et le  .split ("")). Recueillir (collectionneurs.tolist ()) .                                                

                                                
                                                                                            
                                                    Oui, @MC Emperor Vous êtes correct, nous pouvons modifier ce code selon nos exigences.                                                
                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Vous pouvez utiliser  LinkedHashSet  fort> comme ci-dessous, 
for(int i =0; i<noOfLines; i++)
        {
            String receivedLine = sc.nextLine();

            String[] splittedInput = receivedLine.toLowerCase().split(" ");

            Set<String> list =  new LinkedHashSet<>(Arrays.asList(splittedInput));

            list.forEach(x-> System.out.print(x+" "));
         }

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Voici une autre façon de le faire. Alors que l'Usecase est légèrement différente, cette solution proposée est la même chose que  Cette réponse par Stuart Marks . 
 Essence, vous souhaitez appliquer un filtre d'état   em>: vous souhaitez supprimer certains éléments en fonction des éléments déjà observés précédemment. C'est plus ou moins ce que  distinct ()  code> fait, cependant,  distinct ()  code> est limité à la méthode  égale  code>. La méthode suivante fournit un  prédicat  code> qui maintient l'état:  p>  xxx  pré> 
 Le souhaité peut alors être atteint en utilisant les éléments suivants:  P> 
Arrays.stream(receivedLine.split(" "))
    .filter(distinctByKey(String::toLowerCase))
    .collect(Collectors.toList());

                                

                                                                    
                                    
                                    
                                        0 commentaires