Avalie list.contains string em JSTL

Eu preciso esconder um elemento se certos valores estiverem presentes no JSP

Os valores são armazenados em uma lista, então tentei:

<c:if test="${  mylist.contains( myValue ) }">style='display:none;'</c:if>

Mas não funciona.

Como posso avaliar se uma lista contém um valor em JSTL, a lista e os valores são strings.

Infelizmente, acho que o JSTL não oferece suporte a nada além de uma iteração por meio de todos os elementos para descobrir isso. No passado, usei o método forEach na biblioteca de tags principais:

<c:set var="contains" value="false" />
<c:forEach var="item" items="${myList}">
  <c:if test="${item eq myValue}">
    <c:set var="contains" value="true" />
  </c:if>
</c:forEach>

Após a execução, $ {contains} será igual a "true" se myList contiver myValue.

não há nenhum recurso embutido para verificar isso - o que você faria é escrever sua própria função tld, que pega uma lista e um item, e chama o método contains () da lista. por exemplo

//in your own WEB-INF/custom-functions.tld file add this
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib
        PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib
        xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
        version="2.0"
        >
    <tlib-version>1.0</tlib-version>
    <function>
        <name>contains</name>
        <function-class>com.Yourclass</function-class>
        <function-signature>boolean contains(java.util.List,java.lang.Object)
        </function-signature>
    </function>
</taglib>

Em seguida, crie uma classe chamada Yourclass e adicione um método estático chamado contains com a assinatura acima. Tenho certeza de que a implementação desse método é bastante autoexplicativa:

package com; // just to illustrate how to represent the package in the tld
public class Yourclass {
   public static boolean contains(List list, Object o) {
      return list.contains(o);
   }
}

Depois, você pode usá-lo em seu jsp:

<%@ taglib uri="/WEB-INF/custom-functions.tld" prefix="fn" %>
<c:if test="${  fn:contains( mylist, myValue ) }">style='display:none;'</c:if>

A tag pode ser usada em qualquer JSP no site.

editar: mais informações sobre o arquivo tld - mais informações aqui

Outra maneira de fazer isso é usar um Map (HashMap)com pares de chave e valor que representam seu objeto.

Map<Long, Object> map = new HashMap<Long, Object>();
map.put(new Long(1), "one");
map.put(new Long(2), "two");

Em JSTL

<c:if test="${not empty map[1]}">

Isso deve retornar verdadeiro se o par existir no mapa

Você precisa usar a função fn:contains()ou fn:containsIgnoreCase().

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>

...

 <c:if test="${not fn:containsIgnoreCase(mylist, 'apple')}">
        <p>Doesn't contain 'apple'</p>
    </c:if>

ou

<c:if test="${not fn:contains(mylist, 'Apple')}">
            <p>Contains 'Apple'</p>
        </c:if>

Nota: Isso funcionará comomylist.toString().contains("apple")e se não for o que você está procurando, use uma outra abordagem.

O que segue é mais uma solução alternativa do que uma resposta à sua pergunta, mas pode ser o que você está procurando. Se você pudesse colocar seus valores em um mapa em vez de uma lista, isso resolveria seu problema. Basta mapear seus valores para um valor não nulo e fazer isso <c:if test="${mymap.myValue ne null}">style='display:none;'</c:if>ou você pode até mesmo mapear style='display:none;e simplesmente gerar${mymap.myValue}

${fn:contains({1,2,4,8}, 2)}

OU

  <c:if test = "${fn:contains(theString, 'test')}">
     <p>Found test string<p>
  </c:if>

  <c:if test = "${fn:contains(theString, 'TEST')}">
     <p>Found TEST string<p>
  </c:if>

Se você estiver usando EL 3.0+ , a melhor abordagem neste caso é como esta outra resposta explicada em outro tópico:

Para Collectionfacilitar, basta usar o Colleciton#contains() método em EL.

<h:panelGroup id="p1" rendered="#{bean.panels.contains('p1')}">...</h:panelGroup>
<h:panelGroup id="p2" rendered="#{bean.panels.contains('p2')}">...</h:panelGroup>
<h:panelGroup id="p3" rendered="#{bean.panels.contains('p3')}">...</h:panelGroup>

Para um Object[](array), você precisa de no mínimo EL 3.0 e utiliza seu novo suporte para Lambda.

<h:panelGroup id="p1" rendered="#{bean.panels.stream().anyMatch(v -> v == 'p1').get()}">...</h:panelGroup>
<h:panelGroup id="p2" rendered="#{bean.panels.stream().anyMatch(v -> v == 'p2').get()}">...</h:panelGroup>
<h:panelGroup id="p3" rendered="#{bean.panels.stream().anyMatch(v -> v == 'p3').get()}">...</h:panelGroup>

Se você ainda não estiver no EL 3.0, precisará criar uma função EL personalizada. [...]

Se estiver usando Spring Framework, você pode usar Spring TagLib e SpEL:

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>
---
<spring:eval var="containsValue" expression="mylist.contains(myValue)" />
<c:if test="${containsValue}">style='display:none;'</c:if>

Eu achei essa solução incrível.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%
   ArrayList list = new ArrayList();
   list.add("one");
   list.add("two");
   list.add("three");
%>
<c:set var="list" value="<%=list%>" />
<html>
<body>
        My list is ${list}<br/>
<c:if test='${fn:contains(list, "two")}'>
        My list contains two <br/>
</c:if>
<c:if test='${fn:contains(list, ",")}'>
        My list contains , 
</c:if>
</body>
</html>

A saída para o código acima é

Minha lista é [um, dois, três]

Minha lista contém dois

Minha lista contém,

Eu espero que isso ajude alguém.

<c:if test="${fn:contains(task.subscribers, customer)}">

Este trabalho é bom para mim.