012.java_java.lang包

java.lang包中包含了java语言所需要的最基本的功能类和接口，是进行java语言编程的基础。

Object类

Object类是java语言中所有类的父类，一共定义11个方法。

1.equals( )方法

public boolean equals(Object obj);  //比较指定的参数对象是否与当前对象相等。  根据两个对象的哈希码值决定

2.hashCode( )方法

public int hashCode( ); //返回对象的哈希码值   由该对象在内存中的地址决定的

如果两个相同的对象，返回的哈希码值一定相同；如果两个对象不相同，返回的哈希码值不要求一定不同。

所以为了使不相同的对象返回不同的哈希码值，提高某些集合存取该对象的效率，一般对equals（）和hashCode（）方法进行覆盖（IDE可自动生成）。

3.toString( )方法

public String toString( );//返回的String类型由类名、@符号和此对象的哈希码的十六进制表示组成

为了描述更有效的信息，自定义类一般覆盖toString（）方法。

public class Student {
	private String name;
	private int age;
	private char gender;
	private String grade;
	public Student(String name,int age,char gender,String grade){
		this.name=name;
		this.age=age;
		this.gender=gender;
		this.grade=grade;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + gender;
		result = prime * result + ((grade == null) ? 0 : grade.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (gender != other.gender)
			return false;
		if (grade == null) {
			if (other.grade != null)
				return false;
		} else if (!grade.equals(other.grade))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	public String toString(){
		return "学生姓名："+name+"，年龄："+age+"，性别："+gender+"，班级："+grade;
		
	}
}

public class ObjectDemo {

	public static void main(String[] args) {
		Object obj1=new Object();
		Object obj2=new Object();
		Object obj3=obj1;
		System.out.println("obj1.equals(obj2)"+obj1.equals(obj2));
		System.out.println("obj1.equals(obj3)"+obj1.equals(obj3));
		System.out.println("obj2.equals(obj3)"+obj2.equals(obj3));
		
		System.out.println("obj1.hashCode():"+obj1.hashCode());
		System.out.println("obj2.hashCode():"+obj2.hashCode());
		System.out.println("obj3.hashCode():"+obj3.hashCode());
		
		Student st1=new Student("zz",12,'d',"ds");
		Student st2=new Student("sa",12,'c',"ds");
		Student st3=new Student("zz",12,'d',"ds");
		System.out.println("st1.equals(st2):"+st1.equals(st2));
		System.out.println("st1.equals(st3):"+st1.equals(st3));
		
		System.out.println("st1.hashCode():"+st1.hashCode());
		System.out.println("st2.hashCode():"+st2.hashCode());
		System.out.println("st3.hashCode():"+st3.hashCode());
		
		System.out.println(st1);  //没重写toString()方法前，输出 lesson013.Student@1697ea
		System.out.println(st2.toString());
	}

}

输出结果：

obj1.equals(obj2)false
obj1.equals(obj3)true
obj2.equals(obj3)false
obj1.hashCode():2018699554
obj2.hashCode():1311053135
obj3.hashCode():2018699554
st1.equals(st2):false
st1.equals(st3):true
st1.hashCode():1480682
st2.hashCode():1479479
st3.hashCode():1480682
学生姓名：zz，年龄：12，性别：d，班级：ds
学生姓名：sa，年龄：12，性别：c，班级：ds

4.finalize( )方法

protected void finalize( )//jvm回收一个对象所占有的空间，会调用该方法。

5.getClass( )方法

用于获取该对象所属的类型信息对象。主要用于反射技术的实现

6.clone方法

用来复制对象

基本数据类型的包装类

byte(字节)	java.lang.Byte
char(字符)	java.lang.Character
short(短整型)	java.lang.Short
int(整型)	java.lang.Integer
long(长整型)	java.lang.Long
float(单精度浮点型)	java.lang.Float
double(双精度浮点型)	java.lang.Double
boolean(布尔型)	java.lang.Boolean

public class WrapperDemo {

	public static void main(String[] args) {
		/*基本类型与包装类型之间的转换*/
		int i=1000;
		Integer inr1=new Integer(i);//把基本数据类型转换为对象数据类型称为装箱  
		int j=100;
		j=inr1.intValue();  //与j=i; 相同    把对象数据类型转化为基本数据类型称为拆箱
		System.out.println("i:"+i+",j:"+j);
		
		/*字符串类型与包装类型之间的转换*/
		Integer inr2=new Integer("12");//只能传入int型参数  不能为空
		Integer inr3=Integer.valueOf("45");//不能为空    静态转换
		String str1="";
		str1=inr2.toString();
		System.out.println(str1);  //输出 12
		
		/*基本类型和字符串类型之间的转换
		 * 一般用包装类实现*/
		
		/*字符串到基本类型*/
		int m=Integer.parseInt("123");  //等价于 m=123;
		
		/*基本类型到字符串*/
		String str2=Integer.toString(m);
//		String str3=m+"zz";
		System.out.println(str3);  //输出123zz
	}

}

运行结果：

i:1000,j:1000
12
123zz

枚举类型和枚举类

枚举类型是指由一些固定常量组成合法值的类型。如一年四级、一个星期的七天等。枚举类型通过关键字enum来定义。

枚举类型对应的类是java.lang.Enum类的子类，枚举类型的值直接用“类型名.枚举值”访问。

package lesson015;
/*枚举类型*/
public enum Year {
	YearSPRING,YearSUMMER,YearAUTUMN,YearWINTER;
}

package lesson015;
/*状态枚举类型
 * */
public enum Status {
	ACTIVE("可用",100),INACTIVE("不可用",-100);
	private final String name;//final成员
	private final int value;//final成员
	Status(String name,int value){
		this.name=name;
		this.value=value;
	}
	public String toString(){
		return name;
	}
	public int getvalue(){
		return value;
	}
}

package lesson015;

public class EnumTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Year Yearmy2018=Year.YearSPRING;
		System.out.println(Yearmy2018);
		
		Year[] ys=Year.values();//获取枚举类型所有的参数
		for(Year y:ys){
			System.out.println(y);
		}//遍历输出枚举类型的参数
		
		switch(Yearmy2018){
		case YearSPRING:              //case标签后面的枚举值可以不用枚举类型引用
			System.out.println("春天");
			break;
		case YearSUMMER:
			System.out.println("春天");
			break;
		case YearAUTUMN:
			System.out.println("春天");
			break;
		case YearWINTER:
			System.out.println("春天");
			break;
		}
		
		
		Status account_status=Status.ACTIVE;
		System.out.println("文章状态："+account_status);
		System.out.println("此状态对应值："+account_status.getvalue());
	}

}

运行结果：

YearSPRING
YearSPRING
YearSUMMER
YearAUTUMN
YearWINTER
春天
文章状态：可用
此状态对应值：100

如果在类的内部定义一个枚举类型，那么使用时就要用“类名.枚举类型名.枚举值”访问

Math类

Math类是一个数学工具类，它提供两个常量属性和一些方法。声明格式为：

public final class Math extends Obiect{ ... }

由此看出，Math类是一个final类，不能被继承；此外，Math类构造器为私有，不能用来创建对象；Math类的所有方法和属性都是静态的，可以直接用类名来调用。

Math类中的一些常用方法

double sin(double a)	计算角a的正弦值
double cos(double a)	计算角a的余弦值
double pow(double a,double b)	计算a的b次方
double sqrt(double a)	计算a的平方根
int/... abs(int/long/float/double a)	计算a的绝对值
double ceil(double a)	返回大于等于a的最小整数的double值
double floor(double a)	返回小于等于a的最大整数的double值
int max(int/long/float/double a,int b)	返回int型值a和b中的最大值
int min(int a,int b)	返回int型a和b中的最小值
int round(float a)	四舍五入返回整数
double random()	随机返回带正号的double值，该值大于等于0.0且小于1.0

public class MathTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		double a=45.3,b=23,c=60.8;
		System.out.println(Math.sin(60));
		System.out.println(Math.ceil(a));
		System.out.println(Math.max(a,b));
		System.out.println(Math.max(c, Math.max(a, b)));
		System.out.println(Math.round(c));
		System.out.println(Math.random()); 
	}

}

运行结果：

-0.3048106211022167
46.0
45.3
60.8
61
0.610307780324408

System类

System类提供标准输入输出和错误输出流，对外部属性和环境变量的访问，加载文件和库的方法。

与Math类相似，为final类，构造器为私有，静态属性和方法，直接用类名访问。

1.获取标准输入输出和错误流。

定义三个public static final属性，分别代表标准输入流（键盘输入）、标准输出流（命令行、控制台）和标准错误输出流（命令行/控制台）。最常用的System.out.print();//向标准设备输出数据

2.数组拷贝 arraycopy

public static void arraycopy (Object src,int srcPos,Obiect dest,int destPos,int length)

把指定源数组src中指定索引srcPos开始的元素内容复制到目标数组dest中指定索引destPos处，总共复制length个元素。

public class SystemArrayCopyTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] x={1,22,333,4444};
		int[] y=new int[10];
		System.arraycopy(x,0,y,2,3);//把指定源数组x中指定索引0开始的元素内容复制到目标数组y中指定索引2处，总共复制3个元素。
		/*for-each遍历数组
		 * 
		 * for(数据类型 变量名：数组或集合变量名){  //数据类型与声明数据时的数据类型相同
		 * 	//通过变量名就可以访问每个数组成员
		 * }
		 * */
		for(int i:y){ 
			System.out.print(i+" ");
		}
	}

}

运行结果：

0 0 1 22 333 0 0 0 0 0 

3.获取当前时间

public static long currentTimeMillis( )//返回值为当前计算机时间与GMT（格林威治）时间的时间差，以毫秒为单位

nanoTime（）//返回值以微毫秒为单位

public class CurrentTimeMillisTest {
	/*计算test()方法执行时间*/
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		long star=System.currentTimeMillis();
		System.out.println(test());
		long end=System.currentTimeMillis();
		System.out.println("test()方法执行耗时："+(end-star)+"毫秒");
	}

	private static long test() {
		// TODO Auto-generated method stub
		long cout=0;
		for(int i=0;i<100000;i++){
			cout=cout+i;
		}
		return cout;
	}

}

运行结果：

4999950000
test()方法执行耗时：2毫秒

4.获取或设置属性

public static Properties getProperties( )//获取属性

public static void getProperty(String key)

public static String setProperty(String key,String def)

系统属性以及属性的用途

file.separator	与系统有关的文件路径分隔符 Windows中为“\”  Unix、    Linux系统中是“/”
file.encoding	平台默认的编码方式
java.class.path	类路径列表
java.home	JRE安装目录
java.version	JRE版本号
java.io.tmpdir	临时文件存放目录
line.separator	与系统有关的换行符 Windows中为“\r\n”  Unix、    Linux系统中是“\n”
os.name	操作系统名
os.version	操作系统版本
os.arch	当前系统架构
user.name	用户的账户名
user.home	用户的主目录
suer.dir	用户的工作目录

public class SystemPropertyTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("编码方式:"+System.getProperty("file.encoding"));
		System.out.println("当前系统名:"+System.getProperty("os.name"));
		/*...*/
	}

}

运行结果：

编码方式:GBK
当前系统名:Windows 10

5.获取系统的环境变量

System类的getenv(String name)来获取

public class SystemEnvTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("系统环境变量PATH：\n"+System.getenv("PATH"));
		System.out.println("系统环境变量CLASSPATH：\n"+System.getenv("CLASSPATH"));
		System.out.println("系统环境变量TMP：\r"+System.getenv("TMP"));
	}

}

运行结果：

系统环境变量PATH：
C:/Program Files/Java/jre1.8.0_131/bin/server;C:/Program Files/Java/jre1.8.0_131/bin;C:/Program Files/Java/jre1.8.0_131/lib/amd64;C:\ProgramData\Oracle\Java\javapath;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\Java\jdk1.8.0_131\bin;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\Program Files\mysql-5.7.18-winx64\bin;C:\MinGW\bin;C:\Users\zzq\AppData\Local\Microsoft\WindowsApps;C:\Program Files\mysql-5.7.18-winx64\bin;;D:\Eclipse\eclipse;
系统环境变量CLASSPATH：
.;C:\Program Files\Java\jdk1.8.0_131\lib\dt.jar;C:\Program Files\Java\jdk1.8.0_131\lib\tools.jar;
系统环境变量TMP：
C:\Users\zzq\AppData\Local\Temp

6.运行垃圾回收器

System提供静态gc方法提醒jvm回收未使用对象，调用该方法后，不是立即回收

7.推出虚拟机

System类的exit方法来强制终止当前正在运行的jvm。

Runtime类

用于本应用程序与其运行的环境进行信息交互，一个应用程序只能通过Runtime类提供的getRuntime( )静态方法来获取唯一的实例。

1.获取运行时的内存情况

package lesson018;

public class RuntimeTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Runtime runtime=Runtime.getRuntime();
		System.out.println("本jvm可用cpu数目："+runtime.availableProcessors());
		System.out.println("本JVM可用的最大内存量"+runtime.maxMemory()+"字节");
		System.out.println("本JVM当前使用的内存量"+runtime.totalMemory()+"字节");
		System.out.println("本JVM当前空闲的内存量"+runtime.freeMemory()+"字节");
	}
/*每个jvm默认可用的最大内存为64MB */
}

运行结果：

本jvm可用cpu数目：4
本JVM可用的最大内存量1890582528字节
本JVM当前使用的内存量128974848字节
本JVM当前空闲的内存量126930104字节

用java.exe运行时，碰到"找不到或无法加载主类"问题：

http://www.cnblogs.com/wangxiaoha/p/6293340.html

通过java.exe运行程序添加选项“ -Xmx”来指定最大内存量（默认64MB）.

使用“-Xms”指定程序立即使用的内存量。

2.执行指定的命令

Runtime提供了几个用于在单独的进程中执行指定的字符串命令方法。可调用系统自带程序执行命令。

最常用的执行命令方法：

public Process exec(String command)throws IOException

package lesson018;
/*运行程序两个条件
 * 1.安装winRAR 且目录配置正确
 * 2.存在d:\\src和d:\\dest目录
 * */
public class WinRARTest {
	private static String rarPath="c:\\Program Files\\WinRAR\\rar";//WinRAR安装目录
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		rar("d:\\qiujy.rar","d:\\src");
		unrar("d:\\qiuijy.rar","d:\\dest");
		
	}
	private static void unrar(String srcPath, String destfolderPath)throws RuntimeException {
		// TODO Auto-generated method stub
		String cmd=rarPath+" x -o"+srcPath+" "+destfolderPath;//解压命令
		try{
			Process pro=Runtime.getRuntime().exec(cmd);
			if(pro.waitFor()!=0){
				System.out.println("解压失败，返回值为："+pro.exitValue());
			}
		}catch(Exception e){
			throw new RuntimeException("解压失败",e);
		}
	}
	
	/*把源文件中的所有文件和目录压缩到目标文件目录中
	 * destPath:目标压缩文件路径
	 * srcfolderPath:源目录路径
	 * RuntimeException  压缩失败的异常类型*/
	private static void rar(String destPath, String srcfolderPath)throws RuntimeException {
		// TODO Auto-generated method stub
		String cmd=rarPath+"a"+destPath+" "+srcfolderPath;//压缩命令
		try{
			Process pro=Runtime.getRuntime().exec(cmd);//在子进程中压缩
			/*等该进程结束后，判断其出口值是否为0（为0是正常结束）*/
			if(pro.waitFor()!=0){
				System.out.println("压缩失败，返回值为"+pro.exitValue());
			}
		}catch(Exception e){
			throw new RuntimeException("压缩失败",e);
		}
	}

}

String类

String类代表不可变的字符串，是由多个字符组成，存储大量信息会用到它。

1.字符串的初始化

字符串常用的构造器

String()	初始化新建一个String对象，它表示一个空字符序列
String(byte[] bytes)	构造一个新的String，使用平台默认字符集解码指定的字节数组
String(byte[]bytes,String charsetName)	构造一个新的String，使用指定的字符集解码指定的字节数组
String(char[]value)	分配一个新的String，它表示当前字符数组参数中包含的字符序列
String(String original)	初始化一个新创建的String对象，表示一个与该参数相同的字符序列

使用构造器来初始化一个数组

String str=new String("zz");

String str="zz"  //第二种更高效

2.常用操作

获取字符串长度    通过length属性

字符串内容比较   使用equals方法比较两个字符串内容是否相同；“==”方法比较两个字符串是否引用同一个字符串变量

字符串比较方法

方法	说明
boolean equalsIgnoreCase(String val)	比较两个字符串，忽略大小写形式
int compareTo(String value)	按字典顺序‘a’＜‘b’比较两个字符串 如果相等，返回0 如果该字符串在参数值之前，返回值小于0 如果该字符串在参数值之前，返回值大于0
int compareToIgnoreCase(String val)	按字典顺序比较两个字符串，不考虑大小
boolean startsWith(String value)	检查一个字符串是否以参数字符串开始
boolean endWith(String calue)	检查一个字符串是否以参数字符串结束

字符串内容搜索：

public int indexOf(char ch)	返回指定字符ch第一次在该字符串出现处的索引值，如果未找到，返回-1
public int indexOf(char ch,int fromIndex)	返回指定字符ch第一次出现处的索引值，从指定索引处开始寻找
public int indexOf(String str)	返回该字符串第一次出现处的索引值，如果未找到，返回-1
public int indexOf(String str,int fromIndex)	返回指定字符串str第一次出现处的索引值，从指定索引处开始寻找
public int lastIndexOf(char ch)	返回指定字符ch最后一次在该字符串出现处的索引值，如果未出现，返回-1
public int lastIndexOf(String str)	返回指定字符串String最后一次在该字符串出现处的索引值，如果未出现，返回-1
public char charAt(int index)	从index索引处提取单个字符，索引中的值必须为负。

字符串修改：

public String subString(int dex)	提取从索引dex到字符串末尾的这段子串
public String subString(int beginIndex,int endIndex)	提取从beginIndex到endIndex（不包括此位置）的字符串
public String concat(String str)	将str添加到此字符串结尾，并将所得的字符串返回
public String replace(char oldChar,char newChar)	用newChar替换字符串中的oldChar，返回所得字符串
public String trim()	返回字符串的副本，忽略前导空白和尾部空白
public String toUpperCase()	将此字符串中所有字符变为大写
public String toLowerCase()	将此字符串中所有字符变为小写

其它数据类型转换为字符串

在String类中定义了一些重载的静态valueOf方法，用以将各种类型的数据转换为字符串。

public class StringTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1="abc123";
		String str2=new String("abc123");
		String str3="abc123";
		String str4="aBc123";
		String str5="abc1234";
		/*获取字符串长度*/
		System.out.println("/*获取字符串长度*/");
		System.out.println(str1.length());
		/*比较两个字符串*/
		System.out.println("/*比较两个字符串*/");
		System.out.println(str1==str2);
		System.out.println(str1.equals(str2));
		System.out.println(str1==str3);
		System.out.println("-------------");
		System.out.println(str1.equals(str4));
		System.out.println(str1.equalsIgnoreCase(str4));//忽略大小写
		System.out.println("-------------");
		System.out.println(str1.compareTo(str4));
		System.out.println(str1.compareToIgnoreCase(str4));
		System.out.println("-------------");
		System.out.println(str1.startsWith(str2));//str4  str5  :false    
		System.out.println(str1.endsWith(str2));//str4  str5  :false   
		System.out.println("-------------");
		/*字符串内容搜索*/
		System.out.println("/*字符串内容搜索*/");
		String m="qiyong@gmail.com";
		System.out.println("m的索引是："+m.indexOf('m'));//在字符串的中下标为6
		System.out.println("从8往后，m的索引是："+m.indexOf('m', 8));//从8往后，m的索引是：8
		System.out.println("从9往后，m的索引是："+m.indexOf('m', 9));
		System.out.println("-------------");
		System.out.println("m最后出现处的索引值"+m.lastIndexOf('m'));
		System.out.println("-------------");
		System.out.println("从索引6处提取单个字符："+m.charAt(6));
		/*字符串修改*/
		System.out.println("/*字符串修改*/");
		String st1="Hello World!";
		String st2="Hello";
		String st3=" World！";
		System.out.println(st1.substring(2));
		System.out.println(st1.substring(2, 8));//提取下表为（包括）2到下标为（不包括）8的字符串  "llo Wo"
		System.out.println(st2.concat(st3));
		System.out.println(st1.replace('l', 'z'));
		System.out.println(st3.trim());//返回字符串副本，忽略前导空白和尾部空白  "World！"
		System.out.println(st1.toLowerCase());
		/*其它类型转换为字符串*/
		String str=String.valueOf(new Object());//  传入参数类型还可为int float..
		System.out.println(str);//包名@哈希码值
		
	}

}

运行结果：

/*获取字符串长度*/
6
/*比较两个字符串*/
false
true
true
-------------
false
true
-------------
32
0
-------------
true
true
-------------
/*字符串内容搜索*/
m的索引是：8
从8往后，m的索引是：8
从9往后，m的索引是：15
-------------
m最后出现处的索引值15
-------------
从索引6处提取单个字符：@
/*字符串修改*/
llo World!
llo Wo
Hello World！
Hezzo Worzd!
World！
hello world!
java.lang.Object@7852e922

StringBuilder和StringBuffer类

StringBuilder和StringBuffer类代表可变的字符串，适用于字符串内容进行频繁修改的情况。

StringBuilder和StringBuffer类提供了相同的操作方法。StringBuilder类的方法不保证线程同步，StringBuffer类的方法保证线程同步。

StringBuilder类的构造器：

StringBuilder()：用以构造一个其中不带字符的字符串生成器，初始容量为16个字符。

StringBuilder(String str)：构造一个字符串生成器，将其内容指定为给定字符串内容。

StringBuilder类的常用方法：

StringBuilder append (String str)	将指定的字符串追加到此字符串序列
StringBuilder insert(int offset,String str)	将字符串str插入到offset位置
int length()	确定StringBuilder的长度
void setCharAt(int pos,char ch)	将pos位置的字符改为ch
String toString()	转换为字符串形式
StringBuilder reverse()	反转字符串
StringBuilder delete(int star,int end)	删除从star位置到end-1位置的字符
StringBuilder deleteCharAt(int pos)	删除pos指定位置的字符
StringBuilder replace(int star,int end,String s)	用一组字符替换另一组字符。从star开始到end结束

public class StringBuilderTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder sb=new StringBuilder("CoreJava");
		System.out.println(sb);
		System.out.println(sb.append(" Action "));
		System.out.println(sb.append(1.0));
		System.out.println(sb.insert(9, "In "));//在下标为9的位置插入
		String s=sb.toString();
		System.out.println(s);
	}

}

运行结果：

CoreJava
CoreJava Action 
CoreJava Action 1.0
CoreJava In Action 1.0
CoreJava In Action 1.0