java.lang的重要类的复习，反射机制和线程 -

ec06cumt

浏览: 19899 次
性别:
来自: 上海

最近访客更多访客>>

woodding2008

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

java.lang的重要类的复习，反射机制和线程

博客分类：

J2SE

Java Apple C#C C++

java.lang包是Java 的基础包, 在编译时，java.lang 包被自动导入源文件。java.lang包含Object类和包装类（Boolean、Character、Byte、Short、Integer、Long、Float和Double）等。其中重点类有：Class、ClassLoader、Enum、Math、String、StringBuffer还有一个重点的Thread类。

现就以api为导向，重点介绍一下这几个类的应用。

先给出几道面试题作为引子：

1.Object类中的hascode() 方法的返回类型是什么？

这个很简单：int

2.Object 类的clone() 方法可以抛出什么异常？

A. CloneNotSupportedException

B. NotCloneableException

C. IllegalCloneException

D. NoClonesAllowedException.

答案：A

3. 下面程序代码哪些部分能够打印出11？

/**
 * @author ec06cumt
 */
public class TestLangMath {
	public static void main(String[] args) {
		double v = 10.5;
		System.out.println(Math.ceil(v));
		System.out.println(Math.round(v));
		System.out.println(Math.floor(v));
		System.out.println((int)Math.ceil(v));
		System.out.println((int)Math.floor(v));
	}
}

结果：

4. 下面哪些运算符不能用于合并字符串对象？

a. +

b. -

c. +=

d. .

e. &

答案： b、 e

5. 下面的哪些表达式是非法的？

a. "hel".concat("lo");

b. ("hel"+"lo");

c. ('h'+'e'+'l'+'l'+'o');

d. ("hel"+ new String('l'+'o'));

e. ("hel") + new String("lo");

答案： b、c、d

6. 编译并运行下面的程序，结果是什么？

public class TestLangStringBuffer{

public static void mian(String[] args){

String s="Java 你好";

System.out.println(s.length):

}

请选择正确的答案： a. 9

b. 7

c. 11

d. 编译错误

答案： d 因为s.length();

注：String与StringBuffer的区别

String类提供了数值不可变的字符串，String类的对象一旦创建后，它的所有属性都是final类型的，也就是说一旦创建后，就不能修改。StringBuffer则是可变的。这是两者最大的区别。

下面我们就重点看看，各个类的重要方法等。

Math的random方法的应用：

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

/**
 * @author ec06cumt
 */
public class TestRandomNumber {

	/**
	 * 用random生成一个(m,n)之间的随机数，生成一个随机日期
	 * @param args
	 */
	public static void main(String[] args) {
		String beginDate="2010-02-19";
		String endDate="2010-02-28";
		for(int i=0;i<3;i++){
			long number=random(23,56);
			System.out.println(number);
		}
		for(int j=0;j<5;j++){
			Date date=randomDate(beginDate,endDate);
			System.out.println(date);
		}
		System.out.println("现在系统时间：");
			System.out.println(new Date());
	}

	/**
	 * 随机数的生成
	 * @param m
	 * @param n
	 * @return
	 */
	private static long random(long m, long n) {
		if(m>n){
			System.err.println("输入的参数错误");
			return -1;
		}
		long rtn=m+(long)(Math.random()*(n-m));
		if(rtn==m || rtn==n){
			return random(m,n);
		}
		return rtn;
	}
	
	private static Date randomDate(String beginDate, String endDate){
		try{
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			Date start= sdf.parse(beginDate);
			Date end  = sdf.parse(endDate);
			if(start.getTime() >= end.getTime()){
				return null;
			}
			
			long date=random(start.getTime(),end.getTime());
			return new Date(date);
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}

}

打印结果：

33
47
48
Thu Feb 25 22:16:12 CST 2010
Sat Feb 20 17:28:45 CST 2010
Mon Feb 22 08:15:30 CST 2010
Tue Feb 23 13:04:44 CST 2010
Sat Feb 27 00:54:07 CST 2010
现在系统时间：
Sun Feb 28 14:08:45 CST 2010

String类的部分方法用法：

import java.util.ArrayList;

/**
 * @author ec06cumt
 */
public class TestStringCharAt {

	/**
	 * 字符查找charAt，indexOf的应用
	 * @param args
	 */
	public static void main(String[] args) {
		String s="AABBsodnikgIKD57%^*))(_NLDGd42`lISee23432ODGPSfsijw";
		int lCount=0,uCount=0,oCount=0;
		char c=0;
		ArrayList<Character> lArrayList=new ArrayList<Character>();
		ArrayList<Character> uArrayList=new ArrayList<Character>();
		ArrayList<Character> oArrayList=new ArrayList<Character>();
		
		
		String sL="abcdefghijklmnopqistuvwxyz";
		String sU="ABCDEFGHIJKLMNOPQISTUVWXYZ";
		
		for(int i=0;i<s.length();i++){
			c=s.charAt(i);
			if(sL.indexOf(c)!=-1){
				lCount++;
				lArrayList.add(c);
			}else if(sU.indexOf(c)!=-1){
				uCount++;
				uArrayList.add(c);
			}else {
				oCount++;
				oArrayList.add(c);
			}
		}
		System.out.println("小写字母有" + lCount + "个");
		System.out.println("    它们是" + lArrayList.toString());
		System.out.println("小写字母有" + uCount + "个");
		System.out.println("    它们是" + uArrayList.toString());
		System.out.println("小写字母有" + oCount + "个");
		System.out.println("    它们是" + oArrayList.toString());
		
	}

}

结果：

小写字母有16个
    它们是[s, o, d, n, i, k, g, d, l, e, e, f, s, i, j, w]
小写字母有18个
    它们是[A, A, B, B, I, K, D, N, L, D, G, I, S, O, D, G, P, S]
小写字母有17个
    它们是[5, 7, %, ^, *, ), ), (, _, 4, 2, `, 2, 3, 4, 3, 2]

String的其他方法汇总：

import java.io.UnsupportedEncodingException;
/**
 * 
 * @author ec06cumt
 *
 */
public class TestStringsubstring2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		char[] data={'e','c','0','6','c','u','m','t'};
		String str=new String(data);
		System.out.println(str + "cde");
		byte[] bt={'a','b','c','d'};
		try {
			String str2=new String(bt,"gbk");
			System.out.println(str2);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		//spilt 分割字符数组
		String str3="0517-85379805-108-10-8";
		String[] arrStr=str3.split("-");
		for(int i=0;i<arrStr.length;i++){
			System.out.println(arrStr[i]);
		}
		//连接字符串
		String concatStr=str3.concat(str);
		System.out.println(concatStr);
		
		StringBuffer sbf=new StringBuffer(str);
		System.out.println(sbf.hashCode());
		sbf.append(true);
		System.out.println(sbf);
		sbf.append(0.53);
		System.out.println(sbf);
		sbf.delete(0, 2);
		System.out.println(sbf);
		sbf.deleteCharAt(3);
		System.out.println(sbf);
		sbf.insert(2, false);
		System.out.println(sbf);
		//字符串反转
		sbf.reverse();
		System.out.println(sbf);
		
		
	}

}

结果：

ec06cumtcde
abcd
0517
85379805
108
10
8
0517-85379805-108-10-8ec06cumt
23025815
ec06cumttrue
ec06cumttrue0.53
06cumttrue0.53
06cmttrue0.53
06falsecmttrue0.53
35.0eurttmceslaf60

replaceAll 与正则表达式

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ec06cumt
 */
public class TestStringSubString {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s="JAVAiangjavajigngjava2olgjigh javajgiilgojavagpjgo";
		System.out.println(s);
		s=s.replaceAll("\\bjava","JAVA");
		System.out.println(s);
		Pattern p=Pattern.compile("(?i)(java)");//(?i)表示不区分大小写的正则匹配
		Matcher m=p.matcher(s);
		
		StringBuffer sbf=new StringBuffer();
		int count=0;
		while(m.find()){
			count++;
			System.out.println(m.start()+" "+m.end());
			m.appendReplacement(sbf, "Sun");
		}
		m.appendTail(sbf);
		System.out.println(count);
		System.out.println(s);
		System.out.println(sbf.toString());
	}
}

结果：

JAVAiangjavajigngjava2olgjigh javajgiilgojavagpjgo
JAVAiangjavajigngjava2olgjigh JAVAjgiilgojavagpjgo
0 4
8 12
17 21
30 34
41 45
5
JAVAiangjavajigngjava2olgjigh JAVAjgiilgojavagpjgo
SuniangSunjigngSun2olgjigh SunjgiilgoSungpjgo

一个应用很巧妙的正则表达是计算出现字符最多次数的例子：

public class TestStringMaxChar {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s="20jtijhgnjkjdit0-2385690=4360&@#$&&#&%)#_5R468WY7WSRFJR9JSLJHOT";
		s=s.replaceAll("[^a-zA-Z]","");
		System.out.println(s);
		int max=0;
		int temp=0;
		String tempString = "";
		for(int i=0;i<s.length();i++){
			tempString=s.substring(0,1);
			String str=s.replaceAll(tempString,"");
			temp=s.length()-str.length();
			if(max < temp) max=temp;
			s=str;
		}
		
		System.out.println("出现支符次数最多多的是：" + tempString + "次数是： " + max);
	}

}

结果：

jtijhgnjkjditRWYWSRFJRJSLJHOT
出现支符次数最多多的是：Y次数是： 4

lang包中还有Enum的类，给个例子吧：

/**
 * @author ec06cumt
 */
public class TestEnum {

	/**
	 * @param args
	 */
	public enum MyColor {red,blue,green};
	public enum MyPet {dog,cat,snack,tiger,lion,bird};
	
	public static void main(String[] args) {
		MyColor m=MyColor.blue;
		switch(m){
		case  red:
			System.out.println("红色");
			break;
		case  blue:
			System.out.println("蓝色");
			break;
		case  green:
			System.out.println("绿色");
			break;
		default:
			System.out.println("Default");
		}
	    
		System.out.println(m);
	}

}

结果：

蓝色
blue

Lang包中还有Class类和ClassLoder类，我再次就做简单的说明反射机制吧吧，因为我自己也不是很精通。呵呵

1.ClassLoder加载机制：

a.并非一次性加载(不是从头扫描，然后把所有所需要的类都加载进来，然后执行)

b. 需要的时候加载（运行期动态加载）

c. static 语句快在加载后执行一次

d. dynamic 语句块每次加载新的对象都会执行

2.JDK内置ClassLoader：

(1).bootstrap ClassLoader 它是运行程序最基础的加载类，他是最先加载进来的，它是最核心的类，它负值加载jdk的核心类。

(2).extension ClassLoader 它负值loader the class from jre/ext

(3).application ClassLoader 应用程序ClassLoader，既系统ClassLoader，它负值加载用户自定义类

(4).other ClassLoader 如：Security ClassLoader，URLClassLoader

反射特点：可以再运行期间根据类名动态的加载一个类进来，动态new一个对象，动态地了解类内部结构，动态调用内部方法

public class TestLangClassLoader {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws ClassNotFoundException {
		ClassLoader c=TestLangClassLoader.class.getClassLoader();
		while(c !=null){
			System.out.println(c.getClass().getName());
			c=c.getParent();
		}
	}
}

结果：

sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader

/**
 * @author ec06cumt
 *
 */
public class TestLangClassLoader {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws ClassNotFoundException {
	/*	ClassLoader c=TestLangClassLoader.class.getClassLoader();
		while(c !=null){
			System.out.println(c.getClass().getName());
			c=c.getParent();
		}
		*/
		Class c=Class.forName("java.lang.Class");
		Method[] methods=c.getMethods();
		for(Method m : methods){
			System.out.println(m.getName());
		}
	}
}

结果：

forName
isAssignableFrom
isInstance
getModifiers
isInterface。。。。。。。。

lang包中还有Thread类，这里就简单的把线程的一些内容也简单的说以下吧：

线程有两种实现方式：一种是继承Thread类，另一种是实现Runnable接口，建议使用后一种，实现接口。因为这种耦合度更低

/**
 * 线程的两种实现方式
 * @author ec06cumt
 *
 */
public class TestLangThread {
	/*public static void main(String[] args) {
		Runner1 r=new Runner1();
		r.start();
		for(int i=0;i<=100;i++){
			System.out.println("Main Thread: -------" + i);
		}
	}

}
class Runner1 extends Thread{
	public void run(){
		for(int i=0;i<=100;i++){
			System.out.println("Runner1:" + i);
		}
	}
	
}
*/
	public static void main(String[] args){
		Runner2 r=new Runner2();
		//r.run();
		Thread t =new Thread(r);
		t.start();
		for(int i=0;i<=100;i++){
			System.out.println("Main Thread-----:" + i);
		}
	}
		
	
}

class Runner2 implements Runnable{
	public void run(){
		for(int i=0;i<=100;i++){
			System.out.println("Runner2:" + i);
		}
	}
}

结果：

Main Thread-----:0
Runner2:0
Runner2:1
Runner2:2
Runner2:3
Runner2:4
Runner2:5
Runner2:6
Runner2:7
Runner2:8
Runner2:9
Runner2:10
Main Thread-----:1
Main Thread-----:2
Main Thread-----:3
Main Thread-----:4
Main Thread-----:5
Main Thread-----:6
Main Thread-----:7
Main Thread-----:8
Main Thread-----:9
Main Thread-----:10

还有就是线程的集中状态的转换：

创建状态

就绪状态

运行状态阻塞状态

终止

还有一个重点就是线程同步：Synchronized

下面给一个经典的消费者生产者的例子吧：

public class TestLangThreadProducerConsumer {

	public static void main(String[] args) {
		SyncStack ss=new SyncStack();
		//创建线程
		producer p=new producer(ss);
		consumer c=new consumer(ss);
		new Thread(p).start();
		new Thread(c).start();
	}
	
}
   //生产苹果，苹果的构造方法
	class Apple{
		int id;
		Apple(int id){
			this.id=id;
		}
		public String toString(){
			return "Apple :" +id;
		}
	}
	//给出一个栈相当于一个苹果框
	class SyncStack{
		int index=0;
		Apple[] arrAp=new Apple[5];
		public synchronized void push(Apple ap){
			//这里没有用if，若框中的苹果满了就让此线程进入等待状态知道被激活
			while(index == arrAp.length){
				try{
					this.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			this.notifyAll();
			arrAp[index]=ap;
			index++;
		}
		
		public synchronized Apple pop(){
			//若框中没有了苹果，就让此线程进入等待状态，知道被激活
			while(index == 0){
				try{
					this.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			this.notifyAll();
			index--;
			return arrAp[index];
		}
	}
	
	class producer implements Runnable{
		SyncStack ss=null;
		producer(SyncStack ss){
			this.ss=ss;
		}
		public void run(){
			for(int i=0;i<10;i++){
				Apple ap=new Apple(i);
				ss.push(ap);
				System.out.println("生产了：" + ap);
				try{
					Thread.sleep((int)(Math.random()*200));
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
		}	
	}
	
	class consumer implements Runnable{
		SyncStack ss=null;
		consumer(SyncStack ss){
			this.ss=ss;
		}
		public void run(){
			for(int i=0;i<20;i++){
				Apple ap=new Apple(i);
				ss.pop();
				System.out.println("消费了：" + ap);
				try{
					Thread.sleep((int)(Math.random()*1000));
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
		}	
	}

结果：

消费了：Apple :0
生产了：Apple :0
生产了：Apple :1
生产了：Apple :2
生产了：Apple :3
生产了：Apple :4
生产了：Apple :5
消费了：Apple :1
生产了：Apple :6
消费了：Apple :2
生产了：Apple :7
生产了：Apple :8
消费了：Apple :3
消费了：Apple :4
生产了：Apple :9
消费了：Apple :5
消费了：Apple :6
消费了：Apple :7
消费了：Apple :8
消费了：Apple :9

0
顶

0
踩

分享到：

struts源码地址 | JavaIO复习和目录文件的复制

2010-02-28 16:25
浏览 1470
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

java.lang的重要类的复习，反射机制和线程

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

java.lang的重要类的复习，反射机制和线程

评论

发表评论

相关推荐

动态数组的增长

JavaIO复习和目录文件的复制

深入正则表达式(三)

最近访客更多访客>>