java常用类总结（全）

常用实用类总结

涉及到的类包括：Object、Scanner，String，StringBuffer（String、StringBuffer、StringBuilder区别与联系），Array，自动装箱和拆箱（Integer），Random、Math、System，及日期时间类。

Object类

Object作为所有类的超类，无论是四类八种的基本类型还是引用类型或者是自定义类型都需要extends Object，其方法有很多，这里主要介绍几个需要注意的方法：
（1），finalize()：在GC准备释放对象所占用的内存空间之前，它将首先调用finalize()方法，一般用于释放非Java 资源（如打开的文件资源、数据库连接等）,或是调用非Java方法（native方法）时分配的内存（比如C语言的malloc()系列函数）。
在Java中，由于GC的自动回收机制，因而并不能保证finalize方法会被及时地执行（垃圾对象的回收时机具有不确定性），也不能保证它们会被执行(程序由始至终都未触发垃圾回收)。

protected void finalize() throws Throwable { }

（2），clone()： Object类中的clone方法执行特定的复制操作，首先如果对象不能实现接口Cloneable，则会抛出 CloneNotSupportedException。
（3），toString()：返回一个反映这个对象的字符串，是开发者开发java的时候为了方便所有类的字符串操作而特意加入的一个方法。
（4）、equals()：我们都知道 == 作用于基本数据类型，比较的是值是否相等，如果作用于引用类型，则比较的是变量所指向的对象的地址。equals对于非String、Date类型比较的是引用类型的变量所指向的对象的地址，对于String、Date类型，在其类中重写了equals()，所以比较的是值，由此可知 equals() 的底层实现依然是”==“

注意：在自定义类Object类型相等判断中如果重写了equals方法，必须也要重写hashcode方法。equals()方法是比较两个对象的内存地址是否相等，如果不重写，显然两个对象由于不同存储地址所以是不相等的，而hashcode()判断是equals()判断的先决条件，如果两个对象判断相等只重写了euqals()方法，而没有重写hashcode()方法，将违背 "两个对象相等，其hashcode必然相等"

//源码
 @Override
    public boolean equals(Object obj) { 
           return (this==obj);
    }

 

---

Scanner 类

该类的主要作用就是建立一个文本扫描器（键盘录入），存在于java.util包下。在键盘的录入过程中，Scanner sc = new Scammer(System.in)；

System类下有一个静态的字段：public static final InputStream in; 标准的输入流，对应着键盘录入。

一般方法：

* hasNextXxx()  判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
* nextXxx()  获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

常用方法：

两个常用的方法：
* next()方法一定要读取到有效字符才可以结束输入，对输入有效符之前遇到的空白，给方法会自动将其去掉，即next()方法不能得到带有空格的字符串
* nextLine()方法以enter为结束符，返回的是回车之前的所有字符。可以获得空白，即可以获取输入的一整行数据

* public int nextInt():获取一个int类型的值
* public String nextLine():获取一个String类型的值

​
public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		/*//第一个小操作
		System.out.println("请输入第一个整数:");
		int i = sc.nextInt();
		System.out.println("请输入第二个整数:");
		int j = sc.nextInt();
		System.out.println("i = "+i+", j = "+j);*/
			
		/*//第二个小操作
		System.out.println("请输入第一个字符串:");
		String line1 = sc.nextLine();
		System.out.println("请输入第二个字符串:");
		String line2 = sc.nextLine();
		System.out.println("line1 = "+line1+", line2 = "+line2);*/

		//第三个小操作
		//如果输入10回车,没有输入第二个字符串就已经输出结果:i = 10, line2 =
		/*System.out.println("请输入第一个整数:");
		int i = sc.nextInt();
		System.out.println("请输入第二个字符串:");
		String line2 = sc.nextLine();
		System.out.println("i = "+i+", line2 = "+line2);
		//为了证明line2中并没有存放\r\n,因为nextLine()遇到\r\n就结束了,所以不会存入line中
		System.out.println(i);
		System.out.print("111111111111");
		System.out.print(line2);
		System.out.println("22222222222");*/
			
		//解决上面的问题,方案1:再创建一个Scanner,但是浪费空间
		//方案2:因为键盘录入的都是字符串,所以都用nextLine()方法,然后再进行转换
		int i = sc.nextInt();
		Scanner sc2 = new Scanner(System.in);
		String line = sc.nextLine();
		System.out.println(i);
		System.out.println(line);
}
​

---

 

String类

String s = "abc"，"abc"是String类的一个实例，也可以看成是一个字符串对象。字符串是常量，一旦被赋值，就不能被改变。

public static void main(String[] args) {
			String str = "abc";  //"abc"可以看做一个字符串对象
			str = "def";   //当把"def"赋值给str,原来的"abc"就变成了垃圾
			System.out.println(str);
            //打印的结果不是"类名@字符串地址",而是"abc",说明String重写了toString()方法
			
}

String str=”aaa”;和String str= new String(“aaa”);的区别

     （1）当使用String str=" aaa ",这种方式时，先去内存的堆内存中找是否存在" bjsxt "这个字符串，若存在，则将地址引用。若不存在则创建。
     （2）当使用String str=new String("aaa ");时，不管事先是否存在" aaa "，每次都会创建其新的对象。

       (3)  String str= new String(“aaa”) 创建了两个对象，一个在常量池中，一个在堆内存中。

    （4）java的常量优化机制：字符串变量相加，先开辟空间，再相加。字符串常量相加，首先在字符串常量池中找，判断有没有这个常量值，没有需要创建，有就直接返回。

private static void demo1() {
	//byte b = 3 + 4;		//在编译时就变成7,把7赋值给b,常量优化机制
	String s1 = "a" + "b" + "c";//java中有常量优化机制,在编译时期就能确定s2的值为"abc",所以编译时期,在常量池中创建"abc"
	String s2 = "abc";//执行到这里时常量池中已经有了"abc",所以就不再创建,所以s1和s2指向的是常量池中同一个字符串常量"abc"
	System.out.println(s1 == s2); 			//true,java中有常量优化机制	
	System.out.println(s1.equals(s2)); 		//true
}

private static void demo2() {
	String s1 = "ab";
	String s2 = "abc";
	String s3 = s1 + "c";
	System.out.println(s3 == s2);			//false
	System.out.println(s3.equals(s2)); 		//true
}

string常用构造方法：

* public String():空构造
* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串
****int length():获取字符串的长度。数组中没有length()方法，它有length属性。字符串中有length(),集合中没有length(),有size()获取集合中元素的数量

String类的判断功能：
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空。

String的转换功能：
* byte[] getBytes():把字符串转换为字节数组。
* char[] toCharArray():把字符串转换为字符数组。
* static String valueOf(char[] chs):把字符数组转成字符串。
* static String valueOf(int i):把int类型的数据转成字符串。
* 注意：String类的valueOf方法可以把任意类型的数据转成字符串

*String toLowerCase():把字符串转成小写。(了解)
* String toUpperCase():把字符串转成大写。
* String concat(String str):把字符串拼接。

public static void main(String[] args) {
	String s = "woaihbniaima";
    //链式编程
	String s2 = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
	System.out.println(s2);
}

String的替换功能
           String replace(char old,char new)：将字符串中某一个字符用新的字符替换
           String replace(String old,String new)：将字符串中某一个子字符串用新 的字符串去替代
String的去除字符串两空格：String trim()
String的按字典顺序比较两个字符串
           int compareTo(String str)：是Comparable接口中的方法(该接口可以实现一个自然排序)
           int compareToIgnoreCase(String str)(了解)

---

StringBuffer类：

StringBuffer是字符串缓冲区，当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组，当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符。线程安全的可变字符序列。

StringBuffer的构造方法：
* public StringBuffer():无参构造方法。初始容量为 16个字符
* public StringBuffer(int capacity):指定容量的字符串缓冲区对象
* public StringBuffer(String str):指定字符串内容的字符串缓冲区对象，字符串的初始容量为 16 加上字符串参数的长度
StringBuffer的获取长度和容量的方法：
* public int capacity()：返回当前容量。 理论值(不掌握)
* public int length(): 返回长度（字符数）。 实际值

StringBuffer的添加功能
* public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
* public StringBuffer insert(int offset,String str): 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身。如果 没有指定位置的索引就会报索引越界异常

StringBuffer的删除功能
* public StringBuffer deleteCharAt(int index): 删除指定位置的字符，并返回本身
* public StringBuffer delete(int start,int end): 删除从指定位置开始指定位置结束的内容，并返回本身

StringBuffer的替换功能
* public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
StringBuffer的反转功能
* public StringBuffer reverse():将此字符串中的字符序列直接反转

StringBuffer的截取功能
* public String substring(int start): 从指定位置截取到末尾
* public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

注意:返回值类型不再是StringBuffer本身

String、StringBuffer、StringBuilder区别与联系：

 ①，String会产生新的对象，效率低下，浪费内存空间；StringBuffer，StringBuilder不会产生新的对象，都是在原本的缓冲区中操作。

②，StringBuffer是jdk1.0版本的,是线程安全的,效率低； StringBuilder是jdk1.5版本的,是线程不安全的,效率高。

效率：StringBuilder>StringBuffer>String

③，String是一个不可变的字符序列； StringBuffer,StringBuilder是可变的字符序列。

④，StringBuffer适合多线程操作；StringBuilder适合单线程操作。

StringBuffer和String的相互转换：

（1） String ---> StringBuffer ： a.通过构造方法； b.通过append()方法

  (2)  StringBuffer -- String：a:通过构造方法；b:通过toString()方法；c:通过subString(0,length)

private static void demo1() {
    String s = "hb";
    StringBuffer sb1 = new StringBuffer(s);//通过构造方法将String转换为StringBuffer对象
    System.out.println(sb1);
			
    StringBuffer sb2 = new StringBuffer();
    sb2.append(s);			//通过append方法将String转换为StringBuffer对象
    System.out.println(sb2);
}

public static void demo2(){
    StringBuffer sb = new StringBuffer("hb");		
	String s1 = new String(sb);		//通过构造将StringBuffer转换为String	
    System.out.println(s1);                   
			
	String s2 = sb.toString();	//通过toString方法将StringBuffer转换为String
	System.out.println(s2);
			
	String s3 = sb.substring(0, sb.length());//通过截取子字符串将StringBuffer转换为String
	System.out.println(s3);
}

StringBuffer和数组的区别： 都属于容器类型的变量，数组只能存储一种类型的数据，并且长度是固定的，StringBuffer可以存储任意类型的元素。

String和StringBuffer分别作为参数传递：

public static void main(String[] args){
    /**
	*基本数据类型的值传递,不改变其值
	*引用数据类型的值传递,改变其值
	*String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
	*/
	String s = "hb";
	System.out.println(s);//hb
	change1(s);
	System.out.println(s);//hb
			
	System.out.println("---------------------");
	StringBuffer sb = new StringBuffer();
	sb.append("hb");
	System.out.println(sb);//hb
	change2(sb);
	System.out.println(sb);//hbitcast
}

public static void change1(String s) {
    /*
	*因为str是属于局部变量,在调用该方法是实际参数s和形式参数str指向同一个字符串对象
	*但是在方法内部将str又指向了一个新的字符串对象,而此时s还是指向的原来的字符串对象
	*changeString方法执行完毕,局部变量str消失,方法内部产生的新的字符串对象称为垃圾
	*但是s还是指向的原有的字符串对象,并没有改变
	*/
	s += "itcast";
}
public static void change2(StringBuffer sb) {
	//调用该方法时实际参数的sb和形式参数的sb指向的是同一个对象(StringBuffer容器)
	//方法内部又在该容器里添加了"itcast",所以方法结束时,局部变量的sb消失,但是实际参数的sb所指向的容器的内部的内容已经发生了改变
	sb.append("itcast");
}

---

Arrays类

 针对数组进行操作的工具类， 提供了排序，查找等功能。
成员方法：
* public static String toString(int[] a)
* public static void sort(int[] a)
* public static int binarySearch(int[] a,int key)

binarySearch()有两种参数类型，此法为二分搜索法，故查询前需要用sort()方法将数组排序，如果数组没有排序，则结果是不确定的，另外如果数组中含有多个指定值的元素，则无法保证找到的是哪一个。

//binarySearch()源码分析
private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {                                 
	int low = fromIndex;				//最小索引0
	int high = toIndex - 1;				//最大索引数组长度-1
			
	while (low <= high) {				//最小索引小于等于最大索引可以循环判断
	int mid = (low + high) >>> 1;	//求出中间索引值,(最小+最大)/2
	int midVal = a[mid];			//通过中间索引获取中间值
			
	if (midVal < key){			//中间索引对应的值小于查找的值
	    low = mid + 1;				//最小索引变化
	}else if (midVal > key){		//中间索引对应的值大于查找的值
	    high = mid - 1;				//最大索引变化
	}else{
	    return mid; // key found	//找到了
    }
  }
     return -(low + 1);  // key not found.//-插入点 - 1
}

---

自动装箱和自动拆箱

（JDK5.0之后添加进来的，java的jkd5.0以后:还有一些新特性:可变参数,增强for循环,静态导入,枚举...）

装箱就是自动将基本数据类型转换为包装器类型；

Integer it = 200;           实际上： Integer it = Integer.valueOf(200);

　　自动装箱功能：把int类型自动装载到Integer中  先装箱，再赋值

拆箱就是自动将包装器类型转换为基本数据类型。

Integer it2 = it+it1;         实际上是：Integer it2 = Integer.valueOf(it.intValue() + it1.intValue());

         先对it 和 it1做拆箱功能，然后相加，得到一个int类型的值，然后在对这个int类型的值，做装箱操作，最后再赋值。

Integer类：

Integer 类在对象中包装了一个基本类型 int 的值，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换；还提供了处理 int 类型时非常有用的其他一些常量和方法。

构造方法： public Integer(int value)； public Integer(String s)

Integer i1 = new Integer(100);         Integer i3 = new Integer("100");

注意：Integer x = null;代码就会出现NullPointerException，所以需要先判断再使用。

String和int类型的相互转换：

①，int ---> String
* 和""进行拼接
* public static String valueOf(int i)
int ---> Integer ---> String （Integer类的toString方法()）
* public static String toString(int i)（Integer类的静态方法）
②，String ---> int；String ---> Integer -- int
* public static int parseInt(String s)

基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型。

/*
 * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
 * 如果超过了byte取值范围就会再新创建对象
 * 源码分析:
*/
public static Integer valueOf(int i) {
      assert IntegerCache.high >= 127;
      if (i >= IntegerCache.low && i <= IntegerCache.high)		//i>= -128 && i <= 127
          return IntegerCache.cache[i + (-IntegerCache.low)];
		      return new Integer(i);
}

 

---

Date类（日期时间类）

java.util包下的 Date 表示特定的瞬间，精确到毫秒。

构造方法
* public Date()    //如果没有传参数代表的是当前时间
* public Date(long date)   毫秒值创建时间对象
成员方法
* public long getTime()     通过时间对象获取毫秒值
* public void setTime(long time)   设置毫秒值,改变时间对象

java.sql.Date和java.util.Date的联系和区别

    （1）   java.util.Date 就是在除了SQL语句的情况下面使用

　（2）    java.sql.Date 是针对SQL语句使用的，它只包含日期而没有时间部分

　（3）    它们都有getTime方法返回毫秒数，自然就可以直接构建（相同点）

　（4）    java.util.Date 是 java.sql.Date 的父类（注意拼写）

　（5）    java.util.Date是常用的表示时间的类，我们通常格式化或者得到当前时间都是用java.util.Date

　（6）    java.sql.Date在读写数据库的时候用java.sql.Date

import java.util.Date;

//util包下的日期转换成sql包下的日期
public class Demo{
    public static void main(){
        Date date = new Date();
        System.out.println(date.getTime());
        java.sql.Date sqlDate = new java.sql.Date(date.getTime());
        System.out.println(sqlDate);
    }
}

 

SimpleDateFormat类实现日期和字符串的相互转换：

DateFormat类：是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类,不能实例化，所以使用其子类SimpleDateFormat。
SimpleDateFormat构造方法：
                                * public SimpleDateFormat()
                               * public SimpleDateFormat(String pattern)
                  成员方法:
                               * public final String format(Date date)
                               * public Date parse(String source)

public static void demo1() {
	//DateFormat df1 = new SimpleDateFormat();
	DateFormat df1 = DateFormat.getDateInstance();	//相当于父类引用指向子类对象,右边的方法返回一个子类对象
}
	
public static void demo2() {
	Date d = new Date();							//获取当前时间对象
	SimpleDateFormat sdf = new SimpleDateFormat();	//创建日期格式化类对象
	System.out.println(sdf.format(d));	 			//88-6-6 下午9:31
}

public static void demo3() {
	Date d = new Date();							//获取当前时间对象
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//创建日期格式化类对象
	System.out.println(sdf.format(d));				//将日期对象转换为字符串
}

private static void demo4() throws ParseException {
	//将时间字符串转换成日期对象
	String str = "2000年08月08日 08:08:08";
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");		
	System.out.println(sdf.parse(str);    //将时间字符串转换成日期对象
}	

Calendar日历类 ：

 Calendar是一个抽象类，主要用于完成日期字段之间相互操作的功能。

• 获取Calendar实例的方法：

①，使用 Calendar.getInstance() 方法

②，调用它的子类 GregorianCalendar 的构造器

• 一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得先要的时间信息。（如：YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY、MINUTE、SECOND）

JDK8中新日期时间API ：

JDK8 吸收了 Joda-Time 的精华，以一个新的开始为java创建优秀API。新的 java.time 中包含了所有关于本地日期（LocalDate），本地时间（LocalTime），本地日期时间（LocalDateTime），时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date类 新增了 toInstant() 方法，用于把 Date 转换成新的表示形式，这些新增的本地化时间日期API大大简化了时间日期的管理。

相关方法：

①now()：得到当前相关时间日期

②of()：设置指定的年、月、日、时、分、秒

③getXxx()：获取相关的属性

④withXxx()：设置相关的属性（体现不可变性）

---

Random类：

此类用于产生随机数如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
构造方法
* public Random()
* public Random(long seed)
成员方法
* public int nextInt()
* public int nextInt(int n)(重点掌握)

System类

 System 类包含一些有用的类字段和方法。它不能被实例化。 
成员方法
* public static void gc()      //运行垃圾回收器,相当于呼喊保洁阿姨,但是不一厅呼喊一次就执行,有可能需要呼喊多次才执行
* public static void exit(int status)       //为0是正常关闭，非0状态是异常终止。 终止当前的JVM虚拟机
* public static long currentTimeMillis()     //获取当前时间的毫秒值
* pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)      //将数组内容拷贝

System.exit()方法返回程序的最顶层，return和它相比是返回上一层。

exit表示的关闭JVM程序，但是不释放内存，如果想释放内存的话版，用“dispose()”关闭当前程序，并释放资源。

---

（扩展）

BigInteger类

可以让超过Integer范围内的数据进行运算。
构造方法
* public BigInteger(String val)
成员方法
* 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)//取除数和余数

BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示计算浮点数，Java提供了BigDecimal，不可变的、任意精度的有符号十进制数。

 构造方法
* public BigDecimal(String val)
成员方法
* public BigDecimal add(BigDecimal augend)
* public BigDecimal subtract(BigDecimal subtrahend)
* public BigDecimal multiply(BigDecimal multiplicand)
* public BigDecimal divide(BigDecimal divisor)