本文分享自微信公众号 - java版web项目（java_project）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

Java 中必须了解的常用类的汇总

Java中必须了解的常用类

一、包装类

相信各位小伙伴们对基本数据类型都非常熟悉，例如 int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。。。，为了让基本数据类型也具备对象的特性， java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。

基本类型和包装类之间的对应关系：

注意：有两个包装类的名称比较特殊一个是Integer，另一个是Character，其他都是基本数据类首字母大写。

包装类主要提供了两大类方法：

1. 将本类型和其他基本类型进行转换的方法

2. 将字符串和本类型及包装类互相转换的方法

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Java 中基本类型和包装类之间的转换

基本类型和包装类之间经常需要互相转换，以 Integer 为例（其他几个包装类的操作雷同哦）：

1 Integer a=new Integer(3);//定义Integer包装类对象，值为32 int b=a+5;//将对象和基本类型进行运算

在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。

那什么是装箱和拆箱呢？我们分别来看下：

装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱。

1 int i=10;//定一个int基本数据类型2 Integer x=new Integer(i);//手动装箱3 Integer y=i;//自动装箱

1 Double n=i;//类型不同不能自动装箱2 Double m=new Double(i);//不同类型可以通过手动装箱

拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱。

1 Integer j=new Integer(8);//定义Integer包装类对象，值为82 int n=j.intValue();//手动拆箱3 int m=j;//自动拆箱

1 double x=j.doubleValue();//不同类型手动拆箱2 double y=j;//不同类型可以自动拆箱

注意：类型不同不能自动装箱，但是不同类型可以自动拆箱。

立即学习“Java免费学习笔记（深入）”；

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Java 中基本类型和字符串之间的转换

在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。

其中，基本类型转换为字符串有三种方法：

1. 使用包装类的 toString() 方法

2. 使用String类的 valueOf() 方法

3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

代码如下：

1 //将基本类型转化为字符串2 int x=10;3 String str1=Integer.toString(x);//方法一4 String str2=String.valueOf(x);//方法二5 String str3=x+"";//方法三，本质利用系统自动转换类型

再来看，将字符串转换成基本类型有两种方法：

1. 调用包装类的 parseXxx 静态方法

2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱

代码如下：

1 //将字符串转换为基本类型2 String str="8";3 int n=Integer.parseInt(str);//方法一4 int y=Integer.valueOf(str);//方法二

注意：字符串转换为基本类型里如果字符串包含其他字符，程序运行时将会抛出异常。所以在使用该方法时最好用try-catch语句捕获并处理。

PS：其他基本类型与字符串的相互转化这里不再一一列出，方法都类似。

二、Date 和 SimpleDateFormat 类

在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用 java.util 包中的 Date 类。这个类最主要的作用就是获取当前时间，我们来看下 Date 类的使用：

1 Date d=new Date();//使用默认的构造方法创建Date对象2 System.out.println(d);

使用 Date 类的默认无参构造方法创建出的对象就代表当前时间，我们可以直接输出 Date 对象显示当前的时间，显示的结果如下：

其中， Thu 代表 星期四， Jul 代表 七月，06 代表 06 号， CST 代表 China Standard Time (中国标准时间，也就是北京时间，东八区)。

从上面的输出结果中，我们发现，默认的时间格式不是很友好，与我们日常看到的日期格式不太一样，如果想要按指定的格式进行显示，如 2017-07-06 13:31:28 ，那该怎么做呢？

此时就到了 java.text 包中的 SimpleDateFormat 类大显身手的时候了！！可以使用 SimpleDateFormat 来对日期时间进行格式化，如可以将日期转换为指定格式的文本，也可将文本转换为日期。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

1. 使用 format() 方法将日期转换为指定格式的文本

1 //使用 format() 方法将日期转换为指定格式的文本2 Date d=new Date();//使用默认的构造方法创建Date对象3 SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//指定日期格式4 String today=sdf.format(d);5 System.out.println(today);

运行结果：

结果分析：

代码中的 “yyyy-MM-dd HH:mm:ss” 为预定义字符串， yyyy 表示四位年， MM 表示两位月份， dd 表示两位日期， HH 表示小时(使用24小时制)， mm 表示分钟， ss 表示秒，这样就指定了转换的目标格式，最后调用 format() 方法将时间转换为指定的格式的字符串。

2. 使用 parse() 方法将文本转换为日期

 1                 //创建日期格式的字符串 2         String day="2017年07月06日 13:42:10"; 3         //创建SimpleDateFormat对象，指定字符串的日期格式 4         SimpleDateFormat sd=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); 5         //调用parse方法，将字符串转化为日期 6         Date date; 7         try { 8             date = sd.parse(day); 9             System.out.println(date);10         } catch (ParseException e) {11             // TODO Auto-generated catch block12             e.printStackTrace();13         }

运行结果：

结果分析：

代码中的 “yyyy年MM月dd日 HH:mm:ss” 指定了字符串的日期格式，调用 parse() 方法将文本转换为日期。因为将字符串转换为Date类型可能会抛出异常，所以要用try-catch语句捕获。

一定要注意哦：

1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理。

2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包。

三、Calendar 类的应用

Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();

那么如何使用 Calendar 获取年、月、日、时间等信息呢？我们来看下面的代码：

 1 public static void main(String[] args)  { 2         // TODO Auto-generated method stub 3          Calendar c = Calendar.getInstance();//创建Calendar对象 4          int year = c.get(Calendar.YEAR);//获取年 5          int month = c.get(Calendar.MONTH)+1;//获取月份，0表示一月份 6          int day = c.get(Calendar.DAY_OF_MONTH);//获取日期 7          int hour = c.get(Calendar.HOUR_OF_DAY);//获取小时 8          int minute = c.get(Calendar.MINUTE);//获取分钟 9          int second = c.get(Calendar.SECOND);//获取秒10          System.out.println("当前时间："+year+"-"+month+"-"+day+"-"+hour+":"+minute+":"+second);11     12     }

运行结果：

结果分析：

调用 Calendar 类的 getInstance() 方法获取一个实例，然后通过调用 get() 方法获取日期时间信息，参数为需要获得的字段的值， Calendar.Year 等为 Calendar 类中定义的静态常量。

注意：其中有两个特别的参数：DAY_OF_MONTH和HOUR_OF_DAY，千万不要写成DAY和HOUR了；MONTH获取的月份，0表示一月。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。如下所示：

1  Date date=c.getTime();//将Calendar对象转换为Date对象2          Long time=c.getTimeInMillis();//获取当前毫秒数3          System.out.println("当前时间："+date);4          System.out.println("当前毫秒数"+time);

运行结果：

总结：

 1.通过调用 getInstance() 静态方法获取一个 Calendar 对象---对象初始化

　　Calendar c = Calendar.getInstance();

2.通过调用 get() 方法获取日期时间信息

　　int month=c.get(Calendar.MONTH)+1;----0表示1月份

3.提供 getTime() 方法，用来获取 Date 对象

　　Date date=c.getTime();----将Calender对象转换为Date对象

4.通过 getTimeInMillis() 方法，获取此 Calendar 的时间值

　　long time=c.getTimeInMillis();----获取当前毫秒

四、使用 Math 类操作数据

Math 类位于 java.lang 包中，包含用于执行基本数学运算的方法， Math 类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名，如： Math.round();

常用的方法：

下面用代码来实现:

 1 public static void main(String[] args)  { 2         double a=12.81; 3         int b=(int)a;//强制类型转换 4         System.out.println("强制类型转换："+b); 5         long c=Math.round(a);//调用round方法，进行四舍五入 6         System.out.println("四舍五入："+c); 7         double d=Math.floor(a);//调用floor方法，返回小于参数的最大整数 8         System.out.println("floor方法："+d); 9         double e=Math.ceil(a);//调用ceil方法，返回大于参数的最小整数10         System.out.println("ceil方法："+e);11         double x=Math.random();//调用random方法，产生[0,1)之间的随机数12         System.out.println("随机数："+x);13         int y=(int)(Math.random()*100);//产生[0,100)之间的随机数14         System.out.println("[0,100)之间的随机数："+y);15 16     }

运行结果：

注意：要注意Math各个方法返回值类型，可以用强制类型转换来转为自己想要的类型。

PS： Math 类还提供了许多其他方法，各位小伙伴们可以按需去API文档查找想要知道的方法。

以上就是Java 中必须了解的常用类的汇总的详细内容，更多请关注php中文网其它相关文章！

Java 对象的克隆Clone和必须了解的浅拷贝与深拷贝

前言

为什么要写这篇文章？

因为我最近无意间看到了一些项目的代码，不管是曾经编码的人还是新接手的人， 在想完全克隆复制一个已经存在的对象，做为后续的使用，竟然都是采取了重写new一个，然后一个个属性字段值get出来再set回去，这种代码段让我不禁陷入了沉思。

简单描述下场景：

已经存在一个对象  sheep，里面已经有了一些字段属性值；

因为业务处理需要，想整一个跟这个sheep 对象一模一样的 sheep2 出来；

然后在不管是使用sheep 或者 sheep2 的时候，都互不干扰。

正文

那么实现这个场景，最简单最高效的方法是什么呢？

那就是使用克隆 clone。

ps： 当然不妨可能有一些粗心大意的人或者是新手来说，还会写出以下这种代码，这里不多言。

那么接下来进入正题，clone 克隆的使用。

在结合代码介绍clone前， 必须要先列出一些概念理论知识。

1. 我们使用的 clone（）方法，来自于 java类 Object ，也就是所有的java类都继承的java.lang.Object ，用的就是Object里面的clone（）。

2. 使用clone（）拷贝出来的对象，有自己新的内存地址，而不是跟被拷贝对象一样指向同一个内存地址。

3.使用clone（）拷贝对象跟new 对象的区别是，new是出来一个初始化新对象，而clone是复制出来一个包含原对象一些信息数据的新对象。

结合实例：

要使用clone（），那么类就需要实现 Cloneable 接口。

如：

那么可能有的人就发现了，实现了这个Cloneable，编辑工具没有提示我们去重写方法之类的？？

或是动手能力强的人，点进去了Object的clone方法源码里面，发现是一个空方法？？

简短地解惑：

关键在于，native这个关键字，使用这个关键字修饰的方法（如果平时有多点源码的，应该对这个关键字不陌生），代表这个方法实现体被调用，是告知 jvm去调用非java代码编写的实现体，例如C语言编写的等。而 jvm能否去调用这个实现体，也就是根据咱们是否有实现了Cloneable这个接口做为标记。

（可以看看设计者在Cloneable留下来的注释，多看源码肯定是有益的。） 

好了，不啰嗦，咱们要在Sheep.java 类上使用clone（）方法去实现克隆。
我们需要就是实现Cloneable接口，以及重写clone方法，而且把重写的clone方法的protected  改完 public 。

如：

public class Sheep implements Cloneable {

    private String name;
    private Integer age;


    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name=''" + name + ''\'''' +
                ", age=" + age +
                ''}'';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

仅到此，我们来写个测试方法，试一下克隆一个sheep对象,生成 sheep2对象：

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

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);

        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");

        Sheep sheep2 = (Sheep) sheep.clone();

        System.out.println("克隆出来的 sheep2:" +sheep2.toString());
        System.out.println("sheep 与 sheep2 的内存地址是否一样 ： "+ (sheep2==sheep));

        sheep2.setName(" update from sheep2");

        System.out.println("修改 sheep2 的name后, sheep："+sheep.toString());

        System.out.println("修改 sheep2 的name后, sheep2："+sheep2.toString());
    }

可以看到结果：

到这里是否就认为clone的使用就这样子ok了呢？

确实，如果你需要进行克隆的对象里面，只包含基本变量的话，这种clone的使用确实已经足够了。

但是如果里面包含的不只是基本变量，还存在其他对象的引用，那么就涉及到了深拷贝与浅拷贝的知识。

注意注意注意，当对象内包含其他对象的引用， clone 克隆出来的对象，并没有真正的实现数据克隆！ 这就是使用clone需要考虑的深浅拷贝问题！

深拷贝  与  浅拷贝

在我们结合代码实例前，我们先了解下这个深拷贝，浅拷贝的概念理论知识：

浅拷贝： 指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。

深拷贝 ：深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。

这么一看，是不是发现了我们上面的例子里面，其实就是属于浅拷贝，确实如此。

因为对于clone方法来说，

如果不对clone（）方法进行改造，那么默认的使用，都是浅拷贝。

结合实例：

可见现在的sheep类里已经除了基本变量还包含了额外的对象引用 Wool

Wool.java

那么基于这种情况，我们来试试此时浅拷贝克隆出来的情景：

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

        Wool wool=new Wool();
        wool.setColor("Red Red Red Red");

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);
        sheep.setWool(wool);
        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");
        Sheep sheep2 = (Sheep) sheep.clone();
        System.out.println("克隆出来的 sheep2:" +sheep2.toString());

        System.out.println("------对sheep2的Wool 颜色属性进行修改------");
        sheep2.getWool().setColor("Black Black  Black");

        System.out.println("修改 wool颜色后, sheep："+sheep.toString());

        System.out.println("修改 wool颜色后,, sheep2："+sheep2.toString());
    }

结果：

为什么？

因为这是浅度拷贝，对除了基本变量的属性值复制外，对里面的wool对象引用并没有额外分配新的内存地址，所以一旦修改了wool，无论是修改sheep的wool属性还是sheep2的属性， 都会致使 使用到wool对象的对象实例 受影响。

所以对于这种实例里面包含了其他对象的引用，在我们使用克隆clone方法时，我们需要对clone（）进行改造，实现深拷贝。

这样不管后续怎么去修改，克隆出来的对象与被克隆的对象都互不干扰。

进行改造，如上面的分析，我们需要在对Sheep进行克隆的时候，对里面的Wool也分配新的内存地址。

所以：

改造步骤1，让Wool也实现Cloneable，里面wool的重写的clone方法来进行新的内存地址划分。

改造步骤2，在Sheep的clone方法里，调用wool的clone方法然后再赋值。

具体代码:

步骤1

Wool.java

public class Wool  implements Cloneable{

    private String color;


    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Wool{" +
                "color=''" + color + ''\'''' +
                ''}'';
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

步骤2：

Sheep.java

public class Sheep implements Cloneable {

    private String name;
    private Integer age;
    private Wool wool;

    @Override
    public Object clone() throws CloneNotSupportedException {

        Sheep sheep= (Sheep) super.clone();
        sheep.wool= (Wool) wool.clone();
        return sheep;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name=''" + name + ''\'''' +
                ", age=" + age +
                ", wool=" + wool +
                ''}'';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Wool getWool() {
        return wool;
    }

    public void setWool(Wool wool) {
        this.wool = wool;
    }
}

Sheep的clone方法改造分析：

测试方法：

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

        Wool wool=new Wool();
        wool.setColor("Red Red Red Red");

        Sheep sheep=new Sheep();
        sheep.setName("merry");
        sheep.setAge(5);
        sheep.setWool(wool);
        System.out.println("克隆前 sheep :"+sheep.toString());
        System.out.println("-----进行克隆-----");
        Sheep sheep2 = (Sheep) sheep.clone();
        System.out.println("克隆出来的 sheep2:" +sheep2.toString());

        System.out.println("------对sheep2的Wool 颜色属性进行修改------");
        sheep2.getWool().setColor("Black Black  Black");

        System.out.println("修改 wool颜色后, sheep："+sheep.toString());

        System.out.println("修改 wool颜色后,, sheep2："+sheep2.toString());
    }
}

测试结果：

ps： 深拷贝，大家理解意思后，其实应该清楚，实现的方式很多种，那么还有哪些方式实现呢？ 不妨自己探索下。

好了，该篇就到此。

我们今天的关于.NET架构转Java开发必须了解的历史和.net转型java的分享已经告一段落，感谢您的关注，如果您想了解更多关于.NET开发必须了解的几个工具（单元测试）、5款Java程序员必须了解的错误跟踪工具、Java 中必须了解的常用类的汇总、Java 对象的克隆Clone和必须了解的浅拷贝与深拷贝的相关信息，请在本站查询。