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互转

地址：http://xstream.codehaus.org/index.html