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
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));
}
}
结果:
11.0
11
10.0
11
10
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