Quel est le meilleur moyen de filtrer une collection Java?
Je veux filtrer un Java.util.Collection basé sur un prédicat.
Java 8 ( 2014 ) résout ce problème en utilisant des flux et des lambdas dans une ligne de code:
_List<Person> beerDrinkers = persons.stream()
.filter(p -> p.getAge() > 16).collect(Collectors.toList());
_Voici un tutoriel .
Utilisez Collection#removeIf pour modifier la collection en place. (Remarque: dans ce cas, le prédicat supprimera les objets qui satisfont le prédicat):
_persons.removeIf(p -> p.getAge() <= 16);
_lambdaj permet de filtrer des collections sans écrire de boucles ni de classes internes:
_List<Person> beerDrinkers = select(persons, having(on(Person.class).getAge(),
greaterThan(16)));
_Pouvez-vous imaginer quelque chose de plus lisible?
Disclaimer: Je suis un contributeur sur lambdaj
En supposant que vous utilisiez Java 1.5 , et que vous ne puissiez pas ajouter Google Collections , je ferais quelque chose de très similaire à ce que les gars de Google ont fait. Ceci est une légère variation sur les commentaires de Jon.
Ajoutez d’abord cette interface à votre base de code.
public interface IPredicate<T> { boolean apply(T type); }
Ses implémenteurs peuvent répondre lorsqu'un prédicat donné est vrai d'un certain type. Par exemple. Si T était User et AuthorizedUserPredicate<User> implémente IPredicate<T>, alors AuthorizedUserPredicate#apply renvoie si la variable passée dans User est autorisée.
Ensuite, dans une classe d'utilité, vous pourriez dire
public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
Collection<T> result = new ArrayList<T>();
for (T element: target) {
if (predicate.apply(element)) {
result.add(element);
}
}
return result;
}
Donc, en supposant que vous avez l'utilisation de ce qui précède pourrait être
Predicate<User> isAuthorized = new Predicate<User>() {
public boolean apply(User user) {
// binds a boolean method in User to a reference
return user.isAuthorized();
}
};
// allUsers is a Collection<User>
Collection<User> authorizedUsers = filter(allUsers, isAuthorized);
Si les performances de la vérification linéaire sont un sujet de préoccupation, je souhaiterais peut-être avoir un objet de domaine contenant la collection cible. L'objet de domaine qui a la collection cible aurait une logique de filtrage pour les méthodes qui initialisent, ajoutent et définissent la collection cible.
MISE À JOUR:
Dans la classe utilitaire (disons Predicate), j'ai ajouté une méthode de sélection avec une option pour la valeur par défaut lorsque le prédicat ne renvoie pas la valeur attendue, ainsi qu'une propriété statique pour les paramètres à utiliser dans le nouvel IPredicate.
public class Predicate {
public static Object predicateParams;
public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
Collection<T> result = new ArrayList<T>();
for (T element : target) {
if (predicate.apply(element)) {
result.add(element);
}
}
return result;
}
public static <T> T select(Collection<T> target, IPredicate<T> predicate) {
T result = null;
for (T element : target) {
if (!predicate.apply(element))
continue;
result = element;
break;
}
return result;
}
public static <T> T select(Collection<T> target, IPredicate<T> predicate, T defaultValue) {
T result = defaultValue;
for (T element : target) {
if (!predicate.apply(element))
continue;
result = element;
break;
}
return result;
}
}
L'exemple suivant recherche les objets manquants entre les collections:
List<MyTypeA> missingObjects = (List<MyTypeA>) Predicate.filter(myCollectionOfA,
new IPredicate<MyTypeA>() {
public boolean apply(MyTypeA objectOfA) {
Predicate.predicateParams = objectOfA.getName();
return Predicate.select(myCollectionB, new IPredicate<MyTypeB>() {
public boolean apply(MyTypeB objectOfB) {
return objectOfB.getName().equals(Predicate.predicateParams.toString());
}
}) == null;
}
});
L'exemple suivant recherche une instance dans une collection et renvoie le premier élément de la collection comme valeur par défaut lorsque l'instance est introuvable:
MyType myObject = Predicate.select(collectionOfMyType, new IPredicate<MyType>() {
public boolean apply(MyType objectOfMyType) {
return objectOfMyType.isDefault();
}}, collectionOfMyType.get(0));
UPDATE (après la sortie de Java 8):
Cela fait plusieurs années que je (Alan) a posté cette réponse pour la première fois et je ne peux toujours pas croire que je collectionne SO points pour cette réponse. Quoi qu'il en soit, maintenant que Java 8 a introduit des fermetures dans le langage, ma réponse serait désormais bien différente et plus simple. Avec Java 8, il n’est pas nécessaire de créer une classe d’utilitaire statique distincte. Donc, si vous voulez trouver le 1er élément qui correspond à votre prédicat.
final UserService userService = ... // perhaps injected IoC
final Optional<UserModel> userOption = userCollection.stream().filter(u -> {
boolean isAuthorized = userService.isAuthorized(u);
return isAuthorized;
}).findFirst();
L'API JDK 8 pour les options a la capacité de get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) et orElseThrow(exceptionSupplier), ainsi que d'autres fonctions "monadiques" telles que map, flatMap et filter.
Si vous voulez simplement collecter tous les utilisateurs qui correspondent au prédicat, utilisez le Collectors pour terminer le flux dans la collection souhaitée.
final UserService userService = ... // perhaps injected IoC
final List<UserModel> userOption = userCollection.stream().filter(u -> {
boolean isAuthorized = userService.isAuthorized(u);
return isAuthorized;
}).collect(Collectors.toList());
Voir ici pour plus d'exemples sur le fonctionnement de Java 8 flux.
Utilisez CollectionUtils.filter (Collection, Predicate) , d’Apache Commons.
"Le meilleur" moyen est une demande trop large. Est-ce "le plus court"? "Le plus rapide"? "Lisible"? Filtre en place ou dans une autre collection?
La manière la plus simple (mais pas la plus lisible) consiste à la parcourir et à utiliser la méthode Iterator.remove ():
Iterator<Foo> it = col.iterator();
while( it.hasNext() ) {
Foo foo = it.next();
if( !condition(foo) ) it.remove();
}
Maintenant, pour le rendre plus lisible, vous pouvez l’envelopper dans une méthode utilitaire. Puis inventez une interface IPredicate, créez une implémentation anonyme de cette interface et faites quelque chose comme:
CollectionUtils.filterInPlace(col,
new IPredicate<Foo>(){
public boolean keepIt(Foo foo) {
return foo.isBar();
}
});
où filterInPlace () itère la collection et appelle Predicate.keepIt () pour savoir si l'instance doit être conservée dans la collection.
Je ne vois pas vraiment de raison d'introduire une bibliothèque tierce uniquement pour cette tâche.
Considérez Google Collections pour un cadre de collections mis à jour prenant en charge les génériques.
UPDATE: la bibliothèque de collections Google est maintenant obsolète. Vous devez utiliser la dernière version de Guava à la place. Il possède toujours les mêmes extensions du cadre de collections, y compris un mécanisme de filtrage basé sur un prédicat.
Attendez Java 8:
List<Person> olderThan30 =
//Create a Stream from the personList
personList.stream().
//filter the element to select only those with age >= 30
filter(p -> p.age >= 30).
//put those filtered elements into a new List.
collect(Collectors.toList());
Je vais lancer RxJava dans le ring, qui est également disponible sur Android . RxJava n'est peut-être pas toujours la meilleure option, mais cela vous donnera plus de flexibilité si vous souhaitez ajouter davantage de transformations à votre collection ou gérer les erreurs lors du filtrage.
Observable.from(Arrays.asList(1, 2, 3, 4, 5))
.filter(new Func1<Integer, Boolean>() {
public Boolean call(Integer i) {
return i % 2 != 0;
}
})
.subscribe(new Action1<Integer>() {
public void call(Integer i) {
System.out.println(i);
}
});
Sortie:
1
3
5
Plus de détails sur filter de RxJava peuvent être trouvés ici .
Depuis la première version de Java 8, vous pouvez essayer quelque chose comme:
Collection<T> collection = ...;
Stream<T> stream = collection.stream().filter(...);
Par exemple, si vous avez une liste d'entiers et que vous souhaitez filtrer les nombres> 10, puis les imprimer sur la console, vous pouvez procéder comme suit:
List<Integer> numbers = Arrays.asList(12, 74, 5, 8, 16);
numbers.stream().filter(n -> n > 10).forEach(System.out::println);
Êtes-vous sûr de vouloir filtrer la collection elle-même plutôt qu'un itérateur?
voir org.Apache.commons.collections.iterators.FilterIterator
ou en utilisant la version 4 de Apache commons org.Apache.commons.collections4.iterators.FilterIterator
La mise en place:
public interface Predicate<T> {
public boolean filter(T t);
}
void filterCollection(Collection<T> col, Predicate<T> predicate) {
for (Iterator i = col.iterator(); i.hasNext();) {
T obj = i.next();
if (predicate.filter(obj)) {
i.remove();
}
}
}
L'usage:
List<MyObject> myList = ...;
filterCollection(myList, new Predicate<MyObject>() {
public boolean filter(MyObject obj) {
return obj.shouldFilter();
}
});
Que diriez-vous de Java clair et direct?
List<Customer> list ...;
List<Customer> newList = new ArrayList<>();
for (Customer c : list){
if (c.getName().equals("dd")) newList.add(c);
}
Simple, lisible et facile (et fonctionne sous Android!) Mais si vous utilisez Java 8, vous pouvez le faire en une seule ligne:
List<Customer> newList = list.stream().filter(c -> c.getName().equals("dd")).collect(toList());
Notez que toList () est importé de manière statique
Voyons comment filtrer une liste JDK intégrée et une MutableList à l'aide de Collections Eclipse (anciennement GS Collections ).
List<Integer> jdkList = Arrays.asList(1, 2, 3, 4, 5);
MutableList<Integer> ecList = Lists.mutable.with(1, 2, 3, 4, 5);
Si vous souhaitez filtrer les nombres inférieurs à 3, vous pouvez vous attendre aux résultats suivants.
List<Integer> selected = Lists.mutable.with(1, 2);
List<Integer> rejected = Lists.mutable.with(3, 4, 5);
Voici comment vous pouvez filtrer en utilisant une classe interne anonyme comme Predicate.
Predicate<Integer> lessThan3 = new Predicate<Integer>()
{
public boolean accept(Integer each)
{
return each < 3;
}
};
Assert.assertEquals(selected, Iterate.select(jdkList, lessThan3));
Assert.assertEquals(selected, ecList.select(lessThan3));
Voici quelques alternatives pour filtrer les listes JDK et Collections Eclipse MutableLists utilisant la fabrique Prédicats .
Assert.assertEquals(selected, Iterate.select(jdkList, Predicates.lessThan(3)));
Assert.assertEquals(selected, ecList.select(Predicates.lessThan(3)));
Voici une version qui n'alloue pas d'objet pour le prédicat, en utilisant la fabrique Predicates2 à la place de la méthode selectWith qui prend un Predicate2.
Assert.assertEquals(
selected, ecList.selectWith(Predicates2.<Integer>lessThan(), 3));
Parfois, vous souhaitez filtrer sur une condition négative. Il existe une méthode spéciale dans les collections Eclipse pour celle appelée reject.
Assert.assertEquals(rejected, Iterate.reject(jdkList, lessThan3));
Assert.assertEquals(rejected, ecList.reject(lessThan3));
Voici comment filtrer en utilisant un Java 8 lambda en tant que Predicate.
Assert.assertEquals(selected, Iterate.select(jdkList, each -> each < 3));
Assert.assertEquals(rejected, Iterate.reject(jdkList, each -> each < 3));
Assert.assertEquals(selected, gscList.select(each -> each < 3));
Assert.assertEquals(rejected, gscList.reject(each -> each < 3));
La méthode partition renverra deux collections contenant les éléments sélectionnés et rejetés par Predicate.
PartitionIterable<Integer> jdkPartitioned = Iterate.partition(jdkList, lessThan3);
Assert.assertEquals(selected, jdkPartitioned.getSelected());
Assert.assertEquals(rejected, jdkPartitioned.getRejected());
PartitionList<Integer> ecPartitioned = gscList.partition(lessThan3);
Assert.assertEquals(selected, ecPartitioned.getSelected());
Assert.assertEquals(rejected, ecPartitioned.getRejected());
Remarque: je suis un partisan des collections Eclipse.
La méthode Collections2.filter (Collection, Predicate) dans bibliothèque Google de goyave fait exactement ce que vous recherchez.
ForEach DSL, vous pouvez écrire
import static ch.akuhn.util.query.Query.select;
import static ch.akuhn.util.query.Query.$result;
import ch.akuhn.util.query.Select;
Collection<String> collection = ...
for (Select<String> each : select(collection)) {
each.yield = each.value.length() > 3;
}
Collection<String> result = $result();
Avec une collection de [The, quick, brown, renard, sauts, over, the, paresseux, chien], il en résulte [quick, brown, sauts, over, paresseux], c'est-à-dire toutes les chaînes plus longues que trois caractères.
Tous les styles d’itération pris en charge par DSL ForEach sont
AllSatisfyAnySatisfyCollectCounntCutPiecesDetectGroupedByIndexOfInjectIntoRejectSelect
Pour plus de détails, veuillez vous référer à https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach
Depuis Java 9Collectors.filtering est activé:
public static <T, A, R>
Collector<T, ?, R> filtering(Predicate<? super T> predicate,
Collector<? super T, A, R> downstream)
Ainsi, le filtrage devrait être:
collection.stream().collect(Collectors.filtering(predicate, collector))
Exemple:
List<Integer> oddNumbers = List.of(1, 19, 15, 10, -10).stream()
.collect(Collectors.filtering(i -> i % 2 == 1, Collectors.toList()));
Ceci, combiné au manque de fermetures réelles, est mon plus grand reproche pour Java. Honnêtement, la plupart des méthodes mentionnées ci-dessus sont assez faciles à lire et vraiment efficaces; Cependant, après avoir passé du temps avec .Net, Erlang, etc., la compréhension de la liste intégrée au niveau de la langue simplifie grandement la tâche. Sans ajouts au niveau de la langue, Java ne peut tout simplement pas être aussi propre que beaucoup d'autres langues dans ce domaine.
Si les performances sont une préoccupation majeure, les collections de Google sont la voie à suivre (ou écrivez votre propre utilitaire de prédicat simple). La syntaxe Lambdaj est plus lisible pour certaines personnes, mais elle n’est pas aussi efficace.
Et puis il y a une bibliothèque que j'ai écrite. Je vais ignorer toutes les questions concernant son efficacité (oui, c'est si mauvais) ...... Oui, je sais qu'il est clairement basé sur la réflexion, et non, je ne l'utilise pas réellement, mais cela fonctionne:
LinkedList<Person> list = ......
LinkedList<Person> filtered =
Query.from(list).where(Condition.ensure("age", Op.GTE, 21));
OU
LinkedList<Person> list = ....
LinkedList<Person> filtered = Query.from(list).where("x => x.age >= 21");
Quelques très bonnes réponses ici. Moi, j'aimerais que les choses restent aussi simples et lisibles que possible:
public abstract class AbstractFilter<T> {
/**
* Method that returns whether an item is to be included or not.
* @param item an item from the given collection.
* @return true if this item is to be included in the collection, false in case it has to be removed.
*/
protected abstract boolean excludeItem(T item);
public void filter(Collection<T> collection) {
if (CollectionUtils.isNotEmpty(collection)) {
Iterator<T> iterator = collection.iterator();
while (iterator.hasNext()) {
if (excludeItem(iterator.next())) {
iterator.remove();
}
}
}
}
}
JFilter http://code.google.com/p/jfilter/ est le mieux adapté à vos besoins.
JFilter est une bibliothèque open source simple et hautes performances pour interroger la collection de beans Java.
Principales caractéristiques
- Prise en charge des propriétés de collection (Java.util.Collection, Java.util.Map et Array).
- Support de collection dans la collection de n'importe quelle profondeur.
- Prise en charge des requêtes internes.
- Prise en charge des requêtes paramétrées.
- Peut filtrer 1 million d’enregistrements en quelques 100 ms.
- Filtre (requête) est donné au format JSON simple, c'est comme les requêtes Mangodb. Voici quelques exemples.
- {"id": {"$ le": "10"}
- où la propriété object id est inférieure à égale à 10.
- {"id": {"$ in": ["0", "100"]}}
- où la propriété object id est 0 ou 100.
- {"lineItems": {"lineAmount": "1"}}
- où lineItems propriété de collection de type paramétré a lineAmount égal à 1.
- {"$ et": [{"id": "0"}, {"billingAddress": {"ville": "DEL"}}}}.
- où la propriété id est 0 et la propriété billingAddress.city est DEL.
- {"lineItems": {"taxes": {"clé": {"code": "TPS"}, "valeur": {"$ gt": "1.01"}}}}
- où la propriété de collection lineItems de type paramétré ayant la taxe type de carte, la propriété de type paramétré a un code égal à la valeur GST supérieure à 1.01.
- {'$ ou': [{'code': '10'}, {'skus': {'$ et': [{'price': {'$ in': ['20', '40']} }, {'code': 'RedApple'}]}}]}
- Sélectionnez tous les produits dont le code de produit est 10 ou le prix de référence en 20 et 40 et le code de référence est "RedApple".
Utilisez moteur de recherche de collection (CQEngine) . C'est de loin le moyen le plus rapide de le faire.
Voir aussi: Comment interrogez-vous les collections d'objets dans Java (critères/type SQL)?
J'ai écrit ne classe Iterable étendue qui prend en charge l'application d'algorithmes fonctionnels sans copier le contenu de la collection.
Usage:
List<Integer> myList = new ArrayList<Integer>(){ 1, 2, 3, 4, 5 }
Iterable<Integer> filtered = Iterable.wrap(myList).select(new Predicate1<Integer>()
{
public Boolean call(Integer n) throws FunctionalException
{
return n % 2 == 0;
}
})
for( int n : filtered )
{
System.out.println(n);
}
Le code ci-dessus sera effectivement exécuté
for( int n : myList )
{
if( n % 2 == 0 )
{
System.out.println(n);
}
}
En utilisant Java 8, en particulier lambda expression, vous pouvez le faire simplement comme dans l'exemple ci-dessous:
myProducts.stream().filter(prod -> prod.price>10).collect(Collectors.toList())
où pour chaque product à l'intérieur de la collection myProducts, si prod.price>10, ajoutez ce produit à la nouvelle liste filtrée.
Je devais filtrer une liste en fonction des valeurs déjà présentes dans la liste. Par exemple, supprimez toutes les valeurs suivantes qui sont inférieures à la valeur actuelle. {2 5 3 4 7 5} -> {2 5 7}. Ou par exemple pour supprimer tous les doublons {3 5 4 2 3 5 6} -> {3 5 4 2 6}.
public class Filter {
public static <T> void List(List<T> list, Chooser<T> chooser) {
List<Integer> toBeRemoved = new ArrayList<>();
leftloop:
for (int right = 1; right < list.size(); ++right) {
for (int left = 0; left < right; ++left) {
if (toBeRemoved.contains(left)) {
continue;
}
Keep keep = chooser.choose(list.get(left), list.get(right));
switch (keep) {
case LEFT:
toBeRemoved.add(right);
continue leftloop;
case RIGHT:
toBeRemoved.add(left);
break;
case NONE:
toBeRemoved.add(left);
toBeRemoved.add(right);
continue leftloop;
}
}
}
Collections.sort(toBeRemoved, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
for (int i : toBeRemoved) {
if (i >= 0 && i < list.size()) {
list.remove(i);
}
}
}
public static <T> void List(List<T> list, Keeper<T> keeper) {
Iterator<T> iterator = list.iterator();
while (iterator.hasNext()) {
if (!keeper.keep(iterator.next())) {
iterator.remove();
}
}
}
public interface Keeper<E> {
boolean keep(E obj);
}
public interface Chooser<E> {
Keep choose(E left, E right);
}
public enum Keep {
LEFT, RIGHT, BOTH, NONE;
}
}
Ce sera utilisé comme ça.
List<String> names = new ArrayList<>();
names.add("Anders");
names.add("Stefan");
names.add("Anders");
Filter.List(names, new Filter.Chooser<String>() {
@Override
public Filter.Keep choose(String left, String right) {
return left.equals(right) ? Filter.Keep.LEFT : Filter.Keep.BOTH;
}
});
Ma réponse s'appuie sur celle de Kevin Wong, ici en tant que ligne unique utilisant CollectionUtils à partir de spring et d'un Java 8 expression lambda .
CollectionUtils.filter(list, p -> ((Person) p).getAge() > 16);
C’est aussi concis et lisible que toute alternative que j’ai vue (sans utiliser de bibliothèques basées sur les aspects)
Spring CollectionUtils est disponible à partir de la version de printemps 4.0.2.RELEASE. N'oubliez pas que vous avez besoin de JDK 1.8 et du niveau de langue 8+.
La solution simple pré-Java8:
ArrayList<Item> filtered = new ArrayList<Item>();
for (Item item : items) if (condition(item)) filtered.add(item);
Malheureusement, cette solution n'est pas totalement générique, elle génère une liste plutôt que le type de la collection donnée. De plus, importer des bibliothèques ou écrire des fonctions qui encapsulent ce code me semble excessif à moins que la condition ne soit complexe, mais vous pouvez alors écrire une fonction pour la condition.
https://code.google.com/p/joquery/
Prend en charge différentes possibilités,
Collection donnée,
Collection<Dto> testList = new ArrayList<>();
de type,
class Dto
{
private int id;
private String text;
public int getId()
{
return id;
}
public int getText()
{
return text;
}
}
Filtre
Java 7
Filter<Dto> query = CQ.<Dto>filter(testList)
.where()
.property("id").eq().value(1);
Collection<Dto> filtered = query.list();
Java 8
Filter<Dto> query = CQ.<Dto>filter(testList)
.where()
.property(Dto::getId)
.eq().value(1);
Collection<Dto> filtered = query.list();
Aussi,
Filter<Dto> query = CQ.<Dto>filter()
.from(testList)
.where()
.property(Dto::getId).between().value(1).value(2)
.and()
.property(Dto::grtText).in().value(new string[]{"a","b"});
Tri (également disponible pour le Java 7)
Filter<Dto> query = CQ.<Dto>filter(testList)
.orderBy()
.property(Dto::getId)
.property(Dto::getName)
Collection<Dto> sorted = query.list();
Groupement (également disponible pour le Java 7)
GroupQuery<Integer,Dto> query = CQ.<Dto,Dto>query(testList)
.group()
.groupBy(Dto::getId)
Collection<Grouping<Integer,Dto>> grouped = query.list();
Jointures (également disponible pour le Java 7)
Donné,
class LeftDto
{
private int id;
private String text;
public int getId()
{
return id;
}
public int getText()
{
return text;
}
}
class RightDto
{
private int id;
private int leftId;
private String text;
public int getId()
{
return id;
}
public int getLeftId()
{
return leftId;
}
public int getText()
{
return text;
}
}
class JoinedDto
{
private int leftId;
private int rightId;
private String text;
public JoinedDto(int leftId,int rightId,String text)
{
this.leftId = leftId;
this.rightId = rightId;
this.text = text;
}
public int getLeftId()
{
return leftId;
}
public int getRightId()
{
return rightId;
}
public int getText()
{
return text;
}
}
Collection<LeftDto> leftList = new ArrayList<>();
Collection<RightDto> rightList = new ArrayList<>();
Peut être joint comme,
Collection<JoinedDto> results = CQ.<LeftDto, LeftDto>query().from(leftList)
.<RightDto, JoinedDto>innerJoin(CQ.<RightDto, RightDto>query().from(rightList))
.on(LeftFyo::getId, RightDto::getLeftId)
.transformDirect(selection -> new JoinedDto(selection.getLeft().getText()
, selection.getLeft().getId()
, selection.getRight().getId())
)
.list();
Expressions
Filter<Dto> query = CQ.<Dto>filter()
.from(testList)
.where()
.exec(s -> s.getId() + 1).eq().value(2);
Avec goyave:
Collection<Integer> collection = Lists.newArrayList(1, 2, 3, 4, 5);
Iterators.removeIf(collection.iterator(), new Predicate<Integer>() {
@Override
public boolean apply(Integer i) {
return i % 2 == 0;
}
});
System.out.println(collection); // Prints 1, 3, 5
Dans Java 8, vous pouvez directement utiliser cette méthode de filtrage, puis le faire.
List<String> lines = Arrays.asList("Java", "pramod", "example");
List<String> result = lines.stream()
.filter(line -> !"pramod".equals(line))
.collect(Collectors.toList());
result.forEach(System.out::println);