chapter.java.type.xml

<?xml version="1.0" encoding="UTF-8"?>
<chapter id="index"><?dbhtml dir="type" ?>
	<title>数据类型</title>
	<para>数据类型的最大值和最小值。</para>
	<screen>
	<![CDATA[

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）
最大值：Integer.MAX_VALUE= 2147483647  （2的31次方-1）

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768 （-2的15此方）
最大值：Short.MAX_VALUE=32767 （2的15次方-1）

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）
最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方）
最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方）
最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）	
	]]>
	</screen>
	<section id="var">
		<title>var 本地变量类型推断</title>
		<programlisting>
		<![CDATA[
var javastack = "javastack";
就等于：
String javastack = "javastack";		
		]]>
		</programlisting>
	</section>
	<section id="integer">
		<title>Integer 整形</title>
		<section>
			<title>字符串转整数</title>
			<programlisting>
			<![CDATA[
Integer x =Integer.valueOf("1024");
			]]>
			</programlisting>
		</section>
		<section>
			<title>进制转换</title>
			<programlisting>
			<![CDATA[
十进制转成十六进制：   
  
Integer.toHexString(int i)   
  
十进制转成八进制   
  
Integer.toOctalString(int i)   
  
十进制转成二进制   
  
Integer.toBinaryString(int i)   
  
十六进制转成十进制   
  
Integer.valueOf("FFFF",16).toString()   
  
八进制转成十进制   
  
Integer.valueOf("876",8).toString()   
  
二进制转十进制   
  
Integer.valueOf("0101",2).toString()   
  
  
  
有什么方法可以直接将2,8,16进制直接转换为10进制的吗?   
  
java.lang.Integer类   
  
parseInt(String s, int radix)   
  
使用第二个参数指定的基数，将字符串参数解析为有符号的整数。   
  
examples from jdk:   
  
parseInt("0", 10) returns 0   
  
parseInt("473", 10) returns 473   
  
parseInt("-0", 10) returns 0   
  
parseInt("-FF", 16) returns -255   
  
parseInt("1100110", 2) returns 102   
  
parseInt("2147483647", 10) returns 2147483647   
  
parseInt("-2147483648", 10) returns -2147483648   
  
parseInt("2147483648", 10) throws a NumberFormatException   
  
parseInt("99",throws a NumberFormatException   
  
parseInt("Kona", 10) throws a NumberFormatException   
  
parseInt("Kona", 27) returns 411787    			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
int i=100;   

String binStr=Integer.toBinaryString(i);   
String otcStr=Integer.toOctalString(i);   
String hexStr=Integer.toHexString(i);   
System.out.println(binStr);   
			]]>
			</programlisting>
			<programlisting>
		<![CDATA[
Integer factor = Integer.valueOf(args[0]);   
  
String s;   

  
s = String.format("%d", factor);     
System.out.println(s);   
  
s = String.format("%x", factor);   
System.out.println(s);   
  
s = String.format("%o", factor);   
System.out.println(s);   
  
其他方法：   
  
Integer.toHexString(你的10进制数);   
  
例如   
  
String temp = Integer.toHexString(75);   
  
输出temp就为 4b
		]]>
			</programlisting>
		</section>

		<section>
			<title>前面补零</title>
			<programlisting>
			<![CDATA[
public static String frontCompWithZore(int sourceDate,int formatLength) {  
  
　　String newString = String.format("%0"+formatLength+"d", sourceDate);   
　　return newString;  
}  			
			]]>
			</programlisting>

		</section>
		<section id="NumberFormat">
			<title>NumberFormat 数字格式化</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.text.NumberFormat;
import java.util.Locale;

public class Test {
    
    public static void main(String[] args) {

        NumberFormat fmt = NumberFormat.getCompactNumberInstance(Locale.ENGLISH, NumberFormat.Style.SHORT);
        System.out.println(fmt.format(1000));
        System.out.println(fmt.format(100000));
        System.out.println(fmt.format(1000000));

        fmt = NumberFormat.getCompactNumberInstance(Locale.ENGLISH, NumberFormat.Style.LONG);
        System.out.println(fmt.format(1000));
        System.out.println(fmt.format(100000));
        System.out.println(fmt.format(1000000));

        fmt = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.SHORT);
        System.out.println(fmt.format(1000));
        System.out.println(fmt.format(100000));
        System.out.println(fmt.format(1000000));

        fmt = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.LONG);
        System.out.println(fmt.format(1000));
        System.out.println(fmt.format(100000));
        System.out.println(fmt.format(1000000));
        
    }
}
			]]>
			</programlisting>
			<screen>
			<![CDATA[
1K
100K
1M
1 thousand
100 thousand
1 million
1,000
10万
100万
1,000
10万
100万
			]]>
			</screen>
		</section>
		<section>
			<title>从字符串中提取数字</title>
			<programlisting>
			<![CDATA[
import java.util.stream.Collectors;

public class ExtractNumbersStream {
    public static void main(String[] args) {
        String input = "hello123world456";
        // 将字符串转换为字符流，筛选数字并拼接
        String result = input.chars()
                            .filter(Character::isDigit)
                            .mapToObj(c -> String.valueOf((char) c))
                            .collect(Collectors.joining());
        
        System.out.println("提取的数字: " + result); // 输出: 123456
    }
}			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="string">
		<title>String 字符串</title>
		<para>Java 11 增加了一系列的字符串处理方法，如以下所示。</para>
		<screen>
		<![CDATA[
// 判断字符串是否为空白
" ".isBlank(); // true
// 去除首尾空格
" Javastack ".strip(); // "Javastack"
// 去除尾部空格
" Javastack ".stripTrailing(); // " Javastack"
// 去除首部空格
" Javastack ".stripLeading(); // "Javastack "
		]]>
		</screen>
		<section id="string.indexOf">
			<title>查找字符重现的位置</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

public class Test {

	public static void main(String[] args) {

		String string = new String("http://www.netkiller.cn");

		System.out.println("查找字符 . 第一次出现的位置: " + string.indexOf('.'));
		System.out.println("从第15个字符位置查找字符 . 出现的位置:" + string.indexOf('.', 15));
	}
}	
			]]>
			</programlisting>
		</section>
		<section id="string.line">
			<title>行数统计</title>
			<screen>
			<![CDATA[
"A\nB\nC".lines().count(); // 3			
			]]>
			</screen>
		</section>
		<section id="string.repeat">
			<title>复制字符串</title>
			<programlisting>
			<![CDATA[
"Java".repeat(3);// "JavaJavaJava"			
			]]>
			</programlisting>
		</section>
		<section id="string.random">
			<title>随机字符串</title>
			<programlisting>
			<![CDATA[
	public String randomString(String chars, int length) {
		Random rand = new Random();
		StringBuilder buf = new StringBuilder();
		for (int i = 0; i < length; i++) {
			buf.append(chars.charAt(rand.nextInt(chars.length())));
		}
		return buf.toString();
	}
	
	/**
     * 获取4位随机验证码
     * @return
     */
    public static String getValidationCode(){
        return String.valueOf((new Random().nextInt(8999) + 1000));
    }

    /**
     * 获取6位随机验证码
     * @return
     */
    public static String getValidationCode(){
        return String.valueOf((new Random().nextInt(899999) + 100000));
    }	
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
import java.util.Random;

public class RandomNumberGenerator {
    public static void main(String[] args) {
        Random random = new Random();
        // 生成1000到9999之间的随机整数
        int randomNumber = random.nextInt(9000) + 1000;
        System.out.println("生成的4位随机数字是：" + randomNumber);
    }
}

public class RandomNumberGenerator {
    public static void main(String[] args) {
        // 生成1000到9999之间的随机整数
        int randomNumber = (int) (Math.random() * 9000) + 1000;
        System.out.println("生成的4位随机数字是：" + randomNumber);
    }
}

import java.security.SecureRandom;

public class RandomNumberGenerator {
    public static void main(String[] args) {
        SecureRandom secureRandom = new SecureRandom();
        // 生成1000到9999之间的安全随机整数
        int randomNumber = secureRandom.nextInt(9000) + 1000;
        System.out.println("生成的4位安全随机数字是：" + randomNumber);
    }
}

import java.util.Random;
// 说明：此方法会生成一个0-9999的随机整数，然后利用String.format("%04d", number)将其格式化为长度为 4 的字符串，若数字不足 4 位，会在前面补0，例如0001、0123等。
public class RandomNumberGenerator {
    public static void main(String[] args) {
        Random random = new Random();
        // 生成0到9999之间的随机整数
        int randomNumber = random.nextInt(10000);
        // 格式化为4位字符串，不足4位时在前面补0
        String formattedNumber = String.format("%04d", randomNumber);
        System.out.println("生成的4位随机数字字符串是：" + formattedNumber);
    }
}			
			]]>
			</programlisting>
		</section>

		<section id="string.replace">
			<title>字符串替换处理</title>
			<section>
				<title>替换转意字符</title>
				<programlisting>
			<![CDATA[
public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("2010-09-11T20:00:30".replace("T", " "));
	}
}
			
			]]>
				</programlisting>
				<programlisting>
			<![CDATA[
{"status":0,"message":"","bankcode":"ABOC;IBC;CCTB;ICBC"}
转换后
{\"status\":0,\"message\":\"\",\"bankcode\":\"ABOC;IBC;CCTB;ICBC\"}			
			]]>
				</programlisting>
				<programlisting>
			<![CDATA[
package test;

public class str {

	public static void main(String[] args) {
		String jsonString = "{\"status\":0,\"message\":\"\",\"bankcode\":\"ABOC;IBC;CCTB;ICBC\"}";
		System.out.println(jsonString);
		System.out.println(jsonString.replace("\"", "\\\""));
	}

}
			]]>
				</programlisting>
			</section>
			<section id="replaceAll">
				<title>replaceAll</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.test;

public class Test {


    public static void main(String[] args) throws InterruptedException {

        System.out.println("我是小云，你是谁小策".replaceAll("小云|小策", ""));

    }
    
}				
				]]>
				</programlisting>
			</section>
			<section>
				<title>替换控制字符</title>
				<programlisting>
				<![CDATA[
str.replaceAll("\\p{Cntrl}", "");				
				]]>
				</programlisting>
			</section>
			<section>
				<title>正则表达式查找与替换</title>
				<para>查找特定字符并替换为找到的内容</para>
				<programlisting>
				<![CDATA[
package cn.netkiller.type;

public class ragexTest {

	public ragexTest() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		String str = "<html>Netkiller</html>";
		String regex = "<html>|</html>";
		//运行结果返回 Netkiller
		System.out.println(str.replaceAll(regex, ""));
		
		// 运行结果返回 Neo
		System.out.println("CN/NETKILLER/WWW/Neo_Chen".replaceAll(".*/(.+)_Chen", "$1"));
	}
}
				]]>
				</programlisting>
			</section>
			<section>
				<title>利用正则快速转换时间格式</title>
				<programlisting>
				<![CDATA[
// 20200303 => 2020-03-03
date = date.replace(/(.{4})/, "$1-");
date = date.replace(/(.{7})/, "$1-");				
				]]>
				</programlisting>
				<para>用正则处理 Alertmanager 日期 rfc3339 格式
					2021-08-23T01:30:30.2206015+08:00，Alertmanager 日期格式中有7位数的毫秒，使用
					SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX") 无法正常读取。
				</para>
				<programlisting>
				<![CDATA[
package cn.netkiller.alertmanager;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.TimeZone;

public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) throws ParseException {
		// TODO Auto-generated method stub
		String rfc3339 = "2021-08-23T01:30:30.2206015+08:00";
		rfc3339 = rfc3339.replaceAll(".[0-9]{7}", "");

		System.out.println(rfc3339);
		System.out.println(rfc3339.replaceAll("([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})+(.*)", "$1年$2月$3日 $4时$5分$6秒"));
		System.out.println(rfc3339.replaceAll("([0-9]{4}-[0-9]{2}-[0-9]{2})T([0-9]{2}:[0-9]{2}:[0-9]{2})+(.+)", "日期：$1 时间：$2"));

		// SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
		simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8"));
		System.out.println(simpleDateFormat.parse(rfc3339).toString());

	}

}				
				]]>
				</programlisting>
				<screen>
				<![CDATA[
2021-08-23T01:30:30+08:00
2021年08月23日 01时30分30秒
日期：2021-08-23 时间：01:30:30
Mon Aug 23 01:30:30 CST 2021				
				]]>
				</screen>
			</section>

			<section id="string.replaceAll">
				<title>replaceAll</title>
				<para>替换一组字符串</para>
				<programlisting>
				<![CDATA[
        String str1 = "广东省，福建省，北京市，海淀区，河北省，上海市";
        str1 = str1.replaceAll("(省|市|区)", "");
        System.out.println("替换多个中文：" + str1);
        
        替换多个中文：广东，福建，北京，海淀，河北，上海				
				]]>
				</programlisting>
				<para>替换 Ascii</para>
				<programlisting>
			<![CDATA[
		String string = "佛山市123南海区ABC精密abc机械有限公司􁵪􁻠􁴹􄲀􀞜􀨨,";

		String clean = string.replaceAll("\\P{Print}", "");
		System.out.println(clean);			
			]]>
				</programlisting>
			</section>
			<section id="string.unicode">
				<title>字符串处理，删除中文以外的字符</title>
				<para>Unicode 码表 https://www.ssec.wisc.edu/~tomw/java/unicode.html
				</para>
				<programlisting>
			<![CDATA[
	String string = "2017-12-18 netkiller http://www.netkiller.cn -  网站正常";
	System.out.println(string.replaceAll("[^\u4e00-\u9fa5]", ""));			
			]]>
				</programlisting>
			</section>
			<section id="string.regex">
				<title>取出字符串中的中文字符</title>
				<para>Unicode 码表 https://www.ssec.wisc.edu/~tomw/java/unicode.html
				</para>
				<programlisting>
			<![CDATA[
		String string = "2017-12-18 netkiller http://www.netkiller.cn -  网站正常";
		String regex = "[\u4e00-\u9fa5]";
		System.out.println(string.replaceAll(regex, ""));			
			]]>
				</programlisting>
			</section>
			<section id="替换行首标点符号">
				<title>替换行首的标点符号</title>
				<programlisting>
				<![CDATA[
    public static String cleansing(String text) {

        String replacement = "";
        Pattern pattern = Pattern.compile("^[\\p{P}]", Pattern.MULTILINE);
        Matcher matcher = pattern.matcher(text);
        String result = matcher.replaceAll(replacement);
        return result;
    }				
				]]>
				</programlisting>
			</section>	
			<section>
				<title>查找替换末尾最后一个字符</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.test;

import java.util.List;

public class Test {


    public Test() {
    }

    public static String replaceEnd(String string) {
        
        char c = string.charAt(string.length() - 1);
        if (List.of('，', ',', '、').contains(c)) {
            string = string.substring(0, string.length() - 1);
        }

        return string;
    }

    public static void main(String[] args) throws Exception {
        List.of("你好！", "你好,中国，", "Hello,", "Hello world!", "你在干啥么吗？没看到吗？", "这里真好").forEach(s -> {
            System.out.println(replaceEnd(s));
        });

    }
    
}
				]]>
				</programlisting>
				<screen>
				<![CDATA[
你好！
你好,中国
Hello
Hello world!
你在干啥么吗？没看到吗？
这里真好
				]]>
				</screen>
			</section>
			<section>
				<title>数字开头的字符串前面加回车符</title>
				<programlisting>
				<![CDATA[
        String original = "1: neo 2: netkiller 3: other";
        System.out.println(original.replaceAll("\n", "").replaceAll("(?=^\\d:|\\d:)", "\n"));
				]]>
				</programlisting>
				<screen>
				<![CDATA[
1: neo 
2: netkiller 
3: other
				]]>
				</screen>
			</section>
		</section>
		<section id="substring">
			<title>substring</title>
			<programlisting>
			<![CDATA[
例如：
String str = "helloword!!!";

System.out.println(str.substring(1,4));

System.out.println(str.substring(3,5));

System.out.println(str.substring(0,4));

将得到结果为：

ell

lo 

hell
			]]>
			</programlisting>
		</section>
		<section id="string2tempstamp">
			<title>string to timestamp</title>
			<para>Timestamp转化为String:</para>
			<programlisting>
				SimpleDateFormat df = new
				SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //定义格式，不显示毫秒
				Timestamp now =
				new Timestamp(System.currentTimeMillis());
				//获取系统当前时间
				String str =
				df.format(now);
			</programlisting>
			<para>String转化为Timestamp:</para>
			<programlisting>
				SimpleDateFormat df = new
				SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				String time = df.format(new
				Date());
				Timestamp ts = Timestamp.valueOf(time);
			</programlisting>
		</section>
		<section id="String.strip">
			<title>String.strip</title>
			<para>java11对String类新增了strip，stripLeading以及stripTrailing方法，除了strip相关的方法还新增了isBlank、lines、repeat(int)等方法
			</para>
			<screen>
			<![CDATA[
	@Test
    public void testStrip(){
        String text = "  \u2000a  b  ";
        Assert.assertEquals("a  b",text.strip());
        Assert.assertEquals("\u2000a  b",text.trim());
        Assert.assertEquals("a  b  ",text.stripLeading());
        Assert.assertEquals("  \u2000a  b",text.stripTrailing());
    }
			]]>
			</screen>
		</section>
		<section id="string.block">
			<title>文本块</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.kubernetes;

public class Test {

	public Test() {
	}

	public static void main(String[] args) {

		String json = """
				{
				"name" : "netkiller",
				"home" : "https://www.netkiller.cn/"
				}
				""";
		System.out.println(json);
	}

}			
			]]>
			</programlisting>
		</section>
		<section id="string.split">
			<title>分割字符串</title>

			<screen>
			<![CDATA[
        String[] string = topic.split("/");
        Log.d("Service", string.length + "");
        for (String str: string) {
            Log.d("Service", str);
        }		
        
		String str2 = new String("www.netkiller.cn");
        for (String retval: str2.split("\\.", 3)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str3 = new String("acount=? and uu =? or n=?");
        for (String retval: str3.split("and|or")){
            System.out.println(retval);
        }                
			]]>
			</screen>
		</section>
		<section id="String.format">
			<title>String.format 字符串格式化</title>
			<section>
				<title>前补零</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.test;

import lombok.Data;

import java.io.IOException;

@Data
public class Test {
    public static void main(String[] args) throws IOException {
        System.out.printf("%02d%n", 1);
        System.out.printf("%04d%n", 90);

        System.out.println(String.format("%02d", 1));
        System.out.println(String.format("%04d", 90));
    }
}			
				]]>
				</programlisting>
				<screen>
				<![CDATA[
01
0090
01
0090				
				]]>
				</screen>
			</section>
			<section>
				<title>前补零</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.test;

import lombok.Data;

import java.io.IOException;
import java.text.DecimalFormat;

@Data
public class Test {
    public static void main(String[] args) throws IOException {
        int test = 520;

        String paddedStr = String.format("%-6s", test).replace(' ', '0');
        System.out.println("后补零：" + paddedStr);
    }
}			
				]]>
				</programlisting>
				<screen>
				<![CDATA[
后补零：520000			
				]]>
				</screen>
			</section>
		</section>
		<section id="java.text.DecimalFormat">
			<title>DecimalFormat 文本格式化</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import lombok.Data;

import java.io.IOException;
import java.text.DecimalFormat;

@Data
public class Test {
    public static void main(String[] args) throws IOException {
        int test = 520;
        System.out.println("================  前补零   =================");
        DecimalFormat decimalFormat = new DecimalFormat("000000");
        String before = decimalFormat.format(test);
        System.out.println("前补零：" + before);

        DecimalFormat decimalFormat1 = new DecimalFormat("0.000");
        System.out.println("================  小数点后补零   =================");
        String after = decimalFormat1.format(test);
        System.out.println("后补零：" + after);
    }
}			
				]]>
			</programlisting>
			<screen>
				<![CDATA[
================  前补零   =================
前补零：000520
================  小数点后补零   =================
后补零：520.000
				]]>
			</screen>
		</section>
		<section id="stream().anyMatch()">
			<title>通过 stream() 匹配一组字符串</title>
			<programlisting>
			<![CDATA[
		String str1 = "Hello, World!";
        List<String> str2 = Arrays.asList("World", "Hello");

        boolean contains = str2.stream().anyMatch(str1::contains);
        System.out.println("找到字符串：" + contains);			
			]]>
			</programlisting>
		</section>
		<section>
			<title>字符串输出转译字符串</title>
			<programlisting>
			<![CDATA[
    public static String escapeString(String input) {
        if (input == null) return null;

        return input
                .replace("\\", "\\\\")   // 转义反斜杠
                .replace("\t", "\\t")    // 转义制表符
                .replace("\b", "\\b")    // 转义退格符
                .replace("\n", "\\n")    // 转义换行符
                .replace("\r", "\\r")    // 转义回车符
                .replace("\f", "\\f")    // 转义换页符
                .replace("'", "\\'")     // 转义单引号
                .replace("\"", "\\\"");  // 转义双引号
    }			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
// 使用示例
String original = "Hello\nWorld\t\"Java\"";
String escaped = escapeString(original);
System.out.println(escaped); // 输出: Hello\nWorld\t\"Java\"			
			]]>
			</programlisting>
			
		</section>
		
	</section>
	<section id="long">
		<title>类型转换</title>
		<section>
			<title>Long to String</title>
			<programlisting>
			<![CDATA[
	public class MainClass {

	  public static void main(String[] arg) {
	    long b = 12L;
	    System.out.println(String.valueOf(b));   
	
	  }
	}
			]]>
			</programlisting>
		</section>
	</section>

	<section id="date">
		<title>Date 日期时间</title>
		<para>java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp
			区别
		</para>
		<section id="date.new">
			<title>String to Date</title>
			<programlisting>
		<![CDATA[
package cn.netkiller.java.date;

/**
 * Hello world!
 *
 */
public class App {
	public static void main(String[] args) {
		System.out.println("Hello World!");

		// Get standard date and time
		java.util.Date utilDate = new java.util.Date();
		long javaTime = utilDate.getTime();
		System.out.println("The Java Date is:" + utilDate.toString());

		// Get and display SQL DATE
		java.sql.Date sqlDate = new java.sql.Date(javaTime);
		System.out.println("The SQL DATE is: " + sqlDate.toString());

		// Get and display SQL TIME
		java.sql.Time sqlTime = new java.sql.Time(javaTime);
		System.out.println("The SQL TIME is: " + sqlTime.toString());
		
		// Get and display SQL TIMESTAMP
		java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(javaTime);
		System.out.println("The SQL TIMESTAMP is: " + sqlTimestamp.toString());
	}
}

		]]>
			</programlisting>
			<screen>
		<![CDATA[
The Java Date is:Thu Aug 24 16:51:57 CST 2017
The SQL DATE is: 2017-08-24
The SQL TIME is: 16:51:57
The SQL TIMESTAMP is: 2017-08-24 16:51:57.234		
		]]>
			</screen>
			<programlisting>
			<![CDATA[
        Date currentDate = new Date();
        int month = currentDate.getMonth() + 1;
        System.out.println("当前月份为：" + month);			
			]]>
			</programlisting>
		</section>
		<section id="DateTimeFormatter">
			<title>DateTimeFormatter 格式化日期和时间</title>
			<programlisting>
			<![CDATA[
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
 
public class Main {
    public static void main(String[] args) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.now();
        String formattedDateTime = dateTime.format(formatter);
        System.out.println(formattedDateTime);
    }
}
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("B");
        System.out.println(dtf.format(LocalTime.of(8, 0)));
        System.out.println(dtf.format(LocalTime.of(13, 0)));
        System.out.println(dtf.format(LocalTime.of(20, 0)));
        System.out.println(dtf.format(LocalTime.of(23, 0)));
        System.out.println(dtf.format(LocalTime.of(0, 0)));			
			]]>
			</programlisting>
			<para></para>
			<screen>
			<![CDATA[
上午
下午
晚上
晚上
午夜			
			]]>
			</screen>
			<para>Data 转 LocalDate</para>
			<programlisting>
			<![CDATA[
		Date date = new Date();​
        ​
        // 1. 将Date转换为LocalDate（需指定时区，避免默认时区差异）​
        LocalDate localDate = date.toInstant()​
                                 .atZone(ZoneId.systemDefault()) // 系统默认时区（如Asia/Shanghai）​
                                 .toLocalDate();​
        ​
        // 2. 定义格式化器：YYYY-MM-DD​
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");​
        ​
        // 3. 转换为字符串​
        String dateStr = localDate.format(formatter);			
			]]>
			</programlisting>
		</section>
		<section id="SimpleDateFormat">
			<title>SimpleDateFormat 格式化日期和时间</title>
			<para>字符串转日期</para>
			<programlisting>
			<![CDATA[
        try {

            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            String str = "2018-12-11";
            Date date = df.parse(str);
            System.out.println(date);

        } catch (Exception e) {
            e.printStackTrace();
        }			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
package cn.netkiller.example;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class StringToDate {

	public StringToDate() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = "2008-8-8 8:8:8";

		try {

			Date date = formatter.parse(dateString);
			System.out.println(date);
			System.out.println(formatter.format(date));

		} catch (ParseException e) {
			e.printStackTrace();
		}
	}

}			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[

public static void main(String[] args) {

	DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
	//get current date time with Date()
	Date date = new Date();
	System.out.println(dateFormat.format(date));
	
	//get current date time with Calendar()
	Calendar cal = Calendar.getInstance();
	System.out.println(dateFormat.format(cal.getTime()));

}
			]]>
			</programlisting>
			<para>不规范的 RFC3339 日期</para>
			<programlisting>
			<![CDATA[
		String dt = "2021-08-26T09:17:23.859291804+08:00";
		String rfc3339 = dt.replaceAll("\\.([0-9]+)", "");
		System.out.println(dt);
		System.out.println(rfc3339);
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
		simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8"));
		System.out.println(simpleDateFormat.parse(rfc3339).toLocaleString());			
			]]>
			</programlisting>
			<section>
				<title>compareTo() 比较日志</title>
				<programlisting>
				<![CDATA[
String beginTime = "2015-05-20 13:12:30";
String endTime = "2015-07-15 10:20:12";
 
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
try {
	Date date1 = format.parse(beginTime);
	Date date2 = format.parse(endTime);
	
	int compareTo = date1.compareTo(date2);
	
	System.out.println(compareTo);
	
} catch (ParseException e) {
	e.printStackTrace();
}
				
				]]>
				</programlisting>
			</section>
			<section>
				<title>before() / after()</title>
				<programlisting>
				<![CDATA[
String beginTime = "2015-05-20 13:12:30";
String endTime = "2015-07-15 10:20:12";
 
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
try {
	Date date1 = format.parse(beginTime);
	Date date2 = format.parse(endTime);
	
	boolean before = date1.before(date2);
	
	System.out.println(before);
	
} catch (ParseException e) {
	e.printStackTrace();
}

				]]>
				</programlisting>
			</section>
			<section>
				<title></title>
				<programlisting>
				<![CDATA[
String beginTime = "2015-05-20 13:12:30";
String endTime = "2015-07-15 10:20:12";
 
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
try {
	Date date1 = format.parse(beginTime);
	Date date2 = format.parse(endTime);
	
	long beginMillisecond = date1.getTime();
	long endMillisecond = date2.getTime();
	
	System.out.println(beginMillisecond > endMillisecond);
	
} catch (ParseException e) {
	e.printStackTrace();
}
				]]>
				</programlisting>
			</section>
		</section>
		<section id="Timestamp">
			<title>Timestamp</title>
			<screen>
			<![CDATA[
Timestamp timestamp = new Timestamp(System.currentTimeMillis());

Date date = new Date();
Timestamp timestamp = new Timestamp(date.getTime());
			
			]]>
			</screen>
		</section>
		<section id="TimeZone">
			<title>TimeZone</title>
			<screen>
			<![CDATA[
package cn.netkiller.example;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TimeZone;

public class TimeZoneTest {
	
	public TimeZoneTest() {
		// TODO Auto-generated constructor stub
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		
		TimeZone timeZone = TimeZone.getTimeZone("Asia/Harbin");
		
		Date date = new Date();
		Timestamp timestamp = new Timestamp(date.getTime());
		
		System.out.println(timestamp);
		
		timestamp.setHours(timestamp.getHours()+8);
		System.out.println(timestamp);
		
		simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
		System.out.println(simpleDateFormat.format(date));
		
		simpleDateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Harbin"));
		System.out.println(simpleDateFormat.format(date));
		
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.setTimeZone(timeZone);
		System.out.println(simpleDateFormat.format(calendar.getTime()));
	}

}
			]]>
			</screen>
		</section>

		<section id="date.compare">
			<title>比较两个日期与时间</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.example;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateCompare {

	public DateCompare() {
		// TODO Auto-generated constructor stub
	}

	public void fun1() throws InterruptedException {
		Date d1 = new Date();
		Thread.sleep(5000);
		Date d2 = new Date();
		if (d1.before(d2)) {
			System.out.println(String.format("%s < %s", d1.toString(), d2.toString()));
		} else {
			System.out.println(String.format("%s > %s", d1.toString(), d2.toString()));
		}
		if (d2.after(d1)) {
			System.out.println(String.format("%s > %s", d2.toString(), d1.toString()));
		}

		System.out.println(String.format("%s : %s => %d", d2.toString(), d1.toString(), d1.compareTo(d2)));
		System.out.println(String.format("%s : %s => %d", d1.toString(), d2.toString(), d2.compareTo(d1)));
	}

	public void fun2() throws InterruptedException {

		DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

		Date date1 = new Date();
		Date date2 = new Date();
		String s1 = dateFormat.format(date1);
		String s2 = dateFormat.format(date2);
		System.out.println(String.format("%s : %s => %d", s1, s2, s1.compareTo(s2)));

		date1 = new Date();
		Thread.sleep(5000);
		date2 = new Date();
		s1 = dateFormat.format(date1);
		s2 = dateFormat.format(date2);
		System.out.println(String.format("%s : %s => %d", s1, s2, s1.compareTo(s2)));
		System.out.println(String.format("%s : %s => %d", s2, s1, s2.compareTo(s1)));
		System.out.println();
	}

	public void fun3() throws InterruptedException, ParseException {
		DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		//Date time = formatter.parse("2016-09-27 16:29");
		Date time = formatter.parse("2016-08-09 09:15");
		Date startDate = formatter.parse("2016-08-09 09:15");
		Date endDate = formatter.parse("2016-09-27 16:30");
		
		if (time.before(startDate) || time.after(endDate)) {
			System.out.println("Skip");
		}
	}

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		DateCompare dateCompare = new DateCompare();
		dateCompare.fun1();
		System.out.println();
		dateCompare.fun2();
		System.out.println();
		dateCompare.fun3();
	}

}
			]]>
			</programlisting>
		</section>

		<section id="date.calendar">
			<title>Calendar</title>
			<programlisting>
			<![CDATA[	
		Calendar cal = Calendar.getInstance();
		int year = cal.get(Calendar.YEAR);
		int month = cal.get(Calendar.MONTH )+1;
		
		System.out.println(year + "年 " + month + "月");
			]]>
			</programlisting>
			<section>
				<title>日期加法操作</title>
				<programlisting>
				<![CDATA[
//获取当前日期
Date date = new Date();
 
//创建Calendar实例
Calendar cal = Calendar.getInstance();
cal.setTime(date);   //设置当前时间
cal.add(Calendar.YEAR, 1);  //在当前时间基础上加一年
 
//将时间格式化成yyyy-MM-dd HH:mm:ss的格式
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(format.format(cal.getTime()));
 
 
 
//同理增加一个月和一天的方法：
cal.add(Calendar.MONTH, 1);
cal.add(Calendar.DAY, 1);				
				]]>
				</programlisting>
			</section>
			<section>
				<title>计算起始日期与终止日期之间的月份</title>
				<programlisting>
				<![CDATA[
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");

        Date d1 = new SimpleDateFormat("yyyy-MM").parse("2020-02-01");//定义起始日期
        Date d2 = new SimpleDateFormat("yyyy-MM").parse("2024-03-02");//定义结束日期

        calendar.setTime(d2);
        calendar.add(Calendar.MONTH, 1);
        d2 = calendar.getTime();

        calendar.setTime(d1);//设置日期起始时间

        while (calendar.getTime().before(d2)) {//判断是否到结束日期

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
            String str = sdf.format(calendar.getTime());
            System.out.println(str);//输出日期结果
            calendar.add(Calendar.MONTH, 1);//进行当前日期月份加1
        }				
				]]>
				</programlisting>
				<programlisting>
				<![CDATA[
private List<Date> getMonthRange(String startDate, String endDate) {
        List<Date> monthList = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");

        try {


            Date d1 = new SimpleDateFormat("yyyy-MM").parse(startDate);//定义起始日期
            Date d2 = new SimpleDateFormat("yyyy-MM").parse(endDate);//定义结束日期

            calendar.setTime(d2);
            calendar.add(Calendar.MONTH, 1);
            d2 = calendar.getTime();

            calendar.setTime(d1);//设置日期起始时间

            while (calendar.getTime().before(d2)) {//判断是否到结束日期
                monthList.add(calendar.getTime());
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
//            String str = sdf.format(calendar.getTime());
//            System.out.println(str);//输出日期结果
                calendar.add(Calendar.MONTH, 1);//进行当前日期月份加1
            }
        } catch (ParseException e) {

        }
        return monthList;

    }				
				]]>
				</programlisting>
			</section>
			<section>
				<title>取日期范围</title>
				<programlisting>
				<![CDATA[
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");

        Date d1 = new SimpleDateFormat("yyyy-MM-dd").parse("2024-03-10");//定义起始日期
        Date d2 = new SimpleDateFormat("yyyy-MM-dd").parse("2024-03-20");//定义结束日期

        calendar.setTime(d2);
        calendar.add(Calendar.DATE, 1);
        d2 = calendar.getTime();

        calendar.setTime(d1);//设置日期起始时间

        while (calendar.getTime().before(d2)) {//判断是否到结束日期

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            String str = sdf.format(calendar.getTime());
            System.out.println(str);//输出日期结果
            calendar.add(Calendar.DATE, 1);//进行当前日期月份加1
        }				
				]]>
				</programlisting>
			</section>
		</section>
		<section id="date.today">
			<title>getToday</title>
			<programlisting>
			<![CDATA[
	public Date getToday(String time) {
		final Calendar cal = Calendar.getInstance();
		DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd " + time);
		DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = null;
		try {
			date = fmt.parse(dateFormat.format(cal.getTime()));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	private Date addOneDay(Date date, int day) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.DATE, day);
		return cal.getTime();
	}
			]]>
			</programlisting>
		</section>
		<section id="date.Yesterday">
			<title>Yesterday</title>
			<programlisting>
			<![CDATA[		
package cn.netkiller.date;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Yesterday {

	public Yesterday() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Yesterday yesterday = new Yesterday();
		System.out.println(yesterday.yesterday());
		System.out.println(yesterday.getYesterday("00:00:00"));
		System.out.println(yesterday.getYesterday("23:59:59"));
	}
	private Date yesterday() {
	    final Calendar cal = Calendar.getInstance();
	    cal.add(Calendar.DATE, -1);
	    return cal.getTime();
	}

	private Date getYesterday(String time) {
	        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd "+time);
	        
	        DateFormat fmt =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	        Date date = null;
	        try {
	            date = fmt.parse(dateFormat.format(yesterday()));
	        } catch (ParseException e) {
	            e.printStackTrace();
	        }
	        return date;
	}
}
		
]]>
			</programlisting>
		</section>
		<section id="date.iso8601">
			<title>ISO 8601</title>
			<screen>
			<![CDATA[
ISO 8601扩展格式 YYYY-MM-DDTHH:mm:ss.sssZ
			]]>
			</screen>
		</section>
		<section id="date.LocalDateTime">
			<title>LocalDateTime</title>
			<programlisting>
			<![CDATA[
	LocalDateTime localDateTime = LocalDateTime.of(2016, 1, 1, 13, 55);
	ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.of("Asia/Shanghai"));
	Date date = Date.from(zonedDateTime.toInstant());	
		
	Instant instant = Instant.ofEpochMilli(date.getTime());
    LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
    Instant instant = ldt.toInstant(ZoneOffset.UTC);
    Date date = Date.from(instant);		
				
			]]>
			</programlisting>
			<para>时间比较</para>
			<programlisting>
			<![CDATA[
import java.time.LocalDateTime;

public class LocalDateTimeCompareDemo {
    public static void main(String[] args) {
        // 构建两个 LocalDateTime 实例（方式：of() 或 parse()）
        LocalDateTime time1 = LocalDateTime.of(2025, 11, 4, 10, 30, 0); // 2025-11-04 10:30:00
        LocalDateTime time2 = LocalDateTime.parse("2025-11-04T14:20:00"); // 2025-11-04 14:20:00
        LocalDateTime time3 = LocalDateTime.of(2025, 11, 4, 10, 30, 0); // 与 time1 相等

        // 1. isBefore()：是否在之前
        boolean before = time1.isBefore(time2);
        System.out.println("time1 在 time2 之前？" + before); // true

        // 2. isAfter()：是否在之后
        boolean after = time2.isAfter(time1);
        System.out.println("time2 在 time1 之后？" + after); // true

        // 3. isEqual()：是否相等（精确到纳秒，年月日时分秒纳秒完全一致）
        boolean equal = time1.isEqual(time3);
        System.out.println("time1 与 time3 相等？" + equal); // true

        // 4. compareTo()：比较（返回 int，支持排序）
        int compare1 = time1.compareTo(time2); // time1 < time2 → 返回负数（-1）
        int compare2 = time2.compareTo(time1); // time2 > time1 → 返回正数（1）
        int compare3 = time1.compareTo(time3); // 相等 → 返回 0
        System.out.println("time1.compareTo(time2)：" + compare1); // -1
        System.out.println("time2.compareTo(time1)：" + compare2); // 1
        System.out.println("time1.compareTo(time3)：" + compare3); // 0
    }
}			
			]]>
			</programlisting>
			<para>去一个日期范围</para>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {

        LocalDateTime afterTime = LocalDateTime.now().minusHours(1);
        LocalDateTime beforeTime = LocalDateTime.now().minusMinutes(10);
        System.out.printf("%s ~ %s", afterTime, beforeTime);

    }

}			
			]]>
			</programlisting>
		</section>
		<section id="java.time.Duration">
			<title>Duration</title>
			<programlisting>
			<![CDATA[
import java.time.Duration;

public class SecondsToMillisecondsWithDuration {
    public static void main(String[] args) {
        // 1. 整数秒转换
        int seconds1 = 10;
        // 通过 Duration.ofSeconds() 创建对应秒数的 Duration 对象
        Duration duration1 = Duration.ofSeconds(seconds1);
        // 调用 toMillis() 方法获取毫秒数
        long millis1 = duration1.toMillis();
        System.out.println(seconds1 + " 秒 = " + millis1 + " 毫秒"); // 输出：10 秒 = 10000 毫秒

        // 2. 带纳秒的秒数转换（支持更精确的小数秒）
        long seconds2 = 3; // 秒数整数部分
        int nanos = 500_000_000; // 纳秒部分（500毫秒 = 500,000,000纳秒）
        Duration duration2 = Duration.ofSeconds(seconds2, nanos);
        long millis2 = duration2.toMillis();
        System.out.println(seconds2 + "秒 + " + nanos + "纳秒 = " + millis2 + " 毫秒"); // 输出：3秒 + 500000000纳秒 = 3500 毫秒

        // 3. 处理大数值秒数
        long seconds3 = 3_600_000; // 1000小时对应的秒数
        Duration duration3 = Duration.ofSeconds(seconds3);
        long millis3 = duration3.toMillis();
        System.out.println(seconds3 + " 秒 = " + millis3 + " 毫秒"); // 输出：3600000 秒 = 3600000000 毫秒
    }
}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>计算流逝时间</title>
			<programlisting>
			<![CDATA[
package com.netkiller.conference.ai.utils;

import android.os.Build;

import androidx.annotation.RequiresApi;

import java.time.Duration;
import java.time.LocalDateTime;

public class Datatime {
    
    public static String elapsed(LocalDateTime startTime, LocalDateTime endTime) {
        Duration duration = Duration.between(startTime, endTime);
        long hours = duration.toHours();
        long minutes = duration.toMinutesPart();
        long seconds = duration.toSecondsPart();
        long millis = duration.toMillisPart();

        if (hours > 0) {
//            return String.format("%d 时 %d 分 %d 秒 %d 毫秒", hours, minutes, seconds, millis);
            return String.format("%02d:%02d:%02d", hours, minutes, seconds);
        } else if (minutes > 0) {
//            return String.format("%d 分 %d 秒 %d 毫秒", minutes, seconds, millis);
            return String.format("%02d:%02d", minutes, seconds);
        } else if (seconds > 0) {
//            return String.format("%d 秒 %d 毫秒", seconds, millis);
            return String.format("00:%02d", seconds);
        } else {
//            return String.format("%d 毫秒", millis);
            return "00:00";
        }
    }
}		
			]]>
			</programlisting>
		</section>
	</section>
	<section id="array">
		<title>Array 数组</title>
		<para>一定字符串数组</para>
		<programlisting>
		<![CDATA[
String[] str={"AAA","BBB","CCC"};
String str[]={"AAA","BBB","CCC"};		
		]]>
		</programlisting>
		<section id="StringToArray">
			<title>字符串转数组</title>

			<para>String to Array</para>
			<programlisting>
		<![CDATA[
package cn.netkiller.java;

public class StringToArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str="a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z";
		String[] array = null;   
		array = str.split(",");
		for(int i=0; i<array.length; i++){
			System.out.println(array[i]);
		}
	}
}		
		]]>
			</programlisting>
		</section>
		<section>
			<title>for each</title>
			<programlisting>
			<![CDATA[
	public static void main(String[] args) {
		try {
			
			for (String arg : args) {
				System.out.println(arg);
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}			
			]]>
			</programlisting>
		</section>
		<section id="ArrayToString">
			<title>Array to String</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.java;

import java.util.Arrays;

public class ArrayToString {

	public static void main(String[] args) {
		String[] array = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
		System.out.println(Arrays.toString(array));
		System.out.println(Arrays.toString(array).replaceAll(", |\\[|\\]", ""));
	}

}
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
System.out.println(Arrays.toString(deepArray));
//output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
System.out.println(Arrays.deepToString(deepArray));		

Output:
[[John, Mary], [Alice, Bob]]	
			]]>
			</programlisting>
		</section>
		<section id="String.join">
			<title>数据转字符串</title>
			<programlisting>
			<![CDATA[
String[] array = {"neo", "chen"};
String string = String.join(",", array)
// 输出结果 "neo,chen"		
			]]>
			</programlisting>
		</section>
		<section id="string.split">
			<title>字符串转数组</title>
			<programlisting>
			<![CDATA[
    private String[] SplitWords(String wakeup) {
        String[] parts = wakeup.split("[;；]");
        return parts;
    }
			]]>
			</programlisting>
		</section>
	</section>
	<section id="float">
		<title>float 浮点</title>
		<para>float 不能直接做减法运算</para>
		<screen>
			float a = 77.22f;
			float b = 77.2f;

			System.out.println((float)a-b);
			System.out.println((float)a+b);

			输出结果为：
			0.020004272
			154.42
		</screen>
		<para></para>
		<programlisting>
		<![CDATA[
package cn.netkiller.example;

import java.math.BigDecimal;

public class Math {

	public Math() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {

		float a = 77.22f;
		float b = 77.2f;

		System.out.println((float) a + b);
		System.out.println((float) a - b);
		System.out.println((float) a * b);
		System.out.println((float) a / b);

		System.out.println("-------------");

		System.out.println(add(a, b));
		System.out.println(sub(a, b));
		System.out.println(mul(a, b));
		System.out.println(div(a, b));

	}

	public static float add(float v1, float v2) {
		BigDecimal b1 = new BigDecimal(Float.toString(v1));
		BigDecimal b2 = new BigDecimal(Float.toString(v2));
		return b1.add(b2).floatValue();
	}

	public static float sub(float v1, float v2) {
		BigDecimal b1 = new BigDecimal(Float.toString(v1));
		BigDecimal b2 = new BigDecimal(Float.toString(v2));
		return b1.subtract(b2).floatValue();
	}

	public static float mul(float v1, float v2) {
		BigDecimal b1 = new BigDecimal(Float.toString(v1));
		BigDecimal b2 = new BigDecimal(Float.toString(v2));
		return b1.multiply(b2).floatValue();
	}

	public static float div(float v1, float v2) {
		return div(v1, v2, 5);
	}

	public static float div(float v1, float v2, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Float.toString(v1));
		BigDecimal b2 = new BigDecimal(Float.toString(v2));
		return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).floatValue();
	}

	public static float round(float v, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Float.toString(v));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).floatValue();
	}
}

		]]>
		</programlisting>
	</section>
	<section id="double">
		<title>double 双精度浮点</title>
		<programlisting>
		<![CDATA[
package cn.netkiller.example;

import java.math.BigDecimal;

public class Math {

	public Math() {
		// TODO Auto-generated constructor stub
	}

	public static double add(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.add(b2).doubleValue();
	}

	public static double sub(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.subtract(b2).doubleValue();
	}

	public static double mul(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.multiply(b2).doubleValue();
	}

	public static double div(double v1, double v2) {
		return div(v1, v2, 8);
	}

	public static double div(double v1, double v2, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	public static double round(double v, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(v));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
}		
		]]>
		</programlisting>
		<section>
			<title>String to double</title>
			<programlisting>
			<![CDATA[
double amount = Double.parseDouble(value);			
			]]>
			</programlisting>
		</section>
		<section>
			<title>百分数转Double</title>
			<programlisting>
			<![CDATA[
import java.text.NumberFormat;
import java.text.ParseException;
try {

    Double num = (Double)NumberFormat.getInstance().parse("67.89%"); // 转换的结果是67.89
    Double num2 = (Double)NumberFormat.getPercentInstance().parse("67.89%"); // 转换的结果是0.6789

    System.out.println(num);
} catch (ParseException e) {
    e.printStackTrace();
}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Double转百分数</title>
			<programlisting>
			<![CDATA[
import java.text.NumberFormat;
import java.text.ParseException;

try {
    NumberFormat percentInstance = NumberFormat.getPercentInstance();
    percentInstance.setMaximumFractionDigits(2); // 保留小数两位
    String format = percentInstance.format(0.81247); // 结果是81.25% ，最后一们四舍五入了

    System.out.println(num);
} catch (ParseException e) {
    e.printStackTrace();
}
			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="BigDecimal">
		<title>BigDecimal</title>
		<screen>
		<![CDATA[
package cn.netkiller.example;

import java.math.BigDecimal;

public class BigDecimalTest {

	public BigDecimalTest() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BigDecimal first = new BigDecimal("1.0");
		BigDecimal second = new BigDecimal("1.77");
		System.out.println(String.format("%s, %s", first, second));

		if (first.equals(second))

			System.out.println("equals: true");

		else

			System.out.println("equals: false");

		if (first.compareTo(second) == 0)

			System.out.println("compareTo: true");
		else
			System.out.println("compareTo: false");

		BigDecimal zero = new BigDecimal("0");
		BigDecimal one = new BigDecimal("1");
		BigDecimal minus = new BigDecimal("-1");

		if (zero.compareTo(one) < 0)

			System.out.println("比較演算子[ <  ]: true");

		if (one.compareTo(one) == 0)

			System.out.println("比較演算子[ == ]: true");

		if (zero.compareTo(minus) > 0)

			System.out.println("比較演算子[ >  ]: true");

		if (zero.compareTo(minus) >= 0)

			System.out.println("比較演算子[ >= ]: true");

		if (zero.compareTo(minus) != 0)

			System.out.println("比較演算子[ != ]: true");

		if (zero.compareTo(one) <= 0)
			System.out.println("比較演算子[ <= ]: true");

	}

}
		]]>
		</screen>
		<section>
			<title>Convert BigDecimal Object to double value</title>
			<programlisting>
			<![CDATA[
BigDecimal.doubleValue()
			]]>
			</programlisting>
		</section>
		<section>
			<title>去除末尾多余的0</title>
			<programlisting>
			<![CDATA[
System.out.println( new BigDecimal("100.000").stripTrailingZeros().toString());		
			]]>
			</programlisting>
		</section>
		<section>
			<title>禁用科学计数法</title>
			<programlisting>
			<![CDATA[
有时会输出 1E+2，如果你不希望这种科学计数法输出可以使用 toPlainString() 替代 toString()
System.out.println( new BigDecimal("100.000").stripTrailingZeros().toPlainString());			
			]]>
			</programlisting>
		</section>
		<section>
			<title>移动小数点位置</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.example.test;

import java.math.BigDecimal;
import java.math.BigInteger;

public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int decimal = 4;

		BigInteger amount = BigInteger.valueOf(10000000000L);
		BigDecimal balance = new BigDecimal(amount);
		BigDecimal point = new BigDecimal(0.1 / Math.pow(10, decimal));
		balance = balance.multiply(point);
		System.out.println(balance);
	}

}			
			]]>
			</programlisting>
			<para>发现输出有问题
				100000.000000000008180305391403130954586231382563710212707519531250000000000
			</para>
			<para>换种方法</para>
			<programlisting>
			<![CDATA[
package cn.netkiller.example.test;

import java.math.BigDecimal;
import java.math.BigInteger;

public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// String i = Integer.valueOf("0x57c457",16).toString();
		// System.out.println(i);

		int decimal = 6;

		BigInteger amount = BigInteger.valueOf(10000000000L);

		System.out.println(amount);

		String tmp = amount.toString();

		String number = new StringBuffer(tmp).insert(tmp.length() - decimal, ".").toString();
		BigDecimal balance = new BigDecimal(number);

		System.out.println(balance);
	}

}			
			]]>
			</programlisting>
			<para>最佳方案</para>
			<programlisting>
			<![CDATA[

		int decimal = 6;

		System.out.println(BigDecimal.TEN.pow(decimal));
		BigDecimal balance1 = new BigDecimal("1234");
		BigDecimal value = balance1.divide(BigDecimal.TEN.pow(decimal));
		System.out.println(value);

		BigDecimal balance2 = new BigDecimal("12.107");
		BigDecimal value2 = balance2.multiply(BigDecimal.TEN.pow(decimal)).setScale(0, RoundingMode.DOWN);
		System.out.println(value2);			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="StringBuffer">
		<title>StringBuffer</title>
		<programlisting>
		<![CDATA[
String str = Integer.toString(j);
str = new StringBuilder(str).insert(str.length()-2, ".").toString();

Or if you need synchronization use the StringBuffer with similar usage :

String str = Integer.toString(j);
str = new StringBuffer(str).insert(str.length()-2, ".").toString();		
		]]>
		</programlisting>
	</section>
	<section id="enum">
		<title>enum</title>
		<programlisting>
		<![CDATA[
class EnumExample1{

	public enum Season { WINTER, SPRING, SUMMER, FALL }
	
	public static void main(String[] args) {
		for (Season s : Season.values())
			System.out.println(s);
	}
}		
		]]>
		</programlisting>
		<screen>

		</screen>
		<programlisting>
		<![CDATA[
package cn.netkiller.api.util;

public enum HttpMethod {
    GET("GET"), POST("POST"), PUT("PUT"), PATCH("PATCH"), DELETE("DELETE");

    private String value;

    private HttpMethod(String value) {
        this.value = value;
    }

    public String toString() {
        return value;
    }
}		
		]]>
		</programlisting>
	</section>
	<section id="byte">
		<title>byte 类型</title>
		<section>
			<title>string2byte</title>
			<programlisting>
			<![CDATA[
	byte[] bytes = "Helloworld!!! - http://www.netkiller.cn".getBytes();		
			]]>
			</programlisting>
		</section>
		<section>
			<title>初始化 byte[] 填充数据 0</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.Arrays;

public class Test {


    public static void main(String[] args) throws InterruptedException {

        byte[] buffer = new byte[16];
        Arrays.fill(buffer, (byte) 0); // 确保每个元素为 0

        System.out.println(Arrays.toString(buffer));

    }

}			
			]]>
			</programlisting>
		</section>
		<section id="byte2string">
			<title>byte[] to String</title>
			<programlisting>
			<![CDATA[
	byte[] bytes = "Helloworld!!! - http://www.netkiller.cn".getBytes();
	String str = new String(bytes, StandardCharsets.UTF_8);
	System.out.println(str);
			]]>
			</programlisting>
		</section>
		<section id="BigInteger2byte">
			<title>BigInteger2byte</title>
			<programlisting>
			<![CDATA[
BigInteger b= new BigInteger('300');
byte bytes= b.byteValue();			
			]]>
			</programlisting>
		</section>
		<section id="int2byte">
			<title>int to byte array</title>
			<para></para>
			<programlisting>
			<![CDATA[
int a= 120;
byte b= (byte)a;			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
private byte[] bigIntToByteArray( final int i ) {
    BigInteger bigInt = BigInteger.valueOf(i);      
    return bigInt.toByteArray();
}			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
private byte[] intToByteArray ( final int i ) throws IOException {      
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(bos);
    dos.writeInt(i);
    dos.flush();
    return bos.toByteArray();
}			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
private byte[] intToBytes( final int i ) {
    ByteBuffer bb = ByteBuffer.allocate(4); 
    bb.putInt(i); 
    return bb.array();
}						
			]]>
			</programlisting>
			<para>位移操作</para>
			<programlisting>
			<![CDATA[
private static byte[] intToBytes(final int a) {
    return new byte[] {
        (byte)((data >> 24) & 0xff),
        (byte)((data >> 16) & 0xff),
        (byte)((data >> 8) & 0xff),
        (byte)((data >> 0) & 0xff),
    };
}			
			]]>
			</programlisting>
		</section>
		<section id="byte2int">
			<title>byte array to int</title>
			<programlisting>
			<![CDATA[
private int convertByteArrayToInt(byte[] intBytes){
    ByteBuffer byteBuffer = ByteBuffer.wrap(intBytes);
    return byteBuffer.getInt();
}			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
private int convertByteArrayToInt(byte[] data) {
    if (data == null || data.length != 4) return 0x0;
    // ----------
    return (int)( // NOTE: type cast not necessary for int
            (0xff & data[0]) << 24  |
            (0xff & data[1]) << 16  |
            (0xff & data[2]) << 8   |
            (0xff & data[3]) << 0
            );
}			
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
	public static byte[] intToByte32(int num) {
        byte[] arr = new byte[32];
        for (int i = 31; i >= 0; i--) {
            // &1 也可以改为num&0x01,表示取最地位数字.
            arr[i] = (byte) (num & 1);
            // 右移一位.
            num >>= 1;
        }
        return arr;
    }

			
	public static int byte32ToInt(byte[] arr) {
        if (arr == null || arr.length != 32) {
            throw new IllegalArgumentException("byte数组必须不为空,并且长度是32!");
        }
        int sum = 0;
        for (int i = 0; i < 32; ++i) {
            sum |= (arr[i] << (31 - i));
        }
        return sum;
    }			
			]]>
			</programlisting>
			<para>int array to byte array</para>
			<programlisting>
			<![CDATA[
private byte[] convertIntArrayToByteArray(int[] data) {
        if (data == null) return null;
        // ----------
        byte[] byts = new byte[data.length * 4];
        for (int i = 0; i < data.length; i++)
            System.arraycopy(convertIntToByteArray(data[i]), 0, byts, i * 4, 4);
        return byts;
    }			
			]]>
			</programlisting>
			<para>byte array to int array</para>
			<programlisting>
			<![CDATA[
public int[] convertByteArrayToIntArray(byte[] data) {
        if (data == null || data.length % 4 != 0) return null;
        // ----------
        int[] ints = new int[data.length / 4];
        for (int i = 0; i < ints.length; i++)
            ints[i] = ( convertByteArrayToInt(new byte[] {
                    data[(i*4)],
                    data[(i*4)+1],
                    data[(i*4)+2],
                    data[(i*4)+3],
            } ));
        return ints;
    }			
			]]>
			</programlisting>
		</section>
		<section id="byte2char">
			<title>byte2char</title>
			<programlisting>
			<![CDATA[
	byte b1 = 65;
    // char ch = b1;  
          
    char ch = (char) b1;
 
    System.out.println("byte value: " + b1);             // prints 65
    System.out.println("Converted char value: " + ch);   // prints A (ASCII is 65 for A)			
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
	public static char byte2ToChar(byte[] arr) {
        if (arr == null || arr.length != 2) {
            throw new IllegalArgumentException("byte数组必须不为空,并且是2位!");
        }
        return (char) (((char) (arr[0] << 8)) | ((char) arr[1]));
    }			
    
    public static byte[] charToByte2(char c) {
        byte[] arr = new byte[2];
        arr[0] = (byte) (c >> 8);
        arr[1] = (byte) (c & 0xff);
        return arr;
    }
			]]>
			</programlisting>
		</section>
		<section id="longToByte64">
			<title>longToByte64</title>
			<programlisting>
			<![CDATA[
    public static byte[] longToByte64(long sum) {
        byte[] arr = new byte[64];
        for (int i = 63; i >= 0; i--) {
            arr[i] = (byte) (sum & 1);
            sum >>= 1;
        }
        return arr;
    }			
			]]>
			</programlisting>
		</section>
		<section id="byte64ToLong">
			<title>byte64ToLong</title>
			<programlisting>
			<![CDATA[
	public static long byte8ToLong(byte[] arr) {
        if (arr == null || arr.length != 8) {
            throw new IllegalArgumentException("byte数组必须不为空,并且是8位!");
        }
        return (long) (((long) (arr[0] & 0xff) << 56) | ((long) (arr[1] & 0xff) << 48) | ((long) (arr[2] & 0xff) << 40)
                        | ((long) (arr[3] & 0xff) << 32) | ((long) (arr[4] & 0xff) << 24)
                        | ((long) (arr[5] & 0xff) << 16) | ((long) (arr[6] & 0xff) << 8) | ((long) (arr[7] & 0xff)));
    }
    			
	public static byte[] longToByte8(long sum) {
        byte[] arr = new byte[8];
        arr[0] = (byte) (sum >> 56);
        arr[1] = (byte) (sum >> 48);
        arr[2] = (byte) (sum >> 40);
        arr[3] = (byte) (sum >> 32);
        arr[4] = (byte) (sum >> 24);
        arr[5] = (byte) (sum >> 16);
        arr[6] = (byte) (sum >> 8);
        arr[7] = (byte) (sum & 0xff);
        return arr;
    }
    			
	public static long byte64ToLong(byte[] arr) {
        if (arr == null || arr.length != 64) {
            throw new IllegalArgumentException("byte数组必须不为空,并且长度是64!");
        }
        long sum = 0L;
        for (int i = 0; i < 64; ++i) {
            sum |= ((long) arr[i] << (63 - i));
        }
        return sum;
    }			
			]]>
			</programlisting>
		</section>
		<section id="short2byte">
			<title>short2byte</title>
			<programlisting>
			<![CDATA[
    public static byte[] shortToByte16(short s) {
        byte[] arr = new byte[16];
        for (int i = 15; i >= 0; i--) {
            arr[i] = (byte) (s & 1);
            s >>= 1;
        }
        return arr;
    }

    public static short byte16ToShort(byte[] arr) {
        if (arr == null || arr.length != 16) {
            throw new IllegalArgumentException("byte数组必须不为空,并且长度为16!");
        }
        short sum = 0;
        for (int i = 0; i < 16; ++i) {
            sum |= (arr[i] << (15 - i));
        }
        return sum;
    }			
    
    public static short byte2ToShort(byte[] arr) {
        if (arr != null && arr.length != 2) {
            throw new IllegalArgumentException("byte数组必须不为空,并且是2位!");
        }
        return (short) (((short) arr[0] << 8) | ((short) arr[1] & 0xff));
    }
    
    public static byte[] shortToByte2(Short s) {
        byte[] arr = new byte[2];
        arr[0] = (byte) (s >> 8);
        arr[1] = (byte) (s & 0xff);
        return arr;
    }
			]]>
			</programlisting>
		</section>
		<section id="byte8ToDouble">
			<title>byte8ToDouble</title>
			<programlisting>
			<![CDATA[
	public static double byte8ToDouble(byte[] arr) {
        if (arr == null || arr.length != 8) {
            throw new IllegalArgumentException("byte数组必须不为空,并且是8位!");
        }
        long l = byte8ToLong(arr);
        return Double.longBitsToDouble(l);
    }

    public static byte[] doubleToByte8(double i) {
        long j = Double.doubleToLongBits(i);
        return longToByte8(j);
    }			
			]]>
			</programlisting>
		</section>
		<section id="byte4ToFloat">
			<title>byte4ToFloat</title>
			<programlisting>
			<![CDATA[
    public static float byte4ToFloat(byte[] arr) {
        if (arr == null || arr.length != 4) {
            throw new IllegalArgumentException("byte数组必须不为空,并且是4位!");
        }
        int i = byte4ToInt(arr);
        return Float.intBitsToFloat(i);
    }

    public static byte[] floatToByte4(float f) {
        int i = Float.floatToIntBits(f);
        return intToByte4(i);
    }			
			]]>
			</programlisting>
		</section>
		<section id="unsigned-byte">
			<title>无符号 byte</title>
			<programlisting>
			<![CDATA[
byte b= -120;
int a= bytes & 0xff;
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
byte a = (byte)234;
System.out.println(a);

上面的代码，结果是-22，因为java中byte是有符号的，byte范围是-128~127。

如果想输出234，该怎么做呢，首先想到的是将a 赋给大一点的类型，如下：

byte a = (byte)234;
int i = a&0xff;
System.out.println(i);

原因是 0xff是int，占4个字节，a是byte，占1个字节，进行&操作的细节如下：

   00000000 00000000 00000000 11101010    (a)
&
   00000000 00000000 00000000 11111111    (0xff)
---------------------------------------------------------------------
=  00000000 00000000 00000000 11101010

结果是int，但是符号位是0，说明是正数，最后就是正整数234.	
			]]>
			</programlisting>
		</section>
		<section id="byte2hex">
			<title>byte to hex</title>
			<programlisting>
			<![CDATA[
byte bv = 10;
String hexString = Integer.toHexString(bv);			
			]]>
			</programlisting>
		</section>
		<section id="bytes2hex">
			<title>byte[] to hex</title>
			<programlisting>
			<![CDATA[
byte bytes[] = {(byte)0, (byte)0, (byte)134, (byte)0, (byte)61};
System.out.println(javax.xml.bind.DatatypeConverter.printHexBinary(bytes));			
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
public static String byteArrayToHex(byte[] bytes) {
   StringBuilder sb = new StringBuilder(a.length * 2);
   for(byte b: bytes)
      sb.append(String.format("%02x", b));
   return sb.toString();
}
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
BigInteger n = new BigInteger(byteArray);
String hexa = n.toString(16));			
			]]>
			</programlisting>
		</section>
		<section id="byte[]">
			<title>连接两个 byte[]</title>
			<programlisting>
			<![CDATA[
byte[] one = { 1, 2, 3 };
byte[] two = { 6, 8, 9 };
int length = one.Length + two.Length;
byte[] sum = new byte[length];
one.CopyTo(sum,0);
two.CopyTo(sum,one.Length);			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
byte[] one = { 1, 2, 3 };
byte[] two = { 6, 8, 9 };
List<byte> list1 = new List<byte>(one);
List<byte> list2 = new List<byte>(two);
list1.AddRange(list2);
byte[] sum2 = list1.ToArray();			
			]]>
			</programlisting>
		</section>
		<section id="list.byte">
			<title>List&lt;Byte&gt; to byte[]</title>
			<programlisting>
			<![CDATA[
		List<Byte> byteList = new ArrayList<Byte>();
        byteList.add((byte) 1);
        byteList.add((byte) 2);
        byteList.add((byte) 3);
        byte[] byteArray = Bytes.toArray(byteList);
        System.out.println(Arrays.toString(byteArray));			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="java.boolean">
		<title>布尔型 Boolean</title>
		<para>将boolean转换成Boolean</para>
		<programlisting>
		<![CDATA[
		Boolean b1 = new Boolean(true);
		Boolean b2 = Boolean.valueOf(true);		
		]]>
		</programlisting>
		<para>将Boolean转boolean</para>
		<programlisting>
		<![CDATA[
		Boolean b3=new Boolean(true);
		boolean b4=b3.booleanValue();
		]]>
		</programlisting>
		<para>将String转Boolean</para>
		<programlisting>
		<![CDATA[
		String s="true";
		Boolean bo1=new Boolean(s);
		Boolean bo2=Boolean.valueOf(s);
		]]>
		</programlisting>
		<para>将Boolean转String</para>
		<programlisting>
		<![CDATA[
		Boolean boo=new Boolean(true);
		String s1=boo. toString();
		String s2=Boolean.toString(boo);
		String s3=String.valueOf(boo);
		]]>
		</programlisting>
		<para>boolean转String</para>
		<programlisting>
		<![CDATA[
		boolean  b =true;
		String st1 = String.valueOf(b);
		]]>
		</programlisting>
		<para>String转boolean</para>
		<programlisting>
		<![CDATA[
		String str="true";
		boolean boo11=Boolean.parseBoolean(str);
		Boolean boo12=new Boolean(str);
		boolean bool3=boo12.booleanValue();		
		]]>
		</programlisting>
	</section>
</chapter>