Random/Timer/Java Disabuse(解惑)/StAX
一、Random
1、创建Random类型的对象：
Random random = new Random();//默认构造方法
Random random = new Random(10010010);//指定种子数字
2、生成随机数字：
生成随机整数：
int k = random.nextInt();
生成随机长整数：
long l = random.nextLong();
3、生成指定范围的数字：
例如生成0-10之间的随机数字：
int k = random.nextInt();
int j = Math.abs(k % 10);
//直接方式:rand.nextInt(range);
int i =random.nextInt(10);
获得10-20之间的随机数字：
int k = random.nextInt();
int j = Math.abs(k % 10) + 10;
int i = (int)(Math.random()*1000)
random对象的nextInt(),nextInt(int n)说明：
int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。 有正有负。
int nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
4、next(int bits)
next(n)产生2的n次方之内的随机数，next(32)产生2的32次方之内的随机数，就相当于nextInt（）了。
5、setSeed(long seed)
setSeed(long seed) 用于设定随机数的种子，即这里的seed。随机数种子的用处是：一般说来，这里的Random类产生随机数是伪随机数，是系统采用特定的算法生成出来的，方法是new两个Random类random1和random2。各自调用nextInt方法10次，我们可以看出，虽然各自产生的是随机数，但是两个Random类产生的随机数都是一样的。这就使得随机数存在着漏洞。
二、java disabuse
/***********双括弧初始化:内层的花括号就是匿名类的初始化子句************/
@SuppressWarnings("unchecked")
private static Map map = new HashMap() {{
put("id", "20090501");
put("name", "name1");
put("age","20");
}};
private static final Set<String> set = new HashSet<String>() {{
add("lucy");
add("lily");
add("frank");
add("bruce");
}};
public static void printSet(Set set){
Iterator it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
public static void printMap(Map map) {
for (Object key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
}
public static void printSelf() {
// 正则表达式“.”可以匹配任何单个的字符,要转义
System.out.println(JavaDisabuse.class.getName().replaceAll("\\.", "/")
+ ".class");
// java.util.regex.Pattern.quote。它接受一个字符串作为参数，并可以添加必
// 需的转义字符，它将返回一个正则表达式字符串
System.out.println(JavaDisabuse.class.getName().replaceAll(
Pattern.quote("."), "/")+ ".class");
//java.util.regex.Matcher.quoteReplacement，它将字
//符串转换成相应的替代字符串。
System.out.println(JavaDisabuse.class.getName().replaceAll("\\.",
Matcher.quoteReplacement(File.separator)) + ".class");
System.out.println(JavaDisabuse.class.getName().
replace('.', File.separatorChar) + ".class");
}
/** ***********提防溢出*************** */
public static void longDivision() {
final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;// 乘完后(已溢出)转型
final long MICROS_PER_DAY_L = 24L * 60 * 60 * 1000 * 1000;
final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);// 5
System.out.println(MICROS_PER_DAY_L / MILLIS_PER_DAY);// 1000
}
/** ***********执行精确小数运算********* */
public static BigDecimal subtract(String arg0, String arg1) {
// 问题在于1.1 这个数字不能被精确表示成为一个double，因此它被表示成为最
// 接近它的double值。
System.out.println(2.00 - 1.10);// 二进制浮点数的double运算:0.8999999999999999
return new BigDecimal(arg0).subtract(new BigDecimal(arg1));// 0.90
}
/** *******求奇数（莫用i%2==1，负数失效）********* */
public static boolean isOdd(int i) {
return i % 2 != 0;
}
public static boolean isOdd1(int i) {
return (i & 1) != 0;
}
三、Timer和TimerTask
public class JavaTimer {
/**
* 延迟执行任务
* @param task
* @param delay
*/
public void delayDoTask(TimerTask task, long delay){
Timer t = new Timer();
t.schedule(task, delay);
}
/**
* 间隔执行任务
* @param task
* @param delay
*/
public void internalDoTask(TimerTask task, long delay, long period){
Timer t = new Timer();
t.schedule(task, delay, period);
}
public class HomeWork extends TimerTask{
String id = "ID_"+Math.round(Math.random()*100000);
int times = 0;
public void run() {
System.out.println(id + " do homework " + (++times) + " times!");
if(times > 5){
this.cancel();//取消任务
System.exit(0);
}
}
}
public static void main(String args[]){
JavaTimer timer = new JavaTimer();
timer.delayDoTask(timer.new HomeWork(), 1*1000);
timer.internalDoTask(timer.new HomeWork(), 500, 1*1000);
}
}
四、关于StAX
从一开始，Java API for XML Processing (JAXP) 就提供了两种方法来处理 XML：文档对象模型（DOM）方法是用标准的对象模型表示 XML 文档；Simple API for XML (SAX) 方法使用应用程序提供的事件处理程序来处理 XML。JSR-173 提出了一种面向流的新方法：Streaming API for XML (StAX)。
StAX 实际上包括两套处理 XML 的 API，分别提供了不同程度的抽象。基于指针的 API 允许应用程序把 XML 作为一个标记（或事件）流来处理；应用程序可以检查解析器的状态，获得解析的上一个标记的信息，然后再处理下一个标记，依此类推。这是一种低层 API，尽管效率高，但是没有提供底层 XML 结构的抽象。较为高级的基于迭代器的 API 允许应用程序把 XML 作为一系列事件对象来处理，每个对象和应用程序交换 XML 结构的一部分。应用程序只需要确定解析事件的类型，将其转换成对应的具体类型，然后利用其方法获得属于该事件的信息。
(1)StAXReader
public class StAXReader {
/**
* 使用基于底层指针的 API: XMLStreamReader解析输入流
* @param fileName
*/
public static void parseByXMLStreamReader(String fileName) throws Exception{
XMLStreamReader reader = null;
PrintStream out = System.out;
try{
XMLInputFactory factory = XMLInputFactory.newInstance();
reader = factory.createXMLStreamReader(new FileReader(fileName));
int event = reader.getEventType();
while (true) {
switch (event) {
case XMLStreamConstants.START_DOCUMENT://一个文档的开始
out.println("Start Document.");
break;
case XMLStreamConstants.START_ELEMENT://一个元素的开始
out.println("Start Element: " + reader.getName().getLocalPart());
for(int i = 0, n = reader.getAttributeCount(); i < n; ++i)
out.println("Attribute: " + reader.getAttributeName(i)
+ "=" + reader.getAttributeValue(i));
break;
case XMLStreamConstants.CHARACTERS://字符可以是文本，或是一个空格
case XMLStreamConstants.SPACE://可忽略的空格
if (reader.isWhiteSpace())
break;
int start = reader.getTextStart();
int length = reader.getTextLength();
String text =
new String(reader.getTextCharacters(), start, length);
out.println("Text: " + text);
break;
case XMLStreamConstants.COMMENT ://一个注释
case XMLStreamConstants.PROCESSING_INSTRUCTION ://处理指令
out.println("Text: " + reader.getText());
break;
case XMLStreamConstants.END_ELEMENT://结束元素
out.println("End Element:" + reader.getName().getLocalPart());
break;
case XMLStreamConstants.END_DOCUMENT://结束文档
out.println("End Document.");
break;
}
if (!reader.hasNext())
break;
event = reader.next();
}
}catch(Exception e){
e.printStackTrace();
throw new Exception("解析XML文件时出错！", e);
}finally{
if(null != reader){
reader.close();
}
}
}
/**
* 使用迭代器风格的 API: XMLEventReader解析输入流
* @param fileName
*/
public static void parseByXMLEventReader(String fileName) throws Exception{
XMLEventReader reader = null;
PrintStream out = System.out;
try{
XMLInputFactory factory = XMLInputFactory.newInstance();
reader = factory.createXMLEventReader(new FileReader(fileName));
while(reader.hasNext()){
XMLEvent evt = reader.nextEvent();
switch(evt.getEventType()){
case XMLEvent.START_DOCUMENT:
String version = ((StartDocument) evt).getVersion();
String encoding = ((StartDocument) evt).getCharacterEncodingScheme();
boolean isStandAlone = ((StartDocument) evt).isStandalone();
out.println("Start Document.");
if(null != version) out.println("version: " + version);
if(null != encoding) out.println("encoding: "+ encoding);
out.println("isStandAlone: "+isStandAlone);
break;
case XMLEvent.START_ELEMENT:
QName qname = ((StartElement) evt).getName();
String localName = qname.getLocalPart();
out.println("Start Element: " + localName);
Iterator<?> it = ((StartElement) evt).getAttributes();
while (it.hasNext()) {
Attribute attr = (Attribute) it.next();
QName attrName = attr.getName();
String attrValue = attr.getValue();
out.println("Attribute: "+ attrName.getLocalPart() +" = "+attrValue);
}
break;
case XMLEvent.END_ELEMENT:
QName qname_end = ((EndElement) evt).getName();
out.println("End Element: " + qname_end.getLocalPart());
break;
case XMLEvent.CHARACTERS:
String text = ((Characters) evt).getData();
if(null != text && !text.replaceAll("\\s+", "").equals("")){
out.println("Text: " + text);
}
break;
case XMLEvent.COMMENT:
out.println("Comment: " + ((Comment) evt).getText());
break;
case XMLEvent.END_DOCUMENT:
out.println("End Document.");
break;
}
}
}catch(Exception e){
e.printStackTrace();
throw new Exception("解析XML文件时出错！", e);
}finally{
if(null != reader){
reader.close();
}
}
}
/**
* 读指定节点下的值
* 如:<properties>
* <property name="port" description="服务器所使用的端口">
* <field>80</field>
* </property>
* </properties>
* @param fileName
* @param nodeName
* @throws Exception
*/
public static void readXMLNodeProperty(String fileName, String nodeName) throws Exception{
XMLEventReader reader = null;
PrintStream out = System.out;
try{
XMLInputFactory factory = XMLInputFactory.newInstance();
reader = factory.createXMLEventReader(new FileReader(fileName));
while(reader.hasNext()){
XMLEvent evt = reader.nextEvent();
if(evt.getEventType() == XMLEvent.START_ELEMENT){
StartElement el = (StartElement)evt;
Attribute attr = el.getAttributeByName(new QName("name"));//具有name属性的节点
String startTag = el.getName().getLocalPart();//节点标签
if(null != attr && attr.getValue().equals(nodeName)){//根据name的值确定是否是想找的节点
while(reader.hasNext()){//循环其后节点
evt = reader.nextEvent();
if(evt.getEventType() == XMLEvent.END_ELEMENT){
if(((EndElement)evt).getName().getLocalPart().equals(startTag)){//节点结束标签
break;
}
}
if(evt.getEventType() == XMLEvent.CHARACTERS){//是文本节点，包括了空白符
String text = ((Characters) evt).getData();
if(!text.replaceAll("\\s+", "").equals("")){
out.println(nodeName + " = " + text);
break;
}
}
}
}
}
}
}catch(Exception e){
e.printStackTrace();
throw new Exception("读取XML过程中出错！", e);
}finally{
if(null != reader){
reader.close();
}
}
}
}
(2).StAXWriter
public class StAXWriter {
/**
* 基于Cursor
* @throws XMLStreamException
*/
public static void writeByXMLStreamWriter() throws XMLStreamException{
final String XHTML_NS = "http://www.w3.org/1999/xhtml";//Namespace
XMLOutputFactory f = XMLOutputFactory.newInstance();
XMLStreamWriter w = f.createXMLStreamWriter(System.out);
try {
w.writeStartDocument("GBK", "1.0");//Encoding And Version
w.writeCharacters("\n");
w.writeDTD("<!DOCTYPE html " +
"PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " +
"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">");
w.writeCharacters("\n");
w.writeComment(" This is a comment! ");//注释
w.writeCharacters("\n");
w.writeStartElement("html");
w.writeDefaultNamespace(XHTML_NS);//在当前元素上声明默认名称空间
w.writeAttribute("lang", "en");
w.writeCharacters("\n");
w.writeStartElement(XHTML_NS, "head");//名称空间URI 和本地名称
w.writeCharacters("\n");
w.writeStartElement(XHTML_NS, "title");
w.writeCharacters("Test");
w.writeEndElement();//end <title>
w.writeCharacters("\n");
w.writeEndElement();//end <head>
w.writeCharacters("\n");
w.writeStartElement(XHTML_NS, "body");
w.writeCharacters("This is a test.");
w.writeCData("This is a CData content!");//可以将文本包装在 CDATA 块中
w.writeEndElement();//end <body>
w.writeCharacters("\n");
w.writeEndElement();//end <html>
w.writeEndDocument();
}finally{
w.flush();//促使编写器将任何缓存的数据写入底层输出
w.close();//关闭编写器对象:关闭方法只释放编写器需要的资源，并不关闭底层的输出。
}
}
/**
* 基于Event
* @throws XMLStreamException
*/
public static void writeByXMLEventWriter() throws XMLStreamException{
final String XHTML_NS = "http://www.w3.org/1999/xhtml";
final QName HTML_TAG = new QName(XHTML_NS, "html");
final QName HEAD_TAG = new QName(XHTML_NS, "head");
final QName TITLE_TAG = new QName(XHTML_NS, "title");
final QName BODY_TAG = new QName(XHTML_NS, "body");
XMLOutputFactory f = XMLOutputFactory.newInstance();
XMLEventWriter w = f.createXMLEventWriter(System.out);
XMLEventFactory ef = XMLEventFactory.newInstance();
try {
/*
* add(XMLEventReader) 是一个很方便的方法，用它可以写出从读取器获得的全部事件。
* 使用这个方法，应用程序可以将整个 XML 流的内容有效地输送到另一个 XML 流，而且内容保持不变。
* add(XMLEvent) 写出从读取器获得的事件
*/
w.add(ef.createStartDocument());
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createDTD("<!DOCTYPE html " +
"PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " +
"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"));
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createStartElement(HTML_TAG, null, null));
w.add(ef.createNamespace(XHTML_NS));
w.add(ef.createAttribute("lang", "en"));
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createStartElement(HEAD_TAG, null, null));
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createStartElement(TITLE_TAG, null, null));
w.add(ef.createCharacters("Test"));
w.add(ef.createEndElement(TITLE_TAG, null));
w.add(ef.createEndElement(HEAD_TAG, null));
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createStartElement(BODY_TAG, null, null));
w.add(ef.createCharacters("This is a test."));
w.add(ef.createEndElement(BODY_TAG, null));
w.add(ef.createIgnorableSpace("\n"));
w.add(ef.createEndElement(HTML_TAG, null));
w.add(ef.createEndDocument());
} finally {
w.flush();
w.close();
}
}
}
/**
* 直接将Java Bean 转化成XML
* @param obj
*/
public static void convertObjectToXMLByXMLEncoder(Object obj){
try{
java.beans.XMLEncoder encoder = new XMLEncoder(System.out);
encoder.writeObject(obj);
encoder.close();
}catch(Exception e){
e.printStackTrace();
}
}
附：xstream实现java对象与XML互转