Freemarker 基本数据类型

Freemarker 基本数据类型

一 数据类型简介

      freemarker 模板中的数据类型由如下几种：

         1. 布尔型：等价于java中的boolean类型， 不同的是不能直接输出，可以转换成字符串再输出

         2. 日期型：等价于java中的Date类型， 不同之处在于不能直接输出，需要转换成字符串再输出

         3. 数值型：等价于java 中的int, float, double 等数值类型，有三种显示形式：数值型(默认) 、货币型、百分比型

         4. 字符串型：等价于java 中的字符串，有很多内置函数

         5. sequence 类型：等价于java中的数组，list，set 等集合类型

         6. hash 类型：等价于java 中的Map 类型

二、 数据类型示例

【1. 布尔型】 ：
    1. 不能直接输出布尔型的值， 必须转换为string：${b?string}
    2. 在if标签中可以直接使用 
        <#if b>
            b 的值为 true
        </#if>

【2. 日期型】
    1. 输出日期：${currentDate?date}
    2. 只输出时间：${currentDate?time}
    3. 输出日期时间：${currentDate?datetime}
    4. 格式化日期： ${currentDate?string('yyyy-MM-dd HH:mm:ss:S')}


【3. 数值型】 ：
     2.1 Freemarker 中预定义了三种数字格式，货币，百分比，数字，默认为数字格式
        货币：：${0.3?string.currency}
        百分比：${0.3?string.percent}
        数字（默认）：${0.3?string.number}
    
     2.2 取整
        1. 向上取整
            3.4     --> ${3.4?ceiling}

            3.5     --> ${3.5?ceiling}

        2. 向下取整
            3.4     --> ${3.4?floor}

            3.5     --> ${3.5?floor}

        3. 四舍五入
            3.4     --> ${3.4?round}

            3.5     --> ${3.5?round}

     2.3 数字格式化， 使用0 表示不够 由0 补齐， 用# 表示不够不补齐
        1. 保留两位小数: 必须两位，不够补0, 当前一位为偶数时，五舍六入， 当前一位为基数时，四舍五入
            0.135   -- > ${0.135?string('.00')}
            0.125   -- > ${0.125?string('.00')}
            0.1     -- > ${0.1?string('.00')}
            
        2. 保留两位小数: 最多两位，不够不补0, 当前一位为偶数时，五舍六入， 当前一位为基数时，四舍五入
            0.135   -- > ${0.135?string('#.##')}
            0.125   -- > ${0.125?string('#.##')}
            0.1     -- > ${0.1?string('#.##')}
            
        3. 格式化整数， 用0 表示必须三位整数，不够由0 补齐
            12.1   -- > ${12.1?string('000.00')}
            12.125 -- > ${12.125?string('000.00')}
            12.135 -- > ${12.135?string('000.00')}
            
        4. 格式化整数， 用0 表示必须三位整数，不够由0 补齐, 一个# 和 多个# 是一样的
            12.1   -- > ${12.1?string('#.00')}
            12.125 -- > ${12.125?string('#.00')}

            12.135 -- > ${12.135?string('#.00')}

        5. 千位分割
            123456789 --> ${123456789?string(',###')}

            123456789 --> ${123456789?string(',####')}

     2.4 数字转换成字符串：
            数字转换成字符串后，就可以直接用字符串的内置函数了
            1234     -- > ${123?string}
            1234    -- > ${123?string[0]}
        <#--  ${123[2]} 报错 -->
   
【4. 字符串型】
    4.1  截取字符串subString(start,end):"hello,wold"
        1. 截取6~end: ${"hello,wold"?substring(6)}
        2. 截取0~5: ${"Hello,World"?substring(0,5)}
    
     4.2  字母大小写转换  
        1. 首个单词的首字母大写: ${"hello world"?cap_first}
        2. 首个单词的首个字母母小写: ${"Hello World"?uncap_first}
        3. 所有单词首字母大写：${"hello world"?capitalize}
        4. 字符串大写： ${"hello,world"?upper_case}
        5. 字符串小写：${"hello,world"?lower_case}
        
     4.3 判断是否以xxx 结尾
        1. ${"hello,world"?ends_with("world")?string}    
        2. <#if "hello,world"?ends_with("world")>
             hello,world 以字符串 world 结尾
           </#if>
           
     4.4 判断是否以xxx 开头
        1. ${"hello,world"?starts_with("hello")?string}    
        2. <#if "hello,world"?starts_with("hello")>
             hello,world 以字符串 hello 开头
           </#if>
           
     4.5  返回字符串长度
        ${"hello,world"?length}
    
     4.6 是否包含子串
        1. 返回为布尔值，布尔值不能直接输出，必须转换为string 
            ${"hello,world"?contains("llo")?string};
        2. <#if "hello,world"?contains("llo")>
                "hello,world" 包含子串 "llo"
           </#if>
           
     4.7 去除首尾空格
        字符串：${"   hello,world   "?trim}
        
     4.8 替换字符串
        ${"hello,world"?replace("o","0")}
    
     4.9 查询字符串第一次出现的索引位置，如果不存在返回0
        ${"hello,world"?index_of("o")}
        ${"hello,world"?index_of("aaa")}
    
     4.10  字符串分割数组
        <#assign citys="beijing,tianjin,shanghai"?split(",")/>
        <#list citys as city>
            ${city_index} --> ${city}

        </#list>

     4.11 输出单个字母
        ${"hello"[0]}
    

【5. sequence】

     1. 获取第一个元素:sequence?first
           array: ${cityArray?first}
           list: ${cityList?first}
           set: ${citySet?first}
           
        2. 获取最后一个元素：sequence?last
           array: ${cityArray?last}
           list: ${cityList?last}
           set: ${citySet?last}
           
        3. 返回sequence 的大小sequence?size
           array: ${cityArray?size}
           list: ${cityList?size}
           set: ${citySet?size}
           
        4. 排序：sequence?sort
           4.1 sequence 元素为基本元素时（能转换为String的元素，非sequence 和  hash 元素）
               array:sort,reverse
                       正    序：<#list cityArray as city>${city},</#list>
                       倒    序：<#list cityArray?reverse as city>${city},</#list>
                       升    序：<#list cityArray?sort as city>${city},</#list>
                       降    序：<#list cityArray?sort?reverse as city>${city},</#list>
               list:sort,reverse
                       正    序：<#list cityList as city>${city},</#list>
                       倒    序：<#list cityList?reverse as city>${city},</#list>
                       升    序：<#list cityList?sort as city>${city},</#list>
                       降    序：<#list cityList?sort?reverse as city>${city},</#list>
               set:sort,reverse
                       正    序：<#list citySet as city>${city},</#list>
                       倒    序：<#list citySet?reverse as city>${city},</#list>
                       升    序：<#list citySet?sort as city>${city},</#list>

                       降    序：<#list citySet?sort?reverse as city>${city},</#list>

            4.2 sequence 元素为JavaBean时
               正    序：
                   <#list department.employees as employee>
                    ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
                </#list>
            逆    序：
                   <#list department.employees?reverse as employee>
                    ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
                </#list>
               按name属性升序：
                   <#list department.employees?sort_by("name") as employee>
                    ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
                </#list>
            按name属性降序:
                <#list department.employees?sort_by("name")?reverse as employee>
                    ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
                </#list>
            
        5. 遍历sequence, 包含索引值 
           array:    <#list cityArray as city>
                       ${city_index} --> ${city}
                   </#list>
           list:    <#list cityList as city>
                       ${city_index} --> ${city}
                   </#list>
           set:    <#list citySet as city>
                       ${city_index} --> ${city}

                   </#list>

        6. 根据索引获取sequence 元素
           array: ${cityArray[0]}
           list: ${cityList[0]}
           set:  ${citySet[0]}

【6. map 类型】

    1. map长度：${cityMap?size};

    2. map的keys:cityMap.keys 返回的是一个sequence,类似于数组，所以不能直接输出，需要遍历
        <#assign mapKeys=cityMap?keys/>
        <#list mapKeys as mapKey>
            ${mapKey}

        </#list>

     3. map的values: cityMap.values 返回的是一个sequence,类似于数组，所以不能直接输出，需要遍历
        <#assign mapValues=cityMap?values/>
        <#list mapValues as mapValue>
            ${mapValue}

        </#list>

     4. 遍历map 元素： map 通过key获取value的方法用[]
        <#list cityMap?keys as  key>
            ${key_index} --> ${key} --> ${cityMap[key]}
        </#list>
    
【7. JavaBean 类型】
    1. 获取属性： ${department.id} --> ${department.name}
     2. 级联属性 ：${department.employees[0].name} --> ${department.employees[0].age} --> ${department.employees[0].sex}
     3. 遍历数组：
            <#list department.employees as employee>
                ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
            </#list>
     4. 排序
        <#list department.employees?sort_by("name") as employee>
            ${employee_index} --> ${employee.name} --> ${employee.age}  --> ${employee.sex}
        </#list>

       

  三、测试用例

     【1. ftl 文件】 将第二部分copy 一下，就是模板文件

     【2.测试用例】

1. package org.zgf.learn.freemarker;  
2.   
3. import java.io.File;  
4. import java.io.OutputStreamWriter;  
5. import java.io.Writer;  
6. import java.util.ArrayList;  
7. import java.util.Arrays;  
8. import java.util.Date;  
9. import java.util.HashMap;  
10. import java.util.HashSet;  
11. import java.util.List;  
12. import java.util.Map;  
13. import java.util.Set;  
14.   
15. import org.junit.After;  
16. import org.junit.Test;  
17.   
18. import freemarker.template.Configuration;  
19. import freemarker.template.Template;  
20. import freemarker.template.TemplateExceptionHandler;  
21.   
22. /** 
23.  * 测试数据类型  
24.  */  
25. public class Test_02_dataType {  
26.       
27.     private static Configuration cfg;  
28.       
29.     private static final String TEMPLATEFILENAME = "src/test/resources/templates";  
30.       
31.     private static Template dateTmp;  
32.       
33.     private static Map<String,Object> root = new HashMap<>();;  
34.       
35.     static{  
36.         try{  
37.             //初始化参数  
38.             cfg = new Configuration(Configuration.VERSION_2_3_22);  
39.             cfg.setDirectoryForTemplateLoading(new File(TEMPLATEFILENAME));  
40.             cfg.setDefaultEncoding("UTF-8");  
41.             cfg.setTemplateUpdateDelayMilliseconds(0);  
42.             cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);  
43.             dateTmp = cfg.getTemplate("datatype.ftl");  
44.         }catch(Exception ex){  
45.             ex.printStackTrace();  
46.         }  
47.     }  
48.       
49.       
50.     @After  
51.     public void tearDown() throws Exception{  
52.         //输出数据  
53.         Writer out = new OutputStreamWriter(System.out);   
54.         dateTmp.process(root, out);  
55.         out.flush();  
56.         out.close();  
57.           
58.     }  
59.       
60.     @Test  
61.     public void test_1() throws Exception{  
62.         //1. 布尔型  
63.         root.put("b", true);  
64.         //2. 数值型  
65.         root.put("currentDate", new Date());  
66.           
67.         //3. 数组类型  
68.         String[] cityArray = new String[]{"beijing" , "tianjin" , "shanghai"};  
69.         root.put("cityArray", cityArray);  
70.           
71.         //4. list 类型  
72.         List<String> cityList = Arrays.asList(cityArray);  
73.         root.put("cityList",cityList);  
74.           
75.         //5. set 类型  
76.         Set<String> citySet = new HashSet<>(cityList);  
77.         root.put("citySet", citySet);  
78.           
79.         //6. map 类型  
80.         Map<String, String> cityMap= new HashMap<>();  
81.         cityMap.put("BJ", "beijing");  
82.         cityMap.put("TJ", "tianjin");  
83.         cityMap.put("SH", "shanghai");  
84.         root.put("cityMap", cityMap);  
85.           
86.           
87.         //7.JavaBean   
88.         Department department = new Department();  
89.         department.setId(101);  
90.         department.setName("开发部");  
91.           
92.         List<Employee> emps = new ArrayList<>();  
93.         for(int i=0; i<10; i++){  
94.             Employee emp = new Employee("zong_" + i, 20 + i, "man");  
95.             emps.add(emp);  
96.         }  
97.         department.setEmployees(emps);  
98.         root.put("department", department);  
99.           
100.     }  
101.       
102. }  

      【3. 1JavaBean--Department.java】

[java]  view plain  copy

1. public class Department {  
2.   
3.     private Integer id;  
4.   
5.     private String name;  
6.   
7.     private List<Employee> employees;  
8.     
9.         //setter&&getter...  
10. }  

     【3. 2JavaBean--Employee.java】

1. public class Employee {  
2.   
3.     private String name;  
4.   
5.     private int age;  
6.   
7.     private String sex;  
8.  <pre name="code" class="java">        //setter&&getter...  
9. }  

 四 测试结果

1. 二、 数据类型示例  
2. 【1. 布尔型】：  
3.     1. 不能直接输出布尔型的值， 必须转换为string：true  
4.     2. 在if标签中可以直接使用  
5.             b 的值为 true  
6.   
7. 【2. 日期型】  
8.        1. 输出日期：2016-3-4  
9.      2. 只输出时间：17:11:40  
10.     3. 输出日期时间：2016-3-4 17:11:40  
11.     4. 格式化日期： 2016-03-04 17:11:40:580  
12.   
13.   
14. 【3. 数值型】：  
15.     2.1 Freemarker 中预定义了三种数字格式，货币，百分比，数字，默认为数字格式  
16.         货币：：￥0.30  
17.         百分比：30%  
18.         数字（默认）：0.3  
19.       
20.     2.2 取整  
21.         1. 向上取整  
22.             3.4     --> 4  
23.   
24.             3.5     --> 4  
25.   
26.   
27.         2. 向下取整  
28.             3.4     --> 3  
29.   
30.             3.5     --> 3  
31.   
32.   
33.         3. 四舍五入  
34.             3.4     --> 3  
35.   
36.             3.5     --> 4  
37.   
38.   
39.     2.3 数字格式化， 使用0 表示不够 由0 补齐， 用# 表示不够不补齐  
40.         1. 保留两位小数: 必须两位，不够补0, 当前一位为偶数时，五舍六入， 当前一位为基数时，四舍五入  
41.             0.135   -- > .14  
42.             0.125   -- > .12  
43.             0.1     -- > .10  
44.               
45.         2. 保留两位小数: 最多两位，不够不补0, 当前一位为偶数时，五舍六入， 当前一位为基数时，四舍五入  
46.             0.135   -- > 0.14  
47.             0.125   -- > 0.12  
48.             0.1     -- > 0.1  
49.               
50.         3. 格式化整数， 用0 表示必须三位整数，不够由0 补齐  
51.             12.1   -- > 012.10  
52.             12.125 -- > 012.12  
53.             12.135 -- > 012.14  
54.               
55.         4. 格式化整数， 用0 表示必须三位整数，不够由0 补齐, 一个# 和 多个# 是一样的  
56.             12.1   -- > 12.10  
57.             12.125 -- > 12.12  
58.   
59.             12.135 -- > 12.14  
60.   
61.   
62.         5. 千位分割  
63.             123456789 --> 123,456,789  
64.   
65.             123456789 --> 1,2345,6789  
66.   
67.   
68.     2.4 数字转换成字符串：  
69.             数字转换成字符串后，就可以直接用字符串的内置函数了  
70.             1234     -- > 123  
71.             1234    -- > 1  
72.     
73. 【4. 字符串型】  
74.     4.1  截取字符串subString(start,end):"hello,wold"  
75.         1. 截取6~end: wold  
76.         2. 截取0~5: Hello  
77.       
78.     4.2  字母大小写转换  
79.         1. 首个单词的首字母大写: Hello world  
80.         2. 首个单词的首个字母母小写: hello World  
81.         3. 所有单词首字母大写：Hello World  
82.         4. 字符串大写： HELLO,WORLD  
83.         5. 字符串小写：hello,world  
84.           
85.     4.3 判断是否以xxx 结尾  
86.         1. true      
87.         2.   
88.              hello,world 以字符串 world 结尾  
89.              
90.     4.4 判断是否以xxx 开头  
91.         1. true      
92.         2.   
93.              hello,world 以字符串 hello 开头  
94.              
95.     4.5  返回字符串长度  
96.         11  
97.       
98.     4.6 是否包含子串  
99.         1. 返回为布尔值，布尔值不能直接输出，必须转换为string  
100.             true;  
101.         2.   
102.                 "hello,world" 包含子串 "llo"  
103.              
104.     4.7 去除首尾空格  
105.         字符串：hello,world  
106.           
107.     4.8 替换字符串  
108.         hell0,w0rld  
109.       
110.     4.9 查询字符串第一次出现的索引位置，如果不存在返回0  
111.         4  
112.         -1  
113.       
114.     4.10  字符串分割数组  
115.             0 --> beijing  
116.   
117.             1 --> tianjin  
118.   
119.             2 --> shanghai  
120.   
121.   
122.   
123.     4.11 输出单个字母  
124.         h  
125.       
126.   
127. 【5. sequence】  
128.     1. 获取第一个元素:sequence?first  
129.            array: beijing  
130.            list: beijing  
131.            set: tianjin  
132.             
133.        2. 获取最后一个元素：sequence?last  
134.            array: shanghai  
135.            list: shanghai  
136.            set: shanghai  
137.              
138.        3. 返回sequence 的大小sequence?size  
139.            array: 3  
140.            list: 3  
141.            set: 3  
142.              
143.        4. 排序：sequence?sort  
144.            4.1 sequence 元素为基本元素时（能转换为String的元素，非sequence 和  hash 元素）  
145.                array:sort,reverse  
146.                        正    序：beijing,tianjin,shanghai,  
147.                        倒    序：shanghai,tianjin,beijing,  
148.                        升    序：beijing,shanghai,tianjin,  
149.                        降    序：tianjin,shanghai,beijing,  
150.                list:sort,reverse  
151.                        正    序：beijing,tianjin,shanghai,  
152.                        倒    序：shanghai,tianjin,beijing,  
153.                        升    序：beijing,shanghai,tianjin,  
154.                        降    序：tianjin,shanghai,beijing,  
155.                set:sort,reverse  
156.                        正    序：tianjin,beijing,shanghai,  
157.                        倒    序：shanghai,beijing,tianjin,  
158.                        升    序：beijing,shanghai,tianjin,  
159.   
160.                        降    序：tianjin,shanghai,beijing,  
161.   
162.   
163.            4.2 sequence 元素为JavaBean时  
164.                正    序：  
165.                     0 --> zong_0 --> 20  --> man  
166.                     1 --> zong_1 --> 21  --> man  
167.                     2 --> zong_2 --> 22  --> man  
168.                     3 --> zong_3 --> 23  --> man  
169.                     4 --> zong_4 --> 24  --> man  
170.                     5 --> zong_5 --> 25  --> man  
171.                     6 --> zong_6 --> 26  --> man  
172.                     7 --> zong_7 --> 27  --> man  
173.                     8 --> zong_8 --> 28  --> man  
174.                     9 --> zong_9 --> 29  --> man  
175.             逆    序：  
176.                     0 --> zong_9 --> 29  --> man  
177.                     1 --> zong_8 --> 28  --> man  
178.                     2 --> zong_7 --> 27  --> man  
179.                     3 --> zong_6 --> 26  --> man  
180.                     4 --> zong_5 --> 25  --> man  
181.                     5 --> zong_4 --> 24  --> man  
182.                     6 --> zong_3 --> 23  --> man  
183.                     7 --> zong_2 --> 22  --> man  
184.                     8 --> zong_1 --> 21  --> man  
185.                     9 --> zong_0 --> 20  --> man  
186.                按name属性升序：  
187.                     0 --> zong_0 --> 20  --> man  
188.                     1 --> zong_1 --> 21  --> man  
189.                     2 --> zong_2 --> 22  --> man  
190.                     3 --> zong_3 --> 23  --> man  
191.                     4 --> zong_4 --> 24  --> man  
192.                     5 --> zong_5 --> 25  --> man  
193.                     6 --> zong_6 --> 26  --> man  
194.                     7 --> zong_7 --> 27  --> man  
195.                     8 --> zong_8 --> 28  --> man  
196.                     9 --> zong_9 --> 29  --> man  
197.             按name属性降序:  
198.                     0 --> zong_9 --> 29  --> man  
199.                     1 --> zong_8 --> 28  --> man  
200.                     2 --> zong_7 --> 27  --> man  
201.                     3 --> zong_6 --> 26  --> man  
202.                     4 --> zong_5 --> 25  --> man  
203.                     5 --> zong_4 --> 24  --> man  
204.                     6 --> zong_3 --> 23  --> man  
205.                     7 --> zong_2 --> 22  --> man  
206.                     8 --> zong_1 --> 21  --> man  
207.                     9 --> zong_0 --> 20  --> man  
208.              
209.        5. 遍历sequence, 包含索引值  
210.            array:      
211.                        0 --> beijing  
212.   
213.                        1 --> tianjin  
214.   
215.                        2 --> shanghai  
216.            list:      
217.                        0 --> beijing  
218.   
219.                        1 --> tianjin  
220.   
221.                        2 --> shanghai  
222.            set:      
223.                        0 --> tianjin  
224.   
225.   
226.                        1 --> beijing  
227.   
228.   
229.                        2 --> shanghai  
230.   
231.   
232.   
233.        6. 根据索引获取sequence 元素  
234.            array: beijing  
235.            list: beijing  
236.            set:  tianjin  
237.   
238. 【6. map 类型】  
239.   
240.     1. map长度：3;  
241.   
242.   
243.     2. map的keys:cityMap.keys 返回的是一个sequence,类似于数组，所以不能直接输出，需要遍历  
244.             SH  
245.   
246.             TJ  
247.   
248.             BJ  
249.   
250.   
251.   
252.     3. map的values: cityMap.values 返回的是一个sequence,类似于数组，所以不能直接输出，需要遍历  
253.             shanghai  
254.   
255.             tianjin  
256.   
257.             beijing  
258.   
259.   
260.   
261.     4. 遍历map 元素： map 通过key获取value的方法用[]  
262.             0 --> SH --> shanghai  
263.             1 --> TJ --> tianjin  
264.             2 --> BJ --> beijing  
265.       
266. 【7. JavaBean 类型】  
267.     1. 获取属性：101 --> 开发部  
268.     2. 级联属性：zong_0 --> 20 --> man  
269.     3. 遍历数组：  
270.                 0 --> zong_0 --> 20  --> man  
271.                 1 --> zong_1 --> 21  --> man  
272.                 2 --> zong_2 --> 22  --> man  
273.                 3 --> zong_3 --> 23  --> man  
274.                 4 --> zong_4 --> 24  --> man  
275.                 5 --> zong_5 --> 25  --> man  
276.                 6 --> zong_6 --> 26  --> man  
277.                 7 --> zong_7 --> 27  --> man  
278.                 8 --> zong_8 --> 28  --> man  
279.                 9 --> zong_9 --> 29  --> man  
280.     4. 排序  
281.             0 --> zong_0 --> 20  --> man  
282.             1 --> zong_1 --> 21  --> man  
283.             2 --> zong_2 --> 22  --> man  
284.             3 --> zong_3 --> 23  --> man  
285.             4 --> zong_4 --> 24  --> man  
286.             5 --> zong_5 --> 25  --> man  
287.             6 --> zong_6 --> 26  --> man  
288.             7 --> zong_7 --> 27  --> man  
289.             8 --> zong_8 --> 28  --> man  
290.             9 --> zong_9 --> 29  --> man