`

struts2<s:iterator>遍历map

 
阅读更多

1.假使现在有这样一个Action：

Java代码
  1. importjava.util.ArrayList;
  2. importjava.util.HashMap;
  3. importjava.util.List;
  4. importjava.util.Map;
  6. importcom.opensymphony.xwork2.ActionSupport
  7. importcom.model.Student
  8. publicclassMapActionextendsActionSupport
  9. {
  11. privateMap<String，String>map;
  13. privateMap<String，Student>studentMap;
  15. privateMap<String，String[]>arrayMap;
  17. privateMap<String，List<Student>>listMap;
  20. publicStringtestMap（）
  21. {
  22. map=newHashMap<String，String>（）;
  23. map.put（"1"，"one"）;
  24. map.put（"2"，"two"）;
  26. studentMap=newHashMap<String，Student>（）;
  27. studentMap.put（"student1"，newStudent（newLong（1），"20034140201"，"张三1"，"男"，25））;
  28. studentMap.put（"student2"，newStudent（newLong（2），"20034140202"，"张三2"，"女"，26））;
  29. studentMap.put（"student3"，newStudent（newLong（3），"20034140202"，"张三3"，"男"，27））;
  31. arrayMap=newHashMap<String，String[]>（）;
  32. arrayMap.put（"arr1"，newString[]{"1"，"2003401"，"leejie"，"male"，"20"}）;
  33. arrayMap.put（"arr2"，newString[]{"2"，"2003402"，"huanglie"，"male"，"25"}）;
  34. arrayMap.put（"arr3"，newString[]{"3"，"2003403"，"lixiaoning"，"male"，"21"}）;
  37. listMap=newHashMap<String，List<Student>>（）;
  39. List<Student>list1=newArrayList<Student>（）;
  40. list1.add（newStudent（newLong（1），"20034140201"，"张三1"，"男"，25））;
  41. list1.add（newStudent（newLong（2），"20034140202"，"张三2"，"男"，25））;
  42. list1.add（newStudent（newLong（3），"20034140203"，"张三3"，"男"，25））;
  43. listMap.put（"class1"，list1）;
  45. List<Student>list2=newArrayList<Student>（）;
  46. list2.add（newStudent（newLong（1），"20034140301"，"李四1"，"男"，20））;
  47. list2.add（newStudent（newLong（2），"20034140302"，"李四2"，"男"，21））;
  48. list2.add（newStudent（newLong（3），"20034140303"，"李四3"，"男"，22））;
  49. list2.add（newStudent（newLong（4），"20034140304"，"李四4"，"男"，23））;
  50. listMap.put（"class2"，list2）;
  55. returnSUCCESS;
  57. }
  59. publicMap<String，String>getMap（）{
  60. returnmap;
  61. }
  63. publicvoidsetMap（Map<String，String>map）{
  64. this.map=map;
  65. }
  67. publicMap<String，Student>getStudentMap（）{
  68. returnstudentMap;
  69. }
  71. publicvoidsetStudentMap（Map<String，Student>studentMap）{
  72. this.studentMap=studentMap;
  73. }
  75. publicMap<String，String[]>getArrayMap（）{
  76. returnarrayMap;
  77. }
  80. publicvoidsetArrayMap（Map<String，String[]>arrayMap）{
  81. this.arrayMap=arrayMap;
  82. }
  85. publicMap<String，List<Student>>getListMap（）{
  86. returnlistMap;
  87. }
  89. publicvoidsetListMap（Map<String，List<Student>>listMap）{
  90. this.listMap=listMap;
  91. }
  94. }

这个action中给出了各种类型的map，下面我们有这样一个jsp，我们要将这些map展示到这个jsp中：

Jsp代码
  1. <％＠pagecontentType="text/html;charset=UTF-8"％>
  2. <％＠taglibprefix="s"uri="/struts-tags"％>
  3. <html>
  4. <head>
  5. <title>struts2中的map遍历总结</title>
  6. </head>
  7. <body>
  8. <b>1.map中的value为String字符串</b><br>
  9. <s:iteratorvalue="map"id="column">
  10. <s:propertyvalue="＃column"/><br>
  11. key:<s:propertyvalue="key"/><br>
  12. value:<s:propertyvalue="value"/><br>
  13. ******************************************<br>
  14. </s:iterator>
  17. <b>2.map中的value为Student对象</b>
  18. <tableborder="1"width="50％"cellspacing="0"cellpadding="0">
  19. <tr>
  20. <td>key=value</td>
  21. <td>ID</td>
  22. <td>num</td>
  23. <td>name</td>
  24. <td>sex</td>
  25. <td>age</td>
  26. </tr>
  27. <s:iteratorvalue="studentMap"id="column">
  28. <tr>
  29. <td><s:propertyvalue="＃column"/></td>
  30. <td><s:propertyvalue="value.id"/></td>
  31. <td><s:propertyvalue="value.num"/></td>
  32. <td><s:propertyvalue="value.name"/></td>
  33. <td><s:propertyvalue="value.sex"/></td>
  34. <td><s:propertyvalue="value.age"/></td>
  35. </tr>
  36. </s:iterator>
  37. </table>
  38. <p>
  41. <b>3.map中的value为String数组</b>
  42. <tableborder="1"width="50％"cellspacing="0"cellpadding="0">
  43. <tr>
  44. <td>key=value</td>
  45. <td>ID</td>
  46. <td>num</td>
  47. <td>name</td>
  48. <td>sex</td>
  49. <td>age</td>
  50. </tr>
  51. <s:iteratorvalue="arrayMap"id="column">
  52. <tr>
  53. <td><s:propertyvalue="＃column"/></td>
  54. <td><s:propertyvalue="value[0]"/></td>
  55. <td><s:propertyvalue="value[1]"/></td>
  56. <td><s:propertyvalue="value[2]"/></td>
  57. <td><s:propertyvalue="value[3]"/></td>
  58. <td><s:propertyvalue="value[4]"/></td>
  59. </tr>
  60. </s:iterator>
  61. </table>
  62. <p>
  63. <b>4.map中的value为list凑集</b>
  64. <tableborder="1"width="50％"cellspacing="0"cellpadding="0">
  65. <tr>
  66. <td>class</td>
  67. <td>ID</td>
  68. <td>num</td>
  69. <td>name</td>
  70. <td>sex</td>
  71. <td>age</td>
  72. </tr>
  74. <1.<s:iteratorvalue="listHashMap"id="listid">
  75. <s:iteratorvalue="＃listid.value"id="listidsub">
  76. <tr>
  77. <td><s:propertyvalue="key"/></td>
  78. <td><s:propertyvalue="id"/></td>
  79. <td><s:propertyvalue="num"/></td>
  80. <td><s:propertyvalue="name"/></td>
  81. <td><s:propertyvalue="sex"/></td>
  82. <td><s:propertyvalue="age"/></td>
  83. </tr>
  84. </s:iterator>
  85. </s:iterator>
  86. </table>
  89. </body>
  90. </html>

Java代码
  1. 4、普通属性
  2. publicStringexecute(){
  3. username="zhangsan";
  4. password="123";
  5. }
  6. <s:propertyvalue="username"/><br>
  7. <s:propertyvalue="password"/><br>
  9. 5、自定义对象
  10. publicStringexecute(){
  11. userInfo=newUserInfo();
  12. userInfo.setUsername("hhh");
  13. userInfo.setPassword("111");
  14. }
  15. <s:propertyvalue="userInfo.username"/><br>
  16. <s:propertyvalue="userInfo.password"/><br>
  18. 6、List（普通属性）
  19. publicStringexecute(){
  20. list=newArrayList<String>();
  21. list.add("aaa");
  22. list.add("bbb");
  23. list.add("ccc");
  24. }
  25. <s:iteratorvalue="list"var="var">
  26. <s:propertyvalue="var"/><br>
  27. </s:iterator>
  28. 或者：
  29. <s:iteratorvalue="list">
  30. <s:property/><br>
  31. </s:iterator>
  33. 6、List（自定义对象属性）
  34. publicStringexecute(){
  35. list=newArrayList<UserInfo>();
  36. UserInfouserInfo=newUserInfo();
  37. userInfo.setUsername("u1");
  38. userInfo.setPassword("p1");
  39. userInfo.setRoleInfo(newRoleInfo("r1"));
  40. list.add(userInfo);
  41. userInfo=newUserInfo();
  42. userInfo.setUsername("u2");
  43. userInfo.setPassword("p2");
  44. userInfo.setRoleInfo(newRoleInfo("r2"));
  45. list.add(userInfo);
  46. }
  47. <s:iteratorvalue="list"var="var">
  48. <s:propertyvalue="#var.username"/>
  49. <s:propertyvalue="#var.password"/>
  50. <s:propertyvalue="#var.roleInfo.rolename"/><br>
  51. </s:iterator>
  52. 或者：
  53. <s:iteratorvalue="list">
  54. <s:propertyvalue="username"/>
  55. <s:propertyvalue="password"/>
  56. <s:propertyvalue="roleInfo.rolename"/><br>
  57. </s:iterator>
  59. 7、数组（普通属性）
  60. publicStringexecute(){
  61. strs=newString[2];
  62. strs[0]="as";
  63. strs[1]="asd";
  64. }
  65. <s:iteratorvalue="strs">
  66. <s:property/><br>
  67. </s:iterator>
  68. 或者：
  69. <s:iteratorvalue="strs"var="var">
  70. <s:propertyvalue="var"/><br>
  71. </s:iterator>
  73. 8、数组（自定义对象属性）
  74. publicStringexecute(){
  75. strs=newUserInfo[2];
  76. UserInfouserInfo=newUserInfo();
  77. userInfo.setUsername("u11");
  78. userInfo.setPassword("11");
  79. strs[0]=userInfo;
  80. userInfo=newUserInfo();
  81. userInfo.setUsername("u22");
  82. userInfo.setPassword("22");
  83. strs[1]=userInfo;
  84. }
  85. <s:iteratorvalue="strs">
  86. <s:propertyvalue="username"/>
  87. <s:propertyvalue="password"/><br>
  88. </s:iterator>
  89. 或者：
  90. <s:iteratorvalue="strs"var="var">
  91. <s:propertyvalue="#var.username"/>
  92. <s:propertyvalue="#var.password"/><br>
  93. </s:iterator>
  95. 8、数组（自定义对象属性）
  96. publicStringexecute(){
  97. strs=newUserInfo[2];
  98. UserInfouserInfo=newUserInfo();
  99. userInfo.setUsername("u11");
  100. userInfo.setPassword("11");
  101. userInfo.setRoleInfo(newRoleInfo("r11"));
  102. strs[0]=userInfo;
  103. userInfo=newUserInfo();
  104. userInfo.setUsername("u22");
  105. userInfo.setPassword("22");
  106. userInfo.setRoleInfo(newRoleInfo("r22"));
  107. strs[1]=userInfo;
  108. }
  109. <s:iteratorvalue="strs"var="var">
  110. <s:propertyvalue="#var.username"/>
  111. <s:propertyvalue="#var.password"/>
  112. <s:propertyvalue="#var.roleInfo.rolename"/><br>
  113. </s:iterator>
  114. 或者：
  115. <s:iteratorvalue="strs">
  116. <s:propertyvalue="username"/>
  117. <s:propertyvalue="password"/>
  118. <s:propertyvalue="roleInfo.rolename"/><br>
  119. </s:iterator>
  121. 8、Map（普通属性）
  122. publicStringexecute(){
  123. map=newHashMap<String,String>();
  124. map.put("k1","v1");
  125. map.put("k2","v2");
  126. }
  127. <s:iteratorvalue="map"var="var">
  128. <s:propertyvalue="#var.key"/>
  129. <s:propertyvalue="#var.value"/><br>
  130. </s:iterator>
  131. 或者：
  132. <s:iteratorvalue="map">
  133. <s:propertyvalue="key"/>
  134. <s:propertyvalue="value"/><br>
  135. </s:iterator>
  137. 8、Map（自定义对象属性）
  138. publicStringexecute(){
  139. map=newHashMap<String,UserInfo>();
  140. UserInfouserInfo=newUserInfo();
  141. userInfo.setUsername("u1");
  142. userInfo.setPassword("p1");
  143. userInfo.setRoleInfo(newRoleInfo("r1"));
  144. map.put("k1",userInfo);
  145. userInfo=newUserInfo();
  146. userInfo.setUsername("u2");
  147. userInfo.setPassword("p2");
  148. userInfo.setRoleInfo(newRoleInfo("r2"));
  149. map.put("k2",userInfo);
  150. }
  151. <s:iteratorvalue="map"var="var">
  152. <s:propertyvalue="#var.key"/>
  153. <s:propertyvalue="#var.value.username"/>
  154. <s:propertyvalue="#var.value.password"/>
  155. <s:propertyvalue="#var.value.roleInfo.rolename"/><br>
  156. </s:iterator>
  157. 或者
  158. <s:iteratorvalue="map">
  159. <s:propertyvalue="key"/>
  160. <s:propertyvalue="value.username"/>
  161. <s:propertyvalue="value.password"/>
  162. <s:propertyvalue="value.roleInfo.rolename"/><br>
  163. </s:iterator>
  165. 8、Map嵌套Map（自定义对象属性）
  166. publicStringexecute(){
  167. map=newTreeMap<String,Map<String,UserInfo>>();
  168. Map<String,UserInfo>innerMap=newTreeMap<String,UserInfo>();
  169. UserInfouserInfo=newUserInfo();
  170. userInfo.setUsername("u1");
  171. userInfo.setPassword("p1");
  172. userInfo.setRoleInfo(newRoleInfo("r1"));
  173. userInfo=newUserInfo();
  174. userInfo.setUsername("u11");
  175. userInfo.setPassword("p11");
  176. userInfo.setRoleInfo(newRoleInfo("r11"));
  177. innerMap.put("k1",userInfo);
  178. innerMap.put("k11",userInfo);
  179. map.put("key1",innerMap);
  180. //////////////////////////
  181. innerMap=newTreeMap<String,UserInfo>();
  182. userInfo=newUserInfo();
  183. userInfo.setUsername("u2");
  184. userInfo.setPassword("p2");
  185. userInfo.setRoleInfo(newRoleInfo("r2"));
  186. userInfo=newUserInfo();
  187. userInfo.setUsername("u22");
  188. userInfo.setPassword("p22");
  189. userInfo.setRoleInfo(newRoleInfo("r22"));
  190. innerMap.put("k2",userInfo);
  191. innerMap.put("k22",userInfo);
  192. map.put("key2",innerMap);
  193. }
  194. <s:iteratorvalue="map"var="var">
  195. <s:iteratorvalue="value">
  196. <s:propertyvalue="#var.key"/>
  197. <s:propertyvalue="key"/>
  198. <s:propertyvalue="value.username"/>
  199. <s:propertyvalue="value.password"/>
  200. <s:propertyvalue="value.roleInfo.rolename"/><br>
  201. </s:iterator>
  202. </s:iterator>

分享到：
| js得到两个日期之间间隔的天数
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历（三十五）

    本文将深入探讨如何在JSP中将`List`, `Set`, `Map`等集合类型的数据传递到Action，然后再通过`&lt;s:iterator&gt;`标签进行遍历显示。这种方式对于数据的展示和交互具有重要的实践意义。 首先，我们需要了解Struts2的工作...

    Struts2 iterator 标签遍历 Map,List,数组（三十六）

    在这个例子中，`myMap`是Action类中的一个Map属性，`iterator`标签会遍历Map的每个键值对，并使用`s:property`标签显示它们。 接下来，我们讨论如何遍历List。List是一种有序的集合，`iterator`标签通过`status`...

    对 Struts 2 的 s: iterator tag 中嵌套的所有 s: checkbox 进行全选、反选操作

    `s:iterator`标签是Struts 2 提供的一个迭代标签，它允许开发者遍历任何可迭代的对象，如数组、集合或Map。在描述中提到的场景，这个标签用于遍历一个数据集，然后为每个元素创建一个`&lt;s:checkbox&gt;`标签。 `s:...

    struts2中的map遍历

    在Struts2中，我们可以使用OGNL（Object-Graph Navigation Language）表达式语言来遍历Map。 在Struts2中，Map遍历通常在JSP页面上进行，使用OGNL表达式。以下是一个简单的例子： ```jsp &lt;%@ taglib prefix="s" ...

    strust2 s:iterator常用情况个人总结

    在 Struts2 框架中，`s:iterator` 是一个非常重要的标签，它主要用于遍历集合数据（如数组、列表、映射表等），并且在 JSP 页面上显示这些数据。下面将根据提供的示例代码对 `s:iterator` 在不同场景下的使用进行...

    s：iterator 用法 (2).docx

    Struts2 框架中的 `s:iterator` 标签是用于遍历集合、数组、Map 或数据栈中的对象的，它提供了强大的迭代能力，能够方便地在JSP页面中展示数据。以下是对 `s:iterator` 标签用法的详细说明： 1. **数组或List遍历**...

    s：iterator 用法.pdf

    &lt;s:if test="#st.isEven()"&gt;现在的索引是奇数为:&lt;s:property value='#st.index'/&gt;&lt;/s:if&gt; 当前元素值：&lt;s:property value='char'/&gt; &lt;/s:iterator&gt; ``` 3. **遍历Map** `value`属性可以直接设置为Map对象，或者...

    s：iterator 用法.docx

    Struts2 框架中的 `s:iterator` 标签是用于遍历集合、数组、Map 或者数据栈中的对象的重要组件。这个标签提供了一种便捷的方式来在 JSP 页面上展示动态数据，使得开发者能够方便地循环遍历并显示元素。下面我们将...

    s：iterator 用法 (2).pdf

    Struts2框架中的`s:iterator`标签是用于循环遍历集合数据的重要标签，适用于处理数组、列表、Map等数据结构。下面将详细讲解这个标签的用法及其各种属性。 1. **基本用法** `s:iterator`标签的基础用法是通过`...

    struts2 标签库 帮助文档

    4. &lt;s:iterator&gt;&lt;/s:iterator&gt;-----用于遍历集合 L： 1. &lt;s:label&gt;&lt;/s:label&gt;-----只读的标签 M： 1. &lt;s:merge&gt;&lt;/s:merge&gt;-----合并遍历集合出来的值 O： 1. &lt;s:optgroup&gt;&lt;/s:optgroup&gt;-----获取...

    struts2中siterator 标签的使用详解 及 OGNL用法

    - **遍历数组或列表**：`&lt;s:iterator value="{'1','2','3','4','5'}" id='number'&gt;...&lt;/s:iterator&gt;` 这个例子中，`siterator` 标签将遍历给定的字符串数组，并为每个元素提供 ID 'number'。 - **利用 status 获取...

    struts2中iterator 标签的使用详解

    除了遍历列表和数组，`&lt;s:iterator&gt;`同样支持遍历Map类型的数据。Map的遍历可以通过直接指定Map的值或者引用数据栈中的Map对象来实现： ```xml &lt;s:iterator value="{'1':'a','2':'b'}" id="id" status="st"&gt; key: ...

    struts2遍历集合

    `s:iterator`标签是Struts2中最常用的遍历集合的标签。它的主要属性包括： - **value**：指定要遍历的集合，可以是数组、列表或Map类型的对象。 - **id**：为每个遍历元素设置一个临时变量名。 - **status**：提供...

    struts2迭代 Map List

    通过以上这些方法，Struts2的`&lt;s:iterator&gt;`标签能够灵活地处理Map和List数据，大大简化了JSP页面的数据展示逻辑。了解并熟练运用这些特性，能提高开发效率，让代码更加简洁易读。在实际项目中，根据具体需求进行...

    Struts2全部标签使用说明

    - `&lt;s:iterator&gt;` 用于遍历集合，如ArrayList、Map等，可以循环输出集合中的元素。 H. `&lt;s:head&gt;`, `&lt;s:hidden&gt;`: - `&lt;s:head/&gt;` 在HTML的`&lt;head&gt;`标签中使用，用于生成头部信息。 - `&lt;s:hidden&gt;` 创建一个隐藏字段...

    Struts iterator JSP Map 中嵌套 Map

    `&lt;s:iterator&gt;`是Struts2中的一个标签，用于迭代集合或者数组中的元素。在处理Map时，我们可以使用这个标签来迭代键值对，并在JSP页面上显示它们。 在描述中提到的"嵌套Map"是指Map的值本身还是另一个Map。这种结构...

    iterator嵌套，struts2

    在Struts2框架中，`iterator`标签是一个非常重要的组件，用于遍历各种集合对象，如List、Map等。在上述描述中，开发者遇到了一个关于`iterator`标签嵌套使用的问题，涉及到`LinkedHashMap`存储的数据结构。让我们...

    struts2标签介绍

    在Struts2中，所有的标签都统一在`&lt;s&gt;`前缀下，通过引入`&lt;%@ taglib prefix="s" uri="/struts-tags" %&gt;`就可以在页面上使用这些标签。 **A组标签：** 1. `&lt;s:a&gt;` - 用于创建超链接，与HTML的`&lt;a&gt;`标签类似，可以...

    struts2-tags-API.rar_struts2 api_struts2 tag api_struts2 tags ch

    5. **Iterative Tags**: `&lt;s:iterator&gt;`标签用于遍历集合，如List、Map等，是循环渲染数据的关键。 6. **Input Tags**: 包括`&lt;s:textfield&gt;`、`&lt;s:password&gt;`、`&lt;s:textarea&gt;`等，用于创建表单输入元素，并能自动...

    struts2标签详解与实例

    4. `&lt;s:iterator&gt;`：迭代标签，用于遍历集合对象，如List、Map等。例如： ```jsp &lt;s:iterator value="users"&gt; &lt;tr&gt; &lt;td&gt;&lt;s:property value="username" /&gt;&lt;/td&gt; &lt;td&gt;&lt;s:property value="email" /&gt;&lt;/td&gt; &lt;/tr&gt; ...

Magicbox
Global site tag (gtag.js) - Google Analytics