`
ec06cumt
  • 浏览: 20345 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

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

    博客分类：
  • J2SE
JavaAppleC#CC++ 
阅读更多

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));
	}
}

结果：
 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

 

0
顶
0
踩
分享到：
| JavaIO复习和目录文件的复制
评论
发表评论

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

相关推荐

    java期末复习资料

    3. **基本数据类型封装类**：Java为每个基本数据类型提供了对应的封装类，如`float`对应`java.lang.Float`，`char`对应`java.lang.Character`，`boolean`对应`java.lang.Boolean`。 4. **final关键字**：`final`...

    java复习笔记

    Java反射机制允许程序在运行时检查类的信息，如类名、方法名、参数类型，并能动态调用方法和访问字段。它在插件系统、序列化、动态代理等领域有广泛应用。 十、Java虚拟机（JVM） JVM是Java程序的运行环境，负责...

    java面试复习资料

    - `java.lang`：包含构成Java编程语言核心的类（如`String`和`Math`）、异常、接口和错误。 - `java.util.concurrent`：提供了高级并发工具类和类库。 - `java.lang.reflect`：提供了用于获取类和对象的内部结构的...

    Java基础知识复习资料.rar

    - 异常类层次结构基于`java.lang.Throwable`，分为Error和Exception两大类，其中Exception用于应用程序可以预见并可能恢复的情况。 4. **集合框架** - 集合是存储一组对象的容器，Java提供了ArrayList、...

    310-065考试学习资料

    - 在新线程中，首先打印`run.`，然后抛出异常`java.lang.RuntimeException: Problem`。 - 由于Java的线程异常默认不会传播到主线程，除非显式地捕获或处理这些异常。在这个例子中，没有显式处理异常，所以主线程会...

    河北工业大学java期末考试复习题(部分答案)(推荐文档).doc

    12. **反射机制**：Java反射机制允许在运行时检查类的信息，创建并调用对象，增强了程序的灵活性。 13. **注解（Annotation）**：注解是元数据的一种形式，可以帮助编译器和工具进行代码分析、验证或自动生成代码。...

    Java复习题（考试复习）

    - 动态代理：使用java.lang.reflect.Proxy和InvocationHandler实现动态代理。 10. **Java 8及以后的新特性**： - Lambda表达式：简化匿名内部类，提高代码简洁性。 - Stream API：提供一种函数式编程风格处理...

    Java复习资料.zip

    - **自定义异常**: 开发者可以创建自己的异常类，继承自java.lang.Throwable或其子类。 **4. 多线程** - **Thread类**: 创建并启动线程的方法之一是直接继承Thread类并重写run()方法。 - **Runnable接口**: 另一种...

    java复习上下篇

    反射API允许在运行时检查类、接口、字段和方法的信息，动态创建对象和调用方法，增强了Java的灵活性。 八、Java EE和Spring框架 Java Enterprise Edition（Java EE）提供了一个企业级应用开发的平台，包括Servlet、...

    java复习笔记总结123456789

    13. **反射（Reflection）**：反射机制允许在运行时动态地获取类的信息（如类名、方法名、参数类型）并调用方法，增强了程序的灵活性。 14. **注解（Annotation）**：注解是一种元数据，提供了在代码中添加元信息的...

    java复习题库 计算机认证考试

    Java编程中还有许多其他重要概念，例如异常处理、集合框架、IO流、网络编程、多线程同步机制、反射机制等，这些都需要深入学习和理解。在准备计算机认证考试时，除了做题库外，还需要阅读官方文档、参考书籍，以及...

    java复习资料

    - 包：用于组织和管理Java类，避免命名冲突，例如`java.lang`、`java.util`等。 - 导入：使用`import`关键字引入其他包中的类，如`import java.util.ArrayList;` 4. **异常处理** - 异常：当程序运行时发生错误...

    笔试面试(复习资料大全)Java笔试题_20071220.doc

    以上只是Java笔试题中的一部分核心知识点，实际的Java学习还包括面向对象编程、集合框架、IO流、多线程、网络编程、反射、注解等广泛内容。掌握这些知识不仅有助于通过面试，更能在实际开发中游刃有余。对于Java...

    JAVA核心技术卷I源代码（第七版）

    10. **反射**：Java反射机制允许在运行时检查类、接口、字段和方法的信息，甚至动态调用方法。源代码将展示如何使用`java.lang.reflect`包进行反射操作。 11. **JNI**：Java Native Interface允许Java代码调用本地...

    java-programming-chapter-interview.zip_java programming

    这份资料的核心是“JAVA面试题集编程篇.pdf”，它整理了Java编程领域的常见问题和解答，为面试者提供了一个全面的复习平台。 一、基础概念与语法 1. Java的特性：理解Java的面向对象特性，包括封装、继承、多态。 2...

    java复习题补全附标准答案.pdf

    Java是一种广泛使用的高级编程语言，以其跨平台、面向对象、安全性强等特性著称。...Java的语法和特性非常丰富，包括异常处理、集合框架、IO流、网络编程、多线程、反射等，深入学习还需要结合实际编程实践。

    JAVA在线帮助文档2中文版

    【JAVA在线帮助文档2中文版】是一份专为Java开发者准备的重要参考资料，它提供了详尽的API接口说明、类库介绍和技术指南，旨在帮助开发者更好地理解和应用Java编程语言。这份文档是第一部分的补充，意味着它包含了...

    阿里2016校招Java研发笔试题

    2. 高级特性：Java中的集合框架（List、Set、Map等接口及其实现类的使用和比较）、异常处理机制、输入输出（I/O）流、泛型、注解、反射、多线程和并发编程。 3. 核心类库：Java标准库中常用的类和方法，例如java....

    Java基础的例子 练习题（著名的于慧峰老师的总结）

    10. **反射**：Java反射机制允许在运行时检查类、接口、字段和方法的信息，并动态调用方法、创建对象。这对于框架开发、元编程和插件系统非常有用。 以上就是"Java基础的例子 练习题"中涵盖的主要知识点。通过学习...

Magicbox
Global site tag (gtag.js) - Google Analytics