Java_API-常用类

内容概述

• Object类/Scanner类
• String类/StringBuffer类/StringBuilder类
• 数组高级和Arrays类
• 基本类型包装类(Integer,Character)
• 正则表达式(Pattern,Matcher)
• Math类/Random类/System类
• BigInteger类/BigDecimal类
• Date类/DateFormat类/Calendar类

一、Object类/Scanner类

Object类

/*
 * java.lang.Object：类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 
 * 1.在编写代码时，只有在使用java.lang下的类时，无需导包。其它包的类都需要导包；
 * 2.java.lang包下包含了大量的常用类。我们可以直接使用，无需导包；
 * 3.关于Object类：
 * 		1).它是所有引用数据类型(包括数据)的父类；
 * 		2).所有的类(包括Java类库中的类、我们的自定义类、数组)都隐式的继承自Object;
 * 		3).Object的构造方法：
 * 				Object()
 *		4).Object的常用方法：
				public int hashCode()：返回哈希码值。是一个int值。同一个对象，多次调用此方法会返回相同的hashCode;

							不同的对象，会返回不同的hashCode;内部是根据对象的地址产生的哈希值；
					//功能：用于哈希表结构的键值
					//默认实现：将此对象的地址转换为int值返回；
					//此方法建议子类重写；
				public final Class getClass():返回此 Object 的运行时类。
					//功能：获取此对象的Class对象
					//此方法不能被子类重写
				public String toString()：返回该对象的字符串表示。一般子类重写：将内部的所有属性的值封装为一个String并返回；
					//功能：返回此对象的字符串表现形式；
					//默认实现：全名限定的类名 + @ + hashCode(无意义)
					//此方法建议子类重写；
				public boolean equals(Object obj)：比较当前对象与参数对象是否"相等"；
					//功能：将当前对象与参数对象进行比较
					//默认实现：比较地址(跟==的结果是一样的)
					//此方法建议子类重写；
				这里区别一个运算符：==
				判断运算符：==h
					1.如果两边是基本数据类型，比较的值是否相等；
					2.如果两边是"引用数据类型"，比较的是"引用(地址)"是否相等；
				equals方法：
					1.只能判断引用数据类型； 
					2.在Object类中定义，任何类都会继承此方法；
					3.在Object类中默认实现：判断两个对象的地址是否相同；
					4.我们一般都会重写此方法，判断对象内部的属性值是否全部完全相同；
				protected void finalize():当垃圾回收器回收此对象的内存空间前，会自动调用此方法；
					//功能：当前对象在被垃圾回收器回收前，由垃圾回收器自动调用的方法。一般用于做些释放内存的操作；
					//默认实现：无
					//此方法根据需要由子类重写(一般我们不用)
				protected Object clone():复制当前对象的副本；
					//功能：复制此对象的副本；
					//默认实现：本地方法
					//一般子类无需重写；
 */

public class Demo {
	public static void main(String[] args) {
		Student stu = new Student();
		//1.hashCode();
		System.out.println(stu.hashCode());
		System.out.println(stu.hashCode());
		Student stu1 = new Student();
		Student stu2 = new Student();
		System.out.println(stu1.hashCode());
		System.out.println(stu2.hashCode());
		//2.getClass():
		Class c = stu.getClass();
		System.out.println(c.getName());
		System.out.println(c.getModifiers());
		System.out.println(c.getPackage().getName());
		//3.toString();
		stu.setName("张三");
		stu.setAge(20);
		stu.setSex('男');
		System.out.println("stu.toString() : " + stu.toString());
		//4.equals():
		Student stu11 = new Student("张三",20,'男');
		Student stu22 = new Student("张三",20,'男');
		//==：判断地址是否相等
		System.out.println("stu11 == stu22 : " + (stu11 == stu22));
		//判断内部的成员的值，是否完全相同；
		System.out.println("成员的值是否完全相同：" + (stu11.getName().equals(stu22.getName()) &&
												stu11.getAge() == stu22.getAge() &&
												stu11.getSex() == stu22.getSex()));
		System.out.println("stu11.equals(stu22) : " + stu11.equals(stu22));
		Student stu33 = new Student();
		stu33 = null;
		//运行垃圾回收器
		System.gc();
		//复制对象
		Student stu44 = new Student();
		stu44.setName("刘德华");
		stu44.setAge(20);
		stu44.setSex('男');
		Student stu55 = new Student();    
		stu55.setName(stu44.getName());
		stu55.setAge(stu44.getAge());
		stu55.setSex(stu44.getSex());
		Student stu66 = (Student) stu44.clone();
		System.out.println("stu44 == stu66 : " + (stu44 == stu66));//false
		System.out.println(stu66.getName() + "," + stu66.getAge() + "," + stu66.getSex());
		
	}
}

public class Student implements Cloneable{
	private String name;
	private int age;
	private char sex;
	public Student() {
		super();
	}
	public Student(String name, int age, char sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	//重写父类的方法
	/*public boolean equals(Object obj){
		if(this == obj){
			return true;
		}
		if(!(obj instanceof Student)){
			return false;
		}
		Student stu = (Student)obj;
		return this.name.equals(stu.name) &&
				this.age == stu.getAge() &&
				this.sex == stu.getSex();
		
	}*/
	
	//重写父类Object的方法；
	public String toString(){
		return "Student [姓名 = " + this.name + 
							", 年龄 = " + this.age + ",性别 = " + 
							this.sex + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + sex;
		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 (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (sex != other.sex)
			return false;
		return true;
	}
	
	public void finalize(){
		System.out.println("我要被垃圾回收器回收了，最后一句话：拜拜！！");
	}
	public Object clone(){
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
}

Scanner类

/*
 * 之前我们了解了Scanner类的
 * 		1.next()：读取一个字符串
 * 		2.nextInt()：读取一个int值
 * 		3.nextDouble()：读取一个double值
 * 之前，我们的nextInt()方法，如果用户输入了非数字，就会出现异常；
 * 在Scanner类中，有一些：hasNextXxxx()方法，这些方法可以先期判断
 * 是否能够获取一个Xxxx的值，如果可以，此方法返回true，否则返回false;
 */
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(true){
			System.out.println("请输入一个数：");
			if(sc.hasNextInt()){
				int n = sc.nextInt();
				System.out.println("你输入的数是：" + n);
				break;
			}else{
				System.out.println("你输入数字无效！");
				sc = new Scanner(System.in);
			}
		}
	}
}

二、String类/StringBuffer类/StringBuilder类

java.lang.String类

0.此类被定义为final，不能被继承；
1.一个"字符串"对象；
2.一个"引用数据类型"；
3.使用方式：
	String s1 = "abc";(常用、存储的是常量池中的地址)
	或：
	String s1 = new String("abc");(存储的是堆中的地址)(在内存中创建了两个对象：1.常量池："abc"；2.堆：new String())
4.特点：其"值"的内容不能改变(地址可以改变)；
	String str = "你好";
	str = "Java";//原值被丢弃，存储了新的地址；
5.常见面试题：
	String s1 = "abc";
	String s2 = "abc";
	System.out.println(s1 == s2);//true
-----------------------------------------------------------------------------------------------------
	String s1 = "Hello";
	String s2 = "World";
	String s3 = "HelloWorld";
	String s4 = "Hello" + "World";
	String s5 = s1 + s2;
	String s6 = "Hello" + s2;
	String s7 = s1 + "World";
	String s8 = new String("Hello");
	System.out.println(s3 == s4);//true
	System.out.println(s3 == s5);//false
	System.out.println(s3 == s6);//false
	System.out.println(s3 == s7);//false
	System.out.println(s1 == s8);//false;
6.构造方法：
	public String()：构造一个空字符串。效果同String str = "";
	public String(byte[] bytes):使用一个byte[]数组构造一个字符串；
	public String(byte[] bytes,int offset,int length)：使用byte[]数组的一部分构造一个字符串；
	public String(char[] value)：使用一个字符数组构造一个字符串；
	public String(char[] value,int offset,int count)：使用字符数组的一部分构造一个字符串；
	public String(String original)：使用一个字符串构造一个字符串；
7.常用方法：----注意：以下方法返回String的，都是生成一个新字符串，原字符串不变；
	1).判断功能：
		boolean equals(Object obj):重写父类的方法。与参数字符串比较，如果包含一样的字符序列则返回true，否则返回false;
		boolean equalsIgnoreCase(String str):作用与equals()相同；但此方法不区分大小写；
		boolean contains(String str):判断是否包含参数字符串；
		boolean startsWith(String str):判断字符串是否以参数字符串开头；
		boolean endsWith(String str):判断字符串是否以参数字符串结尾；
		boolean isEmpty():判断字符串是否是"空字符串"；
	2).获取功能：
		int length()：获取此字符串内部的字符数量。(区分数组的length属性)
		char charAt(int index)：获取此字符串中index位置的字符char;
		int indexOf(int ch)：从左向右查找，获取字符ch在字符串中第一次出现的位置。如果不包含，则返回：false
		int indexOf(String str)：获取字符串str在此字符串中第一次出现的位置。
		int indexOf(int ch,int fromIndex)：从fromIndex位置开始，查找字符ch。
		int indexOf(String str,int fromIndex)：从fromIndex位置开始，查找str。
		String substring(int start)：从start(包含)开始，截取到此字符串的末尾；返回一个新字符串，原字符串不变；
		String substring(int start,int end)：从start(包含)到end(不包含)截取字符串；返回一个新字符串，原字符串不变；
	3).转换功能：
		byte[] getBytes()：将字符串转换为一个byte[]数组。
		char[] toCharArray()：将字符串转换为一个char[]数组；
		static String valueOf(char[] chs)：静态方法，将一个char[]数组转换为一个String
		static String valueOf(int i)：静态方法，将一个int转换为一个String
		String toLowerCase()：转换为小写；
		String toUpperCase()：转换为大写；
		String concat(String str)：将参数字符串添加到本字符串的末尾。
	4).替换功能：
		String replace(char old,char new)：使用new字符替换本字符串中的所有old字符；
		String replace(String old,String new)：使用new字符串替换本字符串中的所有old字符串；
	5).其它功能：
		String trim():去掉字符串两边的空格；不包括中间的。
		int compareTo(String str)：重写Comparable接口的方法。按Unicode编码表的顺序与参数字符串比较；
			System.out.println("a".compareTo("b"));//-1
			System.out.println("a".compareTo("a"));//0
			System.out.println("b".compareTo("a"));//1
		int compareToIgnoreCase(String str):不区分大小写的比较；

练习_统计大串中小串出现的次数

/*
 * 统计大串中小串出现的次数
 * 举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次
 */
public class Demo {
	public static void main(String[] args) {
		String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
		int count = 0;//计数器
		int index = str.indexOf("java");
		while(index != -1){
			count++;
			index = str.indexOf("java",index + 1);
		}
		System.out.println("出现的次数：" + count);
	}
}

StringBuffer类/StringBuilder类

StringBuffer类：
	1.String的缓冲池类。
	2.String和StringBuffer的区别：
		1).String:其"值"不可变；
		2).StringBuffer:其"值"可变；
	  当我们多次进行字符串的拼接等操作时，使用String会产生大量的垃圾空间。建议使用此类；
	2.构造方法：
		public StringBuffer()：初始容量16
		public StringBuffer(int capacity)：初始容量capacity
		public StringBuffer(String str):使用String构造一个StringBuffer。
	3.添加功能：
		public StringBuffer append(String str)：及各种重载的方法。将任何类型的参数添加到末尾；
		public StringBuffer insert(int offset,String str)：将一个String插入到offset位置。原位置上的字符依次后移；
	4.删除功能：
		public StringBuffer deleteCharAt(int index)：删除index位置上的字符
		public StringBuffer delete(int start,int end)：删除start到end - 1处的所有字符；
	5.替换功能：
		public StringBuffer replace(int start,int end,String str)：将start到end处的所有字符替换为str;
	6.反转功能：
		public StringBuffer reverse()：反转内部字符串；
	7.截取功能：
		public String substring(int start)：截取从start到结尾，返回一个新字符串；
		public String substring(int start,int end)：截取从start到end -1处的所有字符；
StringBuffer类和StringBuilder类的区别：
		1.StringBuffer是线程安全的；
		2.StringBuilder是线程不安全的；

String和StringBuffer的相互转换

/*
 * String和StringBuffer的相互转换
 * String --> StringBuffer:
 * 		1.StringBuffer的构造方法：
 * 				StringBuffer buf = new StringBuffer("Hello");
 * 		2.StringBuffer的append()方法
 * 				StringBuffer buf = new StringBuffer();
 * 				buf.append("Hello");
 * StringBuffer --> String:
 * 		1.全部：StringBuffer的toString():
 * 		2.部分：StringBuffer的substring():
 */
public class Demo {
	public static void main(String[] args) {
		//1.String --> StringBuffer
		String str = "Hello";
		//--构造方法
		StringBuffer buf1 = new StringBuffer(str);
		System.out.println(buf1);
		//--append
		StringBuffer buf2 = new StringBuffer();
		buf2.append(str);
		System.out.println(buf2);
		//2.StringBuffer --> String
		//--全部：toString()
		String s1 = buf2.toString();
		System.out.println(s1);
		//--部分：substring()
		String s2 = buf2.substring(2);//llo
		System.out.println(s2);
	}
}

三、数组高级和Arrays类

冒泡排序

/*
 * 冒泡排序：
 * 将两个相邻的数字进行比较，如果第一个数比第二个数大，就交换，一直比较到最后，将把最大值移动到数组的末尾；
 * 将上述的程序再次执行，将把数组中第二大的数字移到数组的后边，依次类推，反复比较。
 */
public class Demo {
	public static void main(String[] args) {
		int[] array = {1432,432,6543,523,43,867};
		for(int i = 0;i < array.length - 1;i++){//外层循环控制循环次数；一共比较多少"轮"
			for(int j = 0; j < array.length - 1 - i ; j++){//判断每个数跟后边的数进行比较，并交换
				//判断
				if(array[j] > array[j + 1]){
					//交换
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		//遍历数据，查看效果
		for(int i = 0;i < array.length ; i++){
			System.out.println(array[i]);
		}
	}
}

选择排序

/*
 * 选择排序：
 * 1.是将每个数，与它后边的每个数依次进行比较
 */
public class Demo {
	public static void main(String[] args) {
		int[] array = {21,43,24,4365,42,42,554,76,57,3,66,96};
		for(int i = 0;i < array.length - 1 ; i++){
			for(int j = i + 1 ; j < array.length ; j++){
				if(array[i] > array[j]){
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			} 
		} 
		//遍历检查结果
		for(int i = 0;i < array.length ; i++){
			System.out.println(array[i]);
		}
	}
}

二分查找

/*
 * 二分查找：
 * 注意：对要查找的数组，一定要先排序，后查找；
 */
public class Demo {
	public static void main(String[] args) {
		int[] array = {10,20,30,40,50};
		int start = 0;
		int end = array.length - 1;
		int mid = (start + end) / 2; //第一次找的索引
		int num = 50;	//要找的数
		boolean flag = false;
		while(start <= end){
			if (  num  <  array [ mid ]  ){//往左走
				end = mid - 1;
			}else if( num > array[ mid ] ){ // 往右走
				start = mid + 1;
			}else {
				flag = true;
				break;
			}
			mid = (start + end) / 2;
		}
		if(flag){
			System.out.println("找到数字：索引为：" + mid);
		}else{
			System.out.println("数字没找到 ！");
		}
	}
}

Arrays类

	1.对数组操作的类，没有构造方法，内部包含了大量静态的工具方法；
	2.常用方法：
		1).public static String toString(int[] a)：将int[]数组转换为String的表示形式；
		2).public static void sort(int[] a)：升序排序int[]数组；
		3).public static int binarySearch(int[] a,int key)：二分查找int[]数组中的key值；

四、基本数据类型包装类(Integer,Character)

包装类

		基本数据类型	包装类型
		byte			Byte
		short			Short
		int				Integer
		long			Long
		char			Character
		float			Float
		double			Double
		boolean			Boolean

Integer类

		1.内部可以包含一个int值。还包含了其它一些对int值操作的方法；
		2.构造方法：
			1).Integer(int value):将一个int值转换为Integer;
			2).Integer(String s):将一个String转换为Integer;
		3.int和String的相互转换：
			1).String --> int：
				A.Integer-->int parseInt(String s) --> int
				B.Integer-->Integer valueOf(String s) --> intValue() --> int
			2).int --> String:
				A.String --> String valueOf(int n) --> String
				B.Integer -->String toString(int t) --> String 
		4.常用方法：
			public int intValue()：返回Integer内部的int值
			public static int parseInt(String s)：将String转换为int			
			public static String toString(int i)：将int转换为String
			public static Integer valueOf(int i)：将int转换为Integer
			public static Integer valueOf(String s)：将String转换为Integer
			基本进制转换：
			public static String toBinaryString(int i)：int--> 二进制 -->String
			public static String toOctalString(int i):int --> 八进制 --> String
			public static String toHexString(int i):int --> 十六进制 --> String
			十进制到其它进制：
			public static String toString(int i,int radix)：将某进制的i值，转换为String表示形式。radix为：进制数
			其它进制到十进制：
			public static int parseInt(String s,int radix)：将某进制的字符串表现形式s，转换为十进制int值。radix为进制数；

		5.JDK5的自动装箱和拆卸：
			1.自动装箱：将"基本数据类型"转换为对应的"包装类型"；
					Integer intObj = 10;
			2.自动拆箱：将"包装类型"转换为对应的"基本数据类型"；
					int n = intObj;
		6.常见面试题：
			Integer v1 = 127;
			Integer v2 = 127;
			System.out.println(v1 == v2);//true
			Integer v3 = 128;
			Integer v4 = 128;
			System.out.println(v3 == v4);//false

			Integer v5 = 127;
			Integer v6 = new Integer(127);
			System.out.println(v5 == v6);//false;

Character类

		1.char的包装类；
		2.构造方法：
			Character(char v):
		3.常用方法：
			public static boolean isUpperCase(char ch):判断是否是大写字符
			public static boolean isLowerCase(char ch)：判断是否是小写字符；
			public static boolean isDigit(char ch)：判断是否是数字
			public static char toUpperCase(char ch)：将字符ch转换为大写；
			public static char toLowerCase(char ch)：将字符ch转换为小写；

五、正则表达式(Pattern,Matcher)

Pattern类

public class Demo {
	public static void main(String[] args) {
		 Pattern p = Pattern.compile("a*b");
		 Matcher m = p.matcher("aaaaab");
		 boolean b = m.matches();
		 System.out.println("是否匹配：" + b);
		 
		 String str = "aaaaaaab";
		 String regex = "a*b";
		 System.out.println("匹配：" + str.matches(regex));
	}
}

六、Math类/Random类/System类

Math类

		1.成员属性：
			E：比任何其他值都更接近 e（即自然对数的底数）的 double 值。(该值已被定义，并且被修饰为static和final)
			PI:比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。(该值已被定义，并且被修饰为static和final)
		2.成员方法：
			public static int abs(int a):取a的绝对值；
			public static double ceil(double a)：向上取整；
			public static double floor(double a)：向下取整；
			public static int max(int a,int b) ：取a和b的最大值
			public static double pow(double a,double b)：返回第一个参数的第二个参数次幂的值。
			public static double random()：获取一个double类型的随机数。该值>=0 并且 < 1.0
			public static int round(float a):四舍五入取整(参数为double的自学)
			public static double sqrt(double a)：返回正确舍入的 double 值的正平方根

Random类

		1.构造方法：
			public Random()
			public Random(long seed)：由于内部算法固定，所以相同的种子能产生相同的随机数序列(即使多次运行)；
		2.成员方法：
			public int nextInt()：获取一个int范围内的一个随机数；
			public int nextInt(int n)：获取一个n以内的正整数；

System类

		public static void gc()：运行垃圾回收器；
		public static void exit(int status)：结束虚拟机；
		public static long currentTimeMillis()：获取从1970年1月1日到当前时间的毫秒值；
		public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：复制数组；

七、BigInteger类/BigDecimal类

java.math.BigInteger类：用于"大整数"运算

		1.构造方法：
			public BigInteger(String val)
		2.成员方法：
			public BigInteger add(BigInteger val)：加
			public BigInteger subtract(BigInteger val)：减
			public BigInteger multiply(BigInteger val)：乘
			public BigInteger divide(BigInteger val)：除
			public BigInteger[] divideAndRemainder(BigInteger val)：除法和取余

java.math.BigDecimal类：用于"浮点"运算

		* 注意：在以后的开发中，凡是涉及到浮点运算的，都不要使用"基本数据类型"，
		*     而是使用BigDecimal类来运算。
		1.构造方法：
			public BigDecimal(String val)：建议使用此构造方法；
		2.成员方法：
			public BigDecimal add(BigDecimal augend)：加
			public BigDecimal subtract(BigDecimal subtrahend)：减
			public BigDecimal multiply(BigDecimal multiplicand)：乘
			public BigDecimal divide(BigDecimal divisor)：除
			public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)：除法，可以指定四舍五入的方式；

八、Date类/DateFormat类/Calendar类

java.util.Date类

		1.构造方法：
			public Date()：使用当前系统时间构造；
			public Date(long date)：使用一个毫秒值构造；
		2.成员方法：
			public long getTime()：获取毫秒值；
			public void setTime(long time)：设置毫秒值；

java.text.SimpleDateFormat类

		1.构造方法：
			public SimpleDateFormat()：使用默认格式；
			public SimpleDateFormat(String pattern)：使用pattern指定的格式；
		2.成员方法：
			public final String format(Date date)：将Date转换为String；
			public Date parse(String source)：将String转换为Date;

java.util.GregorianCalendar类

	java.util.Calendar(抽象类)：日历类
		|--GregorianCalendar(类)：
        获取GregorianCalendar对象：
        		方式一：直接实例化；
        		方式二：Calendar的getInstance()方法；
        注意：在使用Calendar.MONTH字段时尤其要注意，月份的起始值是从0开始而不是1，比如现在是4月份，得到的Calendar.MONTH字段的值是3。
		1).成员方法：
			public static Calendar getInstance()：获取一个GregorianCalendar对象；
			public int get(int field)：获取field字段的值；
			public void add(int field,int amount)：增加field字段的值为amount；
			public final void set(int year,int month,int date)：设置新的年月日信息；

练习_计算2月份的天数

/*
 * 如何获取任意年份的2月份有多少天
 * 1.构造一个日历：指定年，3，1
 * 2.将"day_Of_Month" 减 1
 * 3.获取日期；
 */
public class Demo {
	public static void main(String[] args) {
		GregorianCalendar gc = new GregorianCalendar(2000,3 - 1,1);
		gc.add(Calendar.DAY_OF_MONTH, -1);
		int day = gc.get(Calendar.DAY_OF_MONTH);
		System.out.println("2月份有：" + day + " 天");
	}
}