(二)Freemarker 基本数据类型

2024-06-12 08:48

本文主要是介绍(二)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.测试用例】

[java]  view plain copy
  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】

[java]  view plain copy
  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. }  

 

 四 测试结果

[html]  view plain copy
  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  

这篇关于(二)Freemarker 基本数据类型的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1053747

相关文章

基本知识点

1、c++的输入加上ios::sync_with_stdio(false);  等价于 c的输入,读取速度会加快(但是在字符串的题里面和容易出现问题) 2、lower_bound()和upper_bound() iterator lower_bound( const key_type &key ): 返回一个迭代器,指向键值>= key的第一个元素。 iterator upper_bou

【IPV6从入门到起飞】5-1 IPV6+Home Assistant(搭建基本环境)

【IPV6从入门到起飞】5-1 IPV6+Home Assistant #搭建基本环境 1 背景2 docker下载 hass3 创建容器4 浏览器访问 hass5 手机APP远程访问hass6 更多玩法 1 背景 既然电脑可以IPV6入站,手机流量可以访问IPV6网络的服务,为什么不在电脑搭建Home Assistant(hass),来控制你的设备呢?@智能家居 @万物互联

C 语言的基本数据类型

C 语言的基本数据类型 注:本文面向 C 语言初学者,如果你是熟手,那就不用看了。 有人问我,char、short、int、long、float、double 等这些关键字到底是什么意思,如果说他们是数据类型的话,那么为啥有这么多数据类型呢? 如果写了一句: int a; 那么执行的时候在内存中会有什么变化呢? 橡皮泥大家都玩过吧,一般你买橡皮泥的时候,店家会赠送一些模板。 上

FreeRTOS-基本介绍和移植STM32

FreeRTOS-基本介绍和STM32移植 一、裸机开发和操作系统开发介绍二、任务调度和任务状态介绍2.1 任务调度2.1.1 抢占式调度2.1.2 时间片调度 2.2 任务状态 三、FreeRTOS源码和移植STM323.1 FreeRTOS源码3.2 FreeRTOS移植STM323.2.1 代码移植3.2.2 时钟中断配置 一、裸机开发和操作系统开发介绍 裸机:前后台系

Java 多线程的基本方式

Java 多线程的基本方式 基础实现两种方式: 通过实现Callable 接口方式(可得到返回值):

Java基础回顾系列-第一天-基本语法

基本语法 Java基础回顾系列-第一天-基本语法基础常识人机交互方式常用的DOS命令什么是计算机语言(编程语言) Java语言简介Java程序运行机制Java虚拟机(Java Virtual Machine)垃圾收集机制(Garbage Collection) Java语言的特点面向对象健壮性跨平台性 编写第一个Java程序什么是JDK, JRE下载及安装 JDK配置环境变量 pathHe

C语言程序设计(数据类型、运算符与表达式)

一、C的数据类型 C语言提供的数据类型: 二、常量和变量 2.1常量和符号常量 在程序运行过程中,其值不能被改变的量称为常量。 常量区分为不同的类型: 程序中用#define(预处理器指令)命令行定义变量将代表常量,用一个标识符代表一个常量,称为符合常量。 2.2变量 变量代表内存中具有特定属性的一个存储单元,用来存放数据,在程序运行期间,这些值是可以 改变的。 变

Gradle的基本使用

新建一个项目后,在项目文件夹下创建build.gradle文件,并加入内容:       apply plugin: 'eclipse'。    然后在终端运行gradle eclipse即可构建eclipse IDE的开发环境。    gradle默认值:gradle有些目录是有默认值存在,建议项目的配置,承袭了maven的风格,如:         java的源码目录:src/mai

QML入门之基本元素

元素分为可视元素与非可视元素,可能元素例如Rectangle、Button等。非可视元素如Timer(定时器)、MouseArea(鼠标区域)等。非可视元素一般用于操作可视元素。 基础元素 Item Item(基础元素对象)是所有可视元素的基础对象,它们都继承自Item。可是元素存在以下共有属性。 Group(分组)Properties(属性)Geometry(几何属性)x

2021-8-14 react笔记-2 创建组件 基本用法

1、目录解析 public中的index.html为入口文件 src目录中文件很乱,先整理文件夹。 新建components 放组件 新建assets放资源   ->/images      ->/css 把乱的文件放进去  修改App.js 根组件和index.js入口文件中的引入路径 2、新建组件 在components文件夹中新建[Name].js文件 //组件名首字母大写