J2SE知识点归纳笔记(六)---Java常用类

Java常用类:

前言:

在上两节的博文中,我们对Java的多线程进行了深入的解析,理解起来还是有一些难度的;

今天这一节,我们讲点轻松点的,就是Java中的一些常用类的用法,这些类都放在java.lang包或者

java.util包下;而我们不需要import lang包,因为系统会自动导入这个包！

好了,废话不多说,看是这一节!

Java.lang包中的常用类:

Object类

简介:

Object类是所有类的父类,默认继承该类,每个类都可以直接调用Object的方法,同时还可以继承其他的类,

这并没有违背Java的单继承的规则哦！

常用方法:

toString()	返回描述对象的一个字符串,通常重写该方法以取得对象的字符串信息 另外,当调用system.print(),对象作为参数时,默认调用对象的toString()方法	String
equals()	判断两个对象的内容是否相同,可按需求对其进行重写	boolean
clone()	实现对象的复制,与赋值不同,赋值引用的是同一对象实例;另外需要实现 Cloneable接口才能使用clone()方法,否则会引发CloneNotSupportedException异常	Object
getClass()	该类封装对象接口运行时的状态,类加载时,Class对象自动创建,但是我们 不能够自己去new Class()哦!	Class

代码实例:

package com.jay.example;

public class ObjectTest {
	public static void main(String[] args) throws Exception {
		Person p1 = new Person("老王", 48);
		Person p2 = new Person("老张", 47);
		Person p3 = new Person("老王", 48);
		
		String s1 = new String("呵呵");
		String s2 = new String("呵呵");
		
		//这里直接调用print对象名的话,自动调用对象的toString()方法
		//如果不重写的话,返回的字符串:
		//getClass().getName() + '@' + Interger.toHexString(hashcode())
		//就是类名@哈希码
		System.out.println(p1);
		
		
		//这里要注意==赋值和equals的区别
		//==比较的是地址;equals比较的是两对象是否指向同一实例
		//而这里要注意字符串,字符串变量是有一个常量池的,当我们创建一个新的字符串
		//如果字符串中已经存在了,那么将该对象指向该内存空间,即指向同一引用对象
		//如果不是String对象而是普通的对象的话,直接调用equals是不相等的
		//所以需要对equals方法进行重写,不然就不能判断对象是否相等了
		System.out.println(p1 == p3);
		System.out.println(p1.equals(p3));
		
		//字符串常量池,使得两对象equals返回ture
		System.out.println(s1 == s2);
		System.out.println(s1.equals(s2));
		
		//调用clone()方法进行对象的复制,需要实现Cloneable接口,
		//要覆盖Clone()方法,至少写个return super().clone();还要注意使用try-catch对
		//CloneNotsupportedException进行捕获;
		//克隆与==赋值不一样,指向的不是同一实例对象哦！
		
		try {
			Person p4 = (Person) p2.clone();
			System.out.println(p4);
			System.out.println("p4和p2是否为同一对象:" + (p4 == p2));
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		
		/*Class类的使用:
		 * ①获得指向某个类的class对象的引用:   Class c1 = p1.getClass();
		 * ②获得接口或者类的全名:     c1.getName()
		 * ③当然也可以通过Class的静态方法forName()获得class对象引用:Class.forName("类的全名");
		 * ④getSuperclass():获得父类的class对象
		 * ⑤newInstance();创建一个与调用对象对应类的实例,是新的哦！
		 * 
		 * */
		
		System.out.println(p1.getClass());
		
		System.out.println(p1.getClass().getName());
		
		Class c1 = Class.forName("com.jay.example.Person");
		System.out.println(c1);
		System.out.println(c1.getSuperclass());
		
		
		Person p5 = p1.getClass().newInstance();
		p5.name = "老黄";
		p5.age = 25;
		System.out.println(p5);
	}
}

运行截图:

封装类

在Java中,基本数据类型都有与之对应的封装类(包装类)   eg:  int ----> Integer

装箱:基本数据类型---->封装类

拆箱:封装类--->基本数据类型

装箱与拆箱由系统自动完成！

基本数据类型与包装类的对照:

int --->  Integer                      short---> Short                  long---> Long

char --->  Character              float  ---> Float                  double--->Double

boolaen--->Boolean              byte  --->  Byte

使用窍门:

包装类-->基本:   intValue()

字符串--->基本:  parseInt("str")

包装--->字符串:  toString()

字符串--->包装: valueOf("str")

使用示例代码:

package com.jay.example;

public class PottingTest {
	public static void main(String[] args) {
		
		//①包装类与基本数据类型的相互转换
		//除了这种构造方法外:还可以写成,Integer(123),但使用字符串的话一定要
		//是符合对应数字格式的字符串,否则印发NumberFormatException(数字转换异常)
		//因为封箱与拆箱都是自动进行的,所以如果我们输入两个数相加的结果是:246
		//其他格式的都是这种转换格式,把int替换成其他数据类型即可
		Integer i = new Integer("123");
		int j = i.intValue();
		System.out.println(i + j);

		
		/*
		 * ②字符串转换为基本数据类型
		 * 同样要是符合数字类型的字符串,不然也会报异常
		 * 同理,只需要把int替换成其他数据类型即可:eg: Double.parseDouble("1.23");
		 * 别忘了Java小数默认是Double类型的哦！
		 * */
		
		 int i2 = Integer.parseInt("321");
		 
		
		 /*
		  * ③包装类与字符串的相互转换:
		  * */
		
		 //包装类转换成字符串,直接调用toString()即可
		 Integer a = new Integer(11);
		 i.toString();
		 
		 //字符串转换为包装类:
		 Integer ig = Integer.valueOf("987");
		 	 
	}
}

Character判断字符类别的方法:

ps:都是静态方法,参数都是char字符,返回值都是boolean!

 

数字:isDiagit(char)                    字母:isLetter(char)                  数字或字母:isLetterOrDigit(char)

小写字母:isLowerCase(char)                大写字母:isUpperCase(char)                空格:isSpace(char)        

Math类

常量PI和E

由名字就知道这个是数学类,当然是提供一些数学方法的啦,比如:正余弦运算等

Math类定义了两个常量,PI(圆周率)和E(自然数),顺道复习下Java中常量的定义方式:

public static final double PI:

public static final double E:

除了以上变量,当然还有很多的数学方法,比较多,这里只列出比较常用的

几个,有需要的自己查询API,都是静态方法,可以直接通过Math.XXX调用哦！

常用属性:

sqrt():求平方根

pow(数字,次方):求数字的多少次方

rint():返回与参数最接近的整数值,以double形式返回

abs():返回绝对值

max():返回两数的最大值

min():返回两数的最小值

System类

常见方法:

①exit(int exitcode):结束应用程序的运行,会返回exitcode给父进程(操作系统),exitcode为0的话表示正常退出

②复制数组:static void arraycopy(被复制的数组,起始下标,目标数组,起始下标,长度)

下标是从0开始算的哦！

使用实例:

package com.jay.example;

public class ArrayCopyTest {
	public static void main(String[] args) {
		int[] a = {1,2,3,4,5,6,7,8};
		int[] b = {0,0,0,0,0,0,0,0};
		int[] c = {0,0,0,0,0};
		
		//这里要注意下标不能越界,否则会引发ArrayIndexOutOfBoundsException异常
		//输出结果是:3,4,5,6,7
		
		System.arraycopy(a, 2, c, 0, 5);
		for(int i = 0; i < c.length;i++)
			System.out.print(c[i]);
		
		
		
	}
}

③currentTimeMillis()

返回从1970.1.1 零点到现在的时间,单位是毫秒,通常用来计算程序运行耗费的时间

使用实例:

package com.jay.example;

public class CurrentTimeMillisTest {
	public static void main(String[] args) {
		long start,end;
		int j = 0,k=0;
		//记录起始时间
		start = System.currentTimeMillis();
		for(int i = 0;i < 1000;i++)
			for(j = 0;j < 1000;j++)
			{
				k++;
			}
		//记录结束时间
		end = System.currentTimeMillis();
		//结束时间-起始时间,即可算出两层for循环的运行时间
		//这个是电脑配置是有一定关系的！不同电脑的结果可能不同！我的电脑是1毫秒
		System.out.println("循环1000次消耗了" + (end - start) + "毫秒");
	}
}

String类

相关操作:

①字符串的连接:用"+"加号可以连接成字符串,比如: 123 + "" = "123"
②求字符串的长度:  str.length()
③求子串:str.subString(开始下标,"结束下标")    //注意是从0开始算的,截取到结束下标 - 1;或者这样算:子串长度 = :结束 - 开始
④判断是否相等:这里要注意==这个比较的是字符串是否存储在同一位置!如果是比较内容我们要用equals("");
⑤返回给定下表处的字符:   str.charAt(int index);  //从0开始算的
⑥将指定字符串连接到字符串的尾部: str.concat("HeHe");
⑦检索某字符在字符串中第一次出现的下标:  str.indexOf("a");
⑧检索某字符在字符串中最后一次出现的下标：str.lastIndexOf("a")；
⑨去掉头尾的空白:str.trim(),这个在数据库操作中比较常用
⑩替换字符串中的某段: str.replace("想替换的字符串","替换后的字符串");
11.比较两个字符串的大小,无视大小写：str.equalsIgnoreCase(stg);
12.全部字符转化为小写:str.toLowerCase()
13.全部字符转化为大写:str.toUpperCase();

字符串比较:

首先,我们要知道字符串和普通对象的不同,字符串都存放在一个字符串池中,

当我们新建一个字符串时,不是直接就开辟一个内存空间;而是先比较下字符串池中

是否有相同的字符串内容,如果有相同的内容的话,直接将该引用指向此处字符串内容

所以为什么相同内容字符串用"=="比较结果是true,"=="比较的是两对象是否为同一类实例的引用(地址)

但是要注意:如果是new String的话,那么是不等的！！！！

当然也可以直接用equals(),String类已重写该方法,比较的是内容是否相同

还有一个compareTo(str)方法,如果当前对象大于参数串,返回大于0的数,返回小于0的数.相等,返回0

StringBuffer类

问题引入:

先说下这货是干嘛的:因为String对象内容不可更改,使用该类实现串内容的添加,修改,删除!

什么?你没听错吧,String对象不可修?那String s = "123",s += 321";不见得运行出错或者异常啊?

输出123321,正常啊,那么为什么说String不能够修改?

问题解答:

其实原因是这样的:我们都知道生成的string对象都存放在一个字符串池中;我们上面用到的字符串的拼接;

其实涉及到的是三个字符串对象了: "123","321","123321",而123和321明显都不是我们想要的,我们只要的是123321

这样就有点浪费内存了,Java给我们提供了StringBuffer对象,实现字符串内容的改变,一定程度上减少了内存的消耗

相关方法:

①将某个对象添加到StringBuffer的尾部,每个对象都有toString()方法,所以可以直接添加  :append(对象)

②将某个对象的字符串描述插入到某个位置:  insert(下标,对象)

③替换指定位置的字符:  setCharAt(下标,字符)

④替换指定范围的字符串:  replace(起始下标,结束坐标,替换字符串);

⑤删除指定位置的字符:  deleteCharAt(下标)

⑥删除指定位置的字符串:   delete(起始坐标,结束坐标)

⑦获取子串:   substring(起始坐标,结束坐标)

⑧获取StingBuffer的长度 : length()

⑨反转字符串:   reverse()

相关方法演示代码实例:

package com.jay.example;

/*
 * 该代码演示的是StringBuffer的用法
 * */

public class StringBufferTest {
	
	public static void main(String[] args) {
		//创建StringBuffer对象的方法
		//记住:不能直接赋值,strbuf1 = "123"这样!!
		StringBuffer strbuf1 = new StringBuffer("123");
		StringBuffer strbuf2 = new StringBuffer("123");
		StringBuffer strbuf3 = new StringBuffer("123");
		StringBuffer strbuf4 = new StringBuffer("123");
		StringBuffer strbuf5 = new StringBuffer("123");
		StringBuffer strbuf6 = new StringBuffer("123");
		StringBuffer strbuf7 = new StringBuffer("123");
		StringBuffer strbuf8 = new StringBuffer("123");
		StringBuffer strbuf9 = new StringBuffer("123");
		
		//调用比较方法,都是false,说明和String是有区别的
		System.out.println(strbuf1 == strbuf2);
		System.out.println(strbuf1.equals(strbuf2));		//输出false,false
		
		//将某个对象添加到StringBuffer的尾部
		strbuf1.append("321");
		System.out.println(strbuf1);	 			//输出123321
		
		//插入某个对象到某个位置
		strbuf2.insert(2, "呵呵");     
		System.out.println(strbuf2);     //输出结果：12呵呵3
		
		//替换指定位置的字符,是字符哦！！！
		strbuf3.setCharAt(2, 'a');
		System.out.println(strbuf3);      //输出12a
		
		//删除指定位置的字符
		strbuf4.deleteCharAt(1);
		System.out.println(strbuf4);      //输出13
		
		//删除指定位置的字符串
		strbuf5.delete(0, 2);
		System.out.println(strbuf5);      //输出:3
		
		//获取子串
		System.out.println(strbuf6.substring(0, 2));      //输出12
		
		//获得字符串的长度
		System.out.println(strbuf7.length());			//输出3
		
		//将字符串反转:
		strbuf8.reverse();
		System.out.println(strbuf8);					//输出321
	}
}

java.util包中的几个常用类:

Date类(日期)

Date类是用于封装日期和时间的,通过Date可以指定特定的一个时间.

可以通过我们前面提供的System.currentTimeMillis();方法获得从1970到现在时间的毫秒数！

用法实例:

package com.jay.example;

import java.util.Date;

public class DateTest {
	public static void main(String[] args) {
		//获得创建Date对象的当前日期,CST代表世界统一时间
		Date d1 = new Date();
		System.out.println(d1);    //输出：Mon Apr 14 12:51:46 CST 2014
		
		//也可以设置成离1970.1.1开始经过多少毫秒后的时刻
		Date d2 = new Date(7200000);    
		System.out.println(d2);
		
		//判断d1是否在d2日期后
		System.out.println(d1.after(d2));
		
		//判断d2是否在d1日期前:
		System.out.println(d2.before(d1));
	}
	
	
}

Calendar类(日历类)

用于设置或获取日历字段值,年月日时分秒,该类时抽象类!

使用流程:

通过getInstance():获得当前的系统时间;

通过get()和set()方法获取或者设置时间分量

使用getTime()和setTime()通过Date类对象获取和设置时间值

时间分量:

YEAR(年),MONTH(月),DATE(日),HOUR(时),MINUTE(分),SECOND(秒)

代码示例:

日历类的普通使用:

package com.jay.example;

import java.util.Calendar;

public class CalendarTest {
	public static void main(String[] args) {
		
		//①获得系统的当前日期,并且输出:
		Calendar cd = Calendar.getInstance();
		System.out.print("系统的当前时间为:"+ cd.get(Calendar.YEAR) + "年");
		System.out.print( cd.get(Calendar.MONTH) + "月");
		System.out.print( cd.get(Calendar.MONTH) + "月");
		System.out.print( cd.get(Calendar.DATE) + "日        ");
		System.out.print( cd.get(Calendar.HOUR) + "时");
		System.out.print( cd.get(Calendar.MINUTE) + "分");
		System.out.print( cd.get(Calendar.SECOND) + "秒");
		
		
		//②通过set可以设置Calendar的某个分量的值;有不同的方式,可查api
		cd.set(Calendar.MONTH, 5);
		cd.set(2012, 10, 6);
		
		//③可以把Date对象作为参数传入setTime(new Date())方法,也能获得系统时间
	}
}

Random类(随机数类)

这个什么好讲的= =,知道lang.Math()也有生成随机数的方法和Util中有Random类用于生产随机数;

会自己生成随机数即可:

示例:生成 1~10 随机数的两个方法:

Random方法:(int)(Math.random()*10)

Random类:int num = new Random().nextInt() + 1

ps:如果是想是其他数据类型的随机数只需要把nextInt改为其他类型即可eg:nextFloat();

总结:

在这一节中我们对于Java的常用类进行了解析:

我们认识了所有类的父类Object类,学习了toString(),equals(),clone(),getClass()方法的使用

又学习了封装类,普通数据类型,字符串的相互转换

还学习了Math类的两个常量PI和E,以及相关的常用方法

也学习了System类的exit(),arraycopy(),currentTimeMilis()方法

接着也学习了String和StringBuffer的相关属性,比较了他们的区别

最后学习了util包中的Date,Calendar的用法

当然还有随机生成随机数的两个方法

不要刻意地去死记属性和方法,用到的时候再来查,死记过两天就忘了....

ps:本节就到这里,如果有什么纰漏,错误,好的建议,望读者支出,

万分感激,O(∩_∩)O谢谢！

1楼u014450015昨天 15:16

继续支持