java常见_JAVA常用类

Java015

(1)包装类的基本使用

包装类均位于java.lang包，八种包装类和基本数据类型的对应关系如下图1：图1

包装类的继承关系：图2

要点：

1)在这八个类中，除了Character和Boolean以外，其他的都是“数字型”，“数字型”都是java.lang.Number的子类。Number类是抽象类，因此它的抽象方法，所有子类都需要提供实现。

2)Number类是抽象类，因此它的抽象方法，所有子类都需要提供实现。Number类提供了抽象方法：intValue()、longValue()、floatValue()、doubleValue()，意味着所有的“数字型”包装类都可以互相转型。

转型格式：(以 Integer 举例)

(1)int -->Integer new Integer(primitive)

(2)Integer-->int Integer 对象.xxxValue()

(3)Integer-->String Integer 对象.toString()

(4)String-->Integer new Integer(String str)

(5)int-->String String.valueOf(primitive)

(6)String-->int Integer.parseXxx()

(2)自动装箱和拆箱

自动装箱和自动拆箱就是将基本数据类型和包装类之间进行自动的相互转换，JDK1.5后，Java引入了自动装箱(autoboxing)/拆箱(unboxing)。

自动装箱

装箱(autoboxing)的定义：基本类型就自动地封装到与它相同的类型的包装类中。

Integer i=100;//左边是引用数据类型，右边是int数据类型，编译不报错。(自动装箱)Integer i = new Integer(100);//(手工装箱)实际上是编译器调用了valueOf()方法来实现将基本数据类型封装到对应的Integer对象当中

代码示例：

/*** 测试自动装箱和包装类的缓存* 自动装箱(AutoBoxing)：将基本数据类型转换为包装类型*/

public class TestAutoBoxing {

public static void main(String[] args) {

//缓存类范围为Cache[-128,127]，超出范围就会自动重新new一个Integer对象Integer a=127;//相当于Integer a= Integer.valueOf(127);(编译器)Integer b=127;

System.out.println(a==b);//比较内存地址//超出范围,new一个Integer对象Integer aa=1000;

Integer bb=1000;

System.out.println(aa==bb);

System.out.println("a:"+a);

}

}

打印结果：图3

Integer i = 5这样的语句就能实现基本数据类型转换成包装类，这是因为JVM为我们执行了Integer i = Integer.valueOf(5)这样的操作，这就是Java的自动装箱。

自动拆箱

拆箱(unboxing)的定义：将包装类型转换为基本类型。

Integer i = 5;int j = i; //这样的过程就是自动拆箱。int j = 22;

Integer j = new Integer(j);//手工装箱int a = j.intValue();//手工拆箱

代码示例：

/*** 测试自动装箱和自动拆箱*/

public class Test3 {

public static void main(String[] args) {

// jdk1.5之前需要手工完成装箱和拆箱int i = 123;

Integer i2 = new Integer(i);// 手动装箱int-->Integerint i3 = i2.intValue();// 手工拆箱 Integer-->int

// jdk1.5之后支持自动装箱和拆箱Integer i4 = i;// 自动装箱 int-->Integerint i5 = i4;// 自动拆箱Integer -->intInteger i6 = null;// 给对象赋空值

// 本质上调用了i6.intValue()方法，因为i6对象为空，所以会出现空指针异常(NullPointerException)int i7 = i6;

}

}

打印结果：图4

(3)包装类的缓存问题

Integer 中的缓存类 IntegerCache。

当调用Integer中的valueOf方法时，系统会自动调用静态内部类IntegerCache，产生一个cache缓存数组[-128,127]，如果传入的形参在该范围内，则直接返回对应cache缓存数组中的Integer对象；反之则new新的Integer对象。

(4)String 类底层分析

1)实际上String 的底层数据结构是 char 类型的数组

2)String 的相应方法的实现实际上就是对数组的一个操作

3)String类的值只能被共享不能被更改，因为char类型的数组是被final修饰，所以其值不能被更改。

(5)StringBuffer和StringBuilder

要点：

1)StringBuffer和StringBuilder非常类似，均代表可变的字符序列。 这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。

常用方法列表：

1. 重载的public StringBuilder append(…)方法

可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。

2. 方法 public StringBuilder delete(int start,int end)

可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。

3. 方法 public StringBuilder deleteCharAt(int index)

移除此序列指定位置上的 char，仍然返回自身对象。

4. 重载的public StringBuilder insert(…)方法

可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。

5. 方法 public StringBuilder reverse()

用于将字符序列逆序，仍然返回自身对象。

6. 方法 public String toString() 返回此序列中数据的字符串表示形式。

StringBuilder和StringBuffer的区别：

StringBuilder：线程安全，做线程同步检查，效率低。

StringBuffer：线程不安全，不做线程检查，因此效率高。

(5)日期时间类 java.util.Date

常用类：

1. Date()分配一个日期对象，并且初始化此对象为系统当前的日期和时间，可以精确到毫秒)。

2.日期(长日期)分配日期对象并初始化此对象，以表示自从标准基准时间(称为“历元(epoch)”，即1970年1月1日00:00:00 GMT)以来的指定毫秒数。

3.布尔之后(Date when)测试此日期是否在指定日期之后。

4. booleanbefore(Date when)测试此日期是否在指定日期之前。

5. boolean equals(Object obj)比较两个日期的相等性。

6. long getTime()返回自1970年1月1日00:00:00 GMT以来此日期对象表示的毫秒数。

7. String toString()把此日期对象转换为以下形式的字符串：

dow mon dd hh：mm：ss zzz yyyy其中：dow是一周中的某一天(周日，星期一，星期二，星期三，星期四，星期五，星期六)

(6)DateFormat类和SimpleDateFormat类

完成字符串和时间对象的转换。

DateFormat类的作用：

把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。图5

(7)Calendar日历类

要点：

1)java.util.Calendar类: 抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。

2)java.util.GregorianCalendar 是 Calendar 的一个具体子类，提供了 世界上大多数国家/地区使用的标准日历系统。

常用的方法：

get(int field) :返回给定日历字段的值。

set(int field, int value) :将给定的日历字段设置为给定的值。

add(int field, int amount) :根据 日历的规则，将指定的时间量添加或减去给定的日历字段。

getActualMaximum(int field) :给定此Calendar的时间值，返回指定日历字段可能具有的Calendar。

代码示例：

package com.bjsxt.calendar;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

/*** 测试日历类(Calendar)*/

public class TestCalendar {

public static void main(String[] args) {

//父类引用指向子类对象(父类是抽象类)Calendar cal=new GregorianCalendar();

cal.set(2050, 6, 18);//设置日期System.out.println("年:"+cal.get(1));//获取时间System.out.println("年:"+cal.get(Calendar.YEAR));//获取时间//getTime();将Calendar转换为Date类型Date d=cal.getTime();

System.out.println(d);

//setTime(Date);将Date所表示的对象设置到日历中Date d1=new Date(1000l);

cal.setTime(d1);

System.out.println("年:"+cal.get(Calendar.YEAR));//获取时间System.out.println("月:"+cal.get(Calendar.MONTH));//获取月份System.out.println("天:"+cal.get(Calendar.DAY_OF_MONTH));//获取天//在相应的属性时间层增加cal.add(Calendar.DAY_OF_MONTH, 10);

System.out.println("天:"+cal.get(Calendar.DAY_OF_MONTH));//获取天System.out.println("*********************************");

//在相应的属性时间层减少cal.add(Calendar.DAY_OF_MONTH,-100);

System.out.println("年:"+cal.get(Calendar.YEAR));

System.out.println("月:"+cal.get(Calendar.MONTH));//获取月份System.out.println("天:"+cal.get(Calendar.DAY_OF_MONTH));//获取天}

}

打印结果：图6

使用日历类(calendar)开发万年历

需求：根据用户输入的年月日，动态的展示该月的“万年历”。

代码示例：

package com.bjsxt.calendar;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.Scanner;

/*** 使用日历类(calendar)开发万年历* 需求：根据用户输入的年月日，动态的展示该月的

public class Test {

public static void main(String[] args) throws ParseException {

Scanner scanner = new Scanner(System.in);

System.out.println("请输入日期：yyy-MM-dd");

String str = scanner.next();

// 创建DateFormat，用于将String转成DateDateFormat df = new SimpleDateFormat("yyy-MM-dd");

Date d = df.parse(str);

// Date所表示的时间，设置到Calender中Calendar cal = new GregorianCalendar();

cal.setTime(d);

// 获取日历中的Date部分int nowDate = cal.get(Calendar.DAY_OF_MONTH);

// 将日期设置成1号，设置成 2020-2-1cal.set(Calendar.DAY_OF_MONTH, 1);

// 获取1号是星期几int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);

System.out.println("日\t一\t二\t三\t四\t五\t六");

for (int i = 1; i < dayOfWeek; i++) {

System.out.print("\t");

}

// 获取输入月份的最后一天int maxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);

//System.out.println(maxDay);for (int i = 1; i <= maxDay; i++) {

System.out.print(i);

if (i == nowDate) {

System.out.print("*");

}

System.out.print("\t");

if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {

System.out.println();

}

cal.add(Calendar.DAY_OF_MONTH, 1);

}

}

}

打印结果：图7

(8)Math类

Math类的常用方法：

1. abs 绝对值

2. acos,asin,atan,cos,sin,tan 三角函数

3. sqrt 平方根

4. pow(double a, double b) a的b次幂

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大于a的最小整数

8. floor(double a) 小于a的最大整数

9. random() 返回 0.0 到 1.0 的随机数

10. long round(double a) double型的数据a转换为long型(四舍五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

代码示例：

package com.bjsxt.math;

/*** 测试Math类的常见用法*/

public class TestMath {

public static void main(String[] args) {

//1)绝对值Math.abs();System.out.println("绝对值："+Math.abs(20)+"\t"+Math.abs(-20)+"\t"+Math.abs(0));

//2)向上(大)取整，再转double类型System.out.println("向上取整再转double:"+Math.ceil(50.000001)+"\t"+Math.ceil(-9.99999));

//3)向下(小)取整，再转double类型System.out.println("向下取整再转double:"+Math.floor(23.9999)+"\t"+Math.floor(-23.0001));

//4)最值，输入两个数，返回最大值，最小值System.out.println("最大值:"+Math.max(20, 10)+",最小值:"+Math.min(2, 30));

//5)第二个参数是第一个参数的几次幂。 Math.pow(,);System.out.println("5的2次方:"+Math.pow

(5, 2)+",5的立方:"+Math.pow(5, 3));

//6)返回值为double类型的正数，区间在[0,1)。Math.random()System.out.println("产生一个[0,1)的随机数:"+Math.random());

int a=(int)(9000*Math.random())+1000;

System.out.println("得到一个1000-9999之间的随机数:"+a);

//7)四舍五入Math.round();System.out.println("四舍五入:"+Math.round(34.567)+"\t"+Math.round(34.345));

//8)开平方Math.sqrt();System.out.println("开平方:"+Math.sqrt(4));

}

}

打印结果：图8

静态导入

import static java.util.Math.*;

作用：调用的时候可以省略类名(Math)。

代码示例：

package com.bjsxt.math;

import static java.lang.Math.*;

/*** 测试静态导入*/

public class TestStaticImport {

public static void main(String[] args) {

System.out.println(abs(-20));//调用的是本类中的abs方法System.out.println(Math.abs(-20));

System.out.println(random());

}

public static int abs(int number) {

return number;

}

}

打印结果：图9

(9)文件类File的基本用法

java.io.File类：代表文件和目录。在开发中，读取文件，生成文件，删除文件，修改文件的属性时经常会用到本类。

构造方法：

1)File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。

2)File(String parent, String child)从父路径名字符串和子路径名字符串创建新的File实例。

3)ile(File parent, String child)从父抽象 路径名和子路径名字符串创建新的File实例。

常用方法：

1)exists() :判斷文件或文件夹是否存在。

2)mkdir( )：创建目录(只能创建一级目录)。

mkdirs() : 创建目录(可创建多级目录)。

3)isDirectory() :判断是否是目录。

4)isFile() :判断是否为文件。

5)createNewFile():创建文件。

6)delete():删除文件或目录。

7)listFiles():获取指定目录下的所有子文件或子文件夹。

8)getName();//获取文件名称。

9)length();//获取文件的大小单位为字节。

代码示例：

package com.bjsxt.file;

import java.io.File;

/*** 测试File的基本用法* File操作目录的相关方法*/

public class TestDirectory {

public static void main(String[] args) {

//创建File类对象File f =new File("D:"+File.separator+"test");

f.mkdir();//创建目录，只能创建单层目录System.out.println(f.exists());//判断目录是否存在System.out.println("是否是目录:"+f.isDirectory());

System.out.println("是否是文件:"+f.isFile());

File f2=new File("D:/aa/bb/ccc/dd");

f2.mkdirs();//用于创建目录，多层目录f.delete();//删除File parent=f2.getParentFile();//获取dd的父级目录System.out.println(parent);

parent.delete();//delete删除目录时，只允许删除空目录(这里删除的是父目录)f2.delete();//删除ddparent.delete();//删除ccc

//获取指定路径下的所有对象(目录和文件)(list())File f3 = new File("D:\\");

String[] strFile = f3.list();

System.out.println(strFile.length);//数组中元素的个数for(String s:strFile) {

System.out.println(s);

}

System.out.println("------------------------------");

//获取指定路径下的所有对象(目录和文件)(listFiles())//得到File类型的对象，能调用File的操作方法方法File[] flise=f3.listFiles();

System.out.println(flise.length );//数组中元素的个数for(File file:flise) {

System.out.println(file);

}

}

}

打印结果：图10

代码示例：

package com.bjsxt.file;

import java.io.File;

import java.io.IOException;

/*** 测试File的基本用法* File操作文件的相关方法*/

public class TestFile {

//使用File类操作文件public static void main(String[] args) throws IOException {

//创建File类对象File f1=new File("D:\\a.txt");//绝对路径File f2=new File("D:/a.txt");

File f3=new File("a.txt");//相对路径，放在项目的根目录上File f4=new File("D:\\txt");//目录File f5=new File(f4,"\\a.txt");

//获取与系统相关的分隔符File.separatorFile f6=new File("D:"+File.separator+"a.txt");

/**File操作文件的相关方法*/

System.out.println(f3.createNewFile());//创建文件的方法System.out.println(f1.delete());//删除目录或文件(从磁盘上删除，不经过回收站)System.out.println(f1.exists());//判断目录是否存在System.out.println("绝对路径:"+f3.getAbsolutePath());//获取绝对路径名字符串System.out.println("相对路径:"+f3.getPath());

System.out.println("获取文件名:"+f3.getName());

System.out.println(f3);//重写toString(),调用了获取绝对路径名System.out.println("是否是文件:"+f3.isFile());//判断是否是文件System.out.println("是否是文件:"+f4.isFile());

System.out.println("文件中内容的字节数:"+f3.length());//文件中内容的字节数}

}

打印结果：图11

(10)枚举

1)DK1.5引入了枚举类型。枚举类型的定义包括枚举声明和枚举体。

2)枚举实质上还是类！而每个被枚举的成员实质上就是一个枚举类型的实例，他们默认都是public static final修饰的，可以使用枚举名.值进行访问。(枚举名.values()：获取枚举体(常量值列表))

语法格式：

enum 枚举名 {

枚举体(常量列表)

}

代码示例：

import java.util.Random;

/*** 测试枚举*/

public class TestEnum {

public static void main(String[] args) {

for (Week k : Week.values()) {// 枚举遍历 System.out.println(k);

}

// switch语句中使用枚举 int a = new Random().nextInt(4); // 生成0，1，2，3的随机数 switch (Season.values()[a]) {

case SPRING:

System.out.println("春");

break;

case SUMMER:

System.out.println("夏");

break;

case AUTUMN:

System.out.println("秋");

break;

case WINDTER:

System.out.println("冬");

break;

}

}

}

//季节enum Season {

SPRING, SUMMER, AUTUMN, WINDTER

}

//星期enum Week {

周一,周二,周三,周四,周五,周六,周日

}

打印结果：图12