Java进阶学习1:【Object类、时间日期类、System类、StringBuilder、包装类】

  • A+
所属分类:Java Java进阶

第一章.Object

01. Object类的介绍

Object是所有类的父类,所有类都直接或者间接的继承自Object。

如果我们在一个类中没有使用extends继承其他类,那么这个类是默认继承自Object的。

02. Object的toString方法

/*
    在Object中,有一个方法叫做toString,可以将对象转成一个字符串。
    String toString():返回对象的字符串表示形式。
    当通过一个对象调用toString方法时,会先看一下自己有没有这个方法,如果自己没有,那么就会向上找父类,    一直到Object。Object中的toString方法,是将对象转成地址值的字符串。

    当我们直接输出一个对象名时,内部会调用这个对象的toString方法, 这个对象的toString方法的内容是什    么,那么直接输出这个对象名的结果就是什么。

    一般来说,输出地址值没有什么意义。 如果想要调用toString方法后得到我们想要的内容,比如对象的属性,     那么我们可以在子类中重写toString。
 */
public class Demo02ObjectToString {
    public static void main(String[] args) {
        //创建一个Person对象
        Person p = new Person("小苍", 36);
        //调用该对象的toString方法。
        System.out.println(p.toString());//小苍-36
        //直接输出这个对象的对象名
        System.out.println(p); //小苍-36
    }
}
public class Person/*extends Object*/{
    //姓名
    private String name;
    //年龄
    private int age;

    //重写toString方法,使用快捷键一步到位: alt + insert
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

03. Object中的equals方法

/*
    在Object中,有一个方法叫做equals,这个方法可以比较两个对象是否相同。
    boolean equals(Object obj): 比较两个对象是否相同。

    当我们通过一个对象调用equals方法时,会先看一下自己有没有这个方法,如果自己没有,就会向上找父类,一    直到Object。
    Object中的equals是使用==比较对象的地址值。

    比较对象的地址值一般没有意义,如果我们要自己定义比较的规则(比如对象的属性完全相同就看成是同一个对    象), 那么我们可以在子类中重写equals
 */
public class Demo03ObjectEquals {
    public static void main(String[] args) {
        //创建三个Person对象
        Person p1 = new Person("王宝强", 30);
        Person p2 = new Person("贾乃亮", 32);
        Person p3 = new Person("贾乃亮", 32);
        //输出对象使用==比较的结果
        System.out.println(p1 == p2); //false
        System.out.println(p2 == p3); //false
        System.out.println("============");
        System.out.println(p1.equals(p2));//false
        System.out.println(p2.equals(p3));//true
    }
}

public class Person/*extends Object*/{
    //姓名
    private String name;
    //年龄
    private int age;

    //alt + insert: 直接生成equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //重写equals方法,定义自己的比较规则,对象的属性如果完全相同,那么就看成是同一个对象
    //要比较的两个对象,一个是参数obj, 另一个是调用者(使用this表示)
    /*
    @Override
    public boolean equals(Object obj) {
        //为了保证程序的健壮性,先加入非空判断。
        if(obj == null) {
            return false;
        }
        //判断参数obj是否是一个Person对象,如果不是Person,那么其实就不需要比较了。 如果是人,那么才需要比较。
        //使用instanceof进行判断,判断obj是否是一个Person
        if(obj instanceof Person) {
            //如果obj表示的是Person对象,那么就进行操作。
            //向下转型,将obj转型成Person
            Person p = (Person) obj;
            //对两个对象的姓名和年龄进行比较,如果完全相同,那么就表示两个对象是相同的对象,那么就返回true。
            return this.getName().equals(p.getName()) && this.getAge() == p.getAge();
        }
        //其他情况,直接返回false。
        return false;
    }
    */

    //重写toString方法,使用快捷键一步到位: alt + insert
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写toString方法。
    //ctrl + o:可以直接重写父类的任何方法
    /*
    @Override
    public String toString() {
        return name + "-" + age;
    }
    */
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

04. Objects的equals方法

/*
    在JDK7之后,多了一个类,叫做Objects。 他是一个操作对象的工具类。
    Objects有一个方法叫做equals,可以比较两个对象是否相同。
    static boolean equals(Object a, Object b): 比较a对象和b对象是否相同。

    当我们调用Objects的equals方法比较两个对象时, 内部其实真正是调用的Object的equals进行的比较。
    如果想要通过属性比较两个对象是否相同,那么还需要重写equals方法。
 */
public class Demo04ObjectsEquals {
    public static void main(String[] args) {
        //创建两个Teacher对象
        Teacher t1 = new Teacher("小苍老师", 30);
        Teacher t2 = new Teacher("小苍老师", 30);
        //使用Objects的equals方法进行比较
        System.out.println(Objects.equals(t1, t2));//false
        System.out.println("===============");
        //Objects的equals和Object的equals的区别。
        Teacher t3 = null;
        Teacher t4 = null;
        //使用Object的equals进行比较。
        //通过null访问任何属性或方法都会引发空指针异常。
        //System.out.println(t3.equals(t4)); //NullPointerException
        //使用Objects的equals进行比较
        System.out.println(Objects.equals(t3, t4)); //true
    }
}

public class Teacher {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Teacher teacher = (Teacher) o;

        if (age != teacher.age) return false;
        return name != null ? name.equals(teacher.name) : teacher.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    public Teacher() {
    }

    public Teacher(String name, int age) {

        this.name = name;
        this.age = age;
    }

    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;
    }
}

第二章.时间日期类

05. Date的介绍以及构造方法

/*
    Java中,有一个类叫做Date(java.util.Date), 这个类叫做日期类,
    但是Java中的Date类表示的是特定的时间瞬间, 精确到了毫秒。

    构造方法:
    Date():使用空参构造方法创建的Date对象会以当前操作系统的时间构建一个Date。
    Date(long date):参数要传递一个long类型的毫秒值。 表示从1970年1月1日 0点0分0秒开始过了多少毫秒。
    中国使用的是北京时间,北京时间是东八区,比标准时间快八个小时。 时间是从1970年1月1日 8点0分0秒开始的。
 */
public class Demo01Date {
    public static void main(String[] args) {
        //使用空参构造创建对象。表示的是当前操作系统的时间
        Date date = new Date();
        System.out.println(date);
        //使用有参构造创建Date对象,传递一个毫秒值
        Date date2 = new Date(0L);
        System.out.println(date2);
    }
}

06. Date的getTime方法

/*
    在Date类中,有一个方法叫做getTime,可以获取Date对象对应的毫秒值。
        long getTime(): 获取Date对象表示的毫秒并返回。
 */
public class Demo02Date {
    public static void main(String[] args) {
        //创建一个Date对象, 表示的是当前操作系统的时间
        Date date = new Date();
        //调用date对象的getTime方法,获取Date对象对应的毫秒值
        long millis = date.getTime();
        //输出
        System.out.println(millis);
    }
}

07. Date的setTime方法

/*
    在Date类中,有一个方法叫做setTime,可以设置Date对象的毫秒值。
    void setTime(long time):设置Date对象表示的时间(毫秒值)。 调用此方法后,Date对象表示的时间会发生改变。
 */
public class Demo03Date {
    public static void main(String[] args) {
        //创建一个Date对象,表示当前操作系统的时间
        Date date = new Date();
        //调用date对象的setTime方法,重新设置时间
        date.setTime(0L); //把date对象表示的时间进行了改变。 因为参数是0,所以新的时间为从1970年(时间原点)开始过了0毫秒。
        //输出date对象
        System.out.println(date);
    }
}

08. DateFormat的format方法

/*
    如果想要把一个Date对象转成一个指定格式的字符串,那么可以使用DateFormat类去实现。
    DateFormat是一个抽象类,如果要用,需要使用子类SimpleDateFormat

    构造方法:
    SimpleDateFormat(String pattern): 参数需要传递一个字符串类型的模式。

    举例:
        要转成的格式: 2019年03月22日 10时17分54秒
        对应的模式:   yyyy年MM月dd日 HH时mm分ss秒
        就是使用英语字母替换掉数字。
        y:年
        M:月
        d:日
        H:时
        m:分
        s:秒

    其他的方法:
    String format(Date date) :将参数Date对象格式化为一个字符串。并把这个字符串返回。

    日期格式化的步骤:
        1. 创建一个Date对象。
        2. 创建一个SimpleDateFormat对象,在构造方法中给出指定的模式。
        3. 调用SimpleDateFormat对象的format方法,将Date对象转成一个字符串。
 */
public class Demo01DateFormat {
    public static void main(String[] args) {
        //创建一个Date对象
        Date date = new Date();
        //2. 创建一个SimpleDateFormat对象,在构造方法中给出指定的模式。
        //要转成的日期格式为:  2019年03月22日 10时17分54秒
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //要转成的日期格式为: 2019-03-22 10:17:54
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //3. 调用SimpleDateFormat对象的format方法,将Date对象转成一个字符串。
        String str = sdf.format(date);
        System.out.println("str:" + str);
    }
}

09.DateFormat的parse方法

/*
    如果要把一个字符串转成一个Date对象,那么我们可以使用SimpleDateFormat去完成。
    使用的方法:
    Date parse(String source):将字符串转成(解析)一个Date对象并返回

    使用步骤:
        1. 定义一个字符串,表示时间。
        2. 创建一个SimpleDateFormat对象, 参数位置指定一个模式。
        3. 调用SimpleDateFormat的parse方法,将字符串转成一个Date对象。

    注意:
        1. 调用parse方法后会有一个红色波浪线的错误。 这个操作需要抛异常(以后讲解)。
           解决方式: 把光标移动到红色波浪线上面,然后按alt + 回车,选择第一个。
        2. SimpleDateFormat构造方法中传递的模式必须和要转换的字符串格式一致。否则会报错。

    小结:
        Date->String:格式化。 使用SimpleDateFormat的format方法去完成。
        String->Date:解析。 使用SimpleDateFormat的parse方法去完成。
 */
public class Demo02DateFormat {
    public static void main(String[] args) throws ParseException {
        //1. 定义一个字符串,表示时间。
        String str = "2019-03-22 10:27:13";
        //2. 创建一个SimpleDateFormat对象, 参数位置指定一个模式。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //3. 调用SimpleDateFormat的parse方法,将字符串转成一个Date对象。
        Date date = sdf.parse(str);
        //4. 输出date对象
        System.out.println(date);
    }
}

10. Calendar的getInstance方法

/*
    在Date类中有很多方法都已经过时了,原因是因为在Calendar中有了更好的方法可以代替他们。

    Calendar叫做日历类。 和Date一样,Calendar也可以表示精确的时间瞬间(精确到毫秒)

    Calendar是一个抽象类, 如果要用,需要使用它的子类。
    因为地区敏感性, Calendar的子类对象不能由我们自己去new,而是要调用Calendar的静态方法            getInstance进行获取。

    Calendar中的方法:
    static Calendar getInstance(): 获取一个Calendar子类对象, 然后把这个子类对象返回了。

    获取Calendar对象的方式:
    之前都是通过new的方式获取一个对象,而此时是通过Calendar的静态方法getInstance获取的Calendar对象(真正是Calendar子类对象)
 */
public class Demo01Calendar {
    public static void main(String[] args) {
        //通过Calendar的静态方法获取一个日历对象
        Calendar c = Calendar.getInstance();
        //进行输出
        System.out.println(c);
    }
}

11. Calendar中的get方法

/*
    在Calendar中,有一个方法叫做get,可以获取到指定字段的值:
    int get(int field): 参数field表示要获取哪个字段的值。
    举例:
        get(年): 获取年这个字段的值。
        get(月): 获取月这个字段的值
        get(日): 获取日这个字段的值。

    get方法参数是int类型, 所以我们要使用数字表示对应的字段。
    如果在get方法中传递数字的话,会大大的影响我们程序的可阅读性。
    我们可以使用Calendar中的静态常量代替这些数字, 这些常量的常量名具有见名之意的效果, 每一个常量都表    示一个数字。
    注意:
        Calendar中的月份是从0开始的范围是(0-11)。 Calendar中的月份比现实生活要少1
 */
public class Demo02Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //获取年的值进行输出
        int year = c.get(Calendar.YEAR);
        System.out.println(year);
        //获取月的值进行输出
        int month = c.get(Calendar.MONTH) + 1;
        System.out.println(month);
        //获取日的值进行输出
        int day = c.get(Calendar.DATE);
        System.out.println(day); 
    }
}

12. Calendar中的set方法

/*
    在Calendar中还有一个方法叫做set,可以给指定字段设置值。
    void set(int field, int value): 可以给指定字段设置值。
            参数field:表示要给哪个字段设置值。
            参数value:表示要设置成什么值。
 */
public class Demo03Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //输出这个日历对象的年月日的值
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE));
        //使用set方法,给日历对象重新设置值
        c.set(Calendar.YEAR, 2012);
        c.set(Calendar.MONTH, 4); //表示的是现实生活中的5月
        c.set(Calendar.DATE, 11);
        //重写输出这个日历对象的年月日的值。
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE));
    }
}

13. Calendar中的add方法

/*
    在Calendar中,还有一个方法叫做add,可以对指定字段的值进行计算。
    void add(int field, int amount): 可以对指定字段的值进行计算。
            参数field: 表示要对哪个字段进行计算。
            参数amount: 表示如何计算。 如果该参数是正数,那么就是加上该值。
                                    如果该参数是负数,那么就是减去该值。
 */
public class Demo04Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //输出该日历对象的年月日的值。
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) +         "-" + c.get(Calendar.DATE));
        //使用add方法,对年进行计算, 加上2年
        //c.add(Calendar.YEAR, 2);
        //使用add方法对月进行计算
        c.add(Calendar.MONTH, 10);
        //重新输出
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) +         "-" + c.get(Calendar.DATE));
    }
}

14. Calendar中的getTime方法

/*
    在Calendar中还有一个方法叫做getTime,可以获取到Calendar对应的Date对象
    Date getTime(): 获取Calendar对应的Date对象
 */
public class Demo05Calendar {
    public static void main(String[] args) {
        //获取一个日历对象
        Calendar c = Calendar.getInstance();
        //将这个日历对象转成一个Date对象。
        Date date = c.getTime();
        //输出date的值
        System.out.println(date);
    }
}

第三章. System类

15. System的currentTimeMillis的使用

/*
    System叫做系统类,里面有很多方法都和系统有关。

    常见方法:
    static long currentTimeMillis():获取当前操作系统的时间(以毫秒值表示的)
 */
public class Demo01System {
    public static void main(String[] args) {
        //调用System的currentTimeMillis获取当前的时间
        long millis = System.currentTimeMillis();
        System.out.println(millis);
    }
}

练习:

/*
    要求: 统计输出1000次HelloWorld使用的时间。

    步骤:
        1. 在输出之前记录当前的时间。
        2. 输出1000次HelloWorld
        3. 在输出之后记录当前的时间。
        4. 让这两个时间相减
 */
public class Demo02SystemTest {
    public static void main(String[] args) {
        //1. 在输出之前记录当前的时间。
        long start = System.currentTimeMillis();
        //2. 输出1000次HelloWorld
        for(int i = 0; i < 1000; i++) {
            System.out.println("HelloWorld");
        }
        //3. 在输出之后记录当前的时间。
        long end = System.currentTimeMillis();
        //4. 让这两个时间相减
        System.out.println(end - start);
    }
}

16. System的arraycopy方法

/*
    在System中有一个方法可以对数组进行复制,这个方法叫做arraycopy
    static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length): 对数组进行复制的方法。
            参数src:表示源数组。
            参数srcPos: 表示源数组的起始位置。
            参数dest: 表示目标数组。
            参数destPos: 表示目标数组的起始位置。
            参数length: 表示要复制几个元素。
    要求:
    将src数组中前3个元素,复制到dest数组的前3个位置上
    复制元素前:src数组元素[1,2,3,4,5],dest数组元素[6,7,8,9,10]
    复制元素后:src数组元素[1,2,3,4,5],dest数组元素[1,2,3,9,10]

    arraycopy是系统级别的,性能非常高。
 */
public class Demo03System {
    public static void main(String[] args) {
        //定义两个数组
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,10};
        //进行复制,将src数组的前三个元素,复制到dest数组的前3个位置上。
        System.arraycopy(src, 0, dest, 0, 3);//将src中的内容复制到dest。 从src中索引为0的位置开始复制,从dest数组索引为0的位置开始放, 一共复制3个。
        //输出两个数组的结果
        System.out.println("src:" + Arrays.toString(src));
        System.out.println("dest:" + Arrays.toString(dest));
    }
}

第四章. StringBuilder

17. String拼接产生的问题

/*
    字符串拼接的问题

    因为字符串具有不变性,所以每次对字符串进行拼接,都会产生新的字符串。这样既耗时又浪费空间。

    StringBuilder可以变的, 如果使用StringBuilder进行拼接,效率会更高。
 */
public class Demo01String {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

18. StringBuilder的介绍

StringBuilder是一个可变的字符序列。 我们可以把它看成一个可变的字符串。
StringBuilder的本质和String一样,都是由一个字符数组组成的,在使用字符数组保存数据。

String和StringBuilder的区别:
        String是不可以改变的。
        StringBuilder是可以改变的。

19. StringBuilder的构造方法

/*
    StringBuilder的构造方法:
    StringBuilder(): 空参构造。 使用这个构造方法创建的StringBuilder对象,里面不会保存任何内容
    StringBuilder(String str): 会根据参数字符串构建一个StringBuilder对象
 */
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //使用空参数构造方法创建对象
        //使用空参构造创建的StringBuilder对象中没有任何内容。 相当于 String str = ""
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        //使用有参构造创建一个StringBuilder对象
        StringBuilder newSb = new StringBuilder("你好,你今天早上吃了吗");
        System.out.println("newSb:" + newSb);//你好,你今天早上吃了吗
    }
}

20. StringBuilder的常见方法

/*
    StringBuilder中的常见方法:
    StringBuilder append(任何类型): 对任何类型的数据进行拼接。返回值表示调用者对象本身。
    String toString(): 将StringBuilder转成一个String并返回。
 */
public class Demo03StringBuilder {
    public static void main(String[] args) {
        //创建一个StringBuilder对象
        StringBuilder sb = new StringBuilder();
        //StringBuilder newSb = sb.append("你好");
        //输出
        //System.out.println("sb:" + sb);
        //System.out.println("newSb:" + newSb);

        //拼接任何类型的数据
        /*
        sb.append("你好");
        sb.append(10);
        sb.append(3.14);
        sb.append(true);
        sb.append('a');
        */
        //链式编程。
        sb.append("你好").append(10).append(3.14);

        //进行输出
        System.out.println("sb:" + sb); //你好103.14
        //String toString(): 将StringBuilder转成一个String并返回
        String str = sb.toString();
        System.out.println("str:" + str);//你好103.14
    }
}

第五章. 包装类

21. 包装类的介绍

每一个基本类型都有其对应的引用类型(包装类)

基本类型            引用类型(包装类)
byte                  Byte
short                Short
int                    Integer(特殊)
long                Long
float                Float
double            Double
boolean          Boolean
char                Character(特殊)

基本类型其实就是简单的数据,用法也非常简单,只能直接使用或运算,不能调用方法。
引用类型(包装类)可以创建对象, 这样的话他们不仅可以表示数据,也可以调用方法完成一些功能。

包装类的功能比其对应的基本类型的功能要强大。基本类型能做的,对应的包装类也能做。

22. 自动拆装箱

/*
    在JDK5的时候,出现了一个新特性,叫做自动拆装箱
    拆箱: 包装类转成对应的基本类型。
    装箱: 基本类型转成对应的包装类。
 */
public class Demo01Warp {
    public static void main(String[] args) {
        //自动装箱。 把int类型的10自动转成了Integer类型。
        Integer a = 10;
        //自动装箱。 把int类型的20自动转成了Integer类型。
        Integer b = 20;
        //会先把Integer类型的a和b自动拆箱为int类型,a和b相加求出来的结果是int类型。 然后又把这个int类型的结果自动装箱成了Integer。
        Integer sum = a + b;
        System.out.println(sum);
    }
}

23. 手动拆装箱

/*
    手动拆装箱
    手动装箱(int -> Integer)
    可以使用包装类(Integer)中的valueOf的方法
    static Integer valueOf(int i):传递一个int类型的数据,返回一个Integer类型的结果。

    手动拆箱(Integer -> int)
    使用包装类(Integer)中的intvalue方法
    int intValue() :将Integer的值转成int并返回。
 */
public class Demo02Warp {
    public static void main(String[] args) {
        //定义一个变量
        int num = 10;
        //把int类型的变量手动装箱为Integer类型
        Integer warpNum = Integer.valueOf(num);
        System.out.println(warpNum);
        System.out.println("===============");
        int basicNum = warpNum.intValue();
        System.out.println(basicNum);
    }
}

24. 基本类型和字符串的相互转换

/*
    基本类型和字符串的相互转换
    基本类型转字符串:
        1. 可以使用String的静态方法valueOf。 不推荐
        2. 可以使用包装类的toString方法。 不推荐。
        3. 直接在这个基本类型数据的后面加上""。 推荐

    字符串转基本类型:
        我们需要使用对应包装类的parseXXX方法(静态方法)。
        如果要把字符串转成int,那么我们可以使用Integer的parseInt方法。
        如果要把字符串转成double,那么我们使用Double的parseDouble方法。
        如果要把字符串转成long,那么我们可以使用Long的parseLong方法。

 */
public class Demo02Parse {
    public static void main(String[] args) {
        //定义一个数字
        int num = 10;
        //把num转成字符串
        //String numStr = String.valueOf(num);
        //String numStr = Integer.valueOf(num).toString();
        String numStr = num + "";
        System.out.println("numStr:" + numStr);
        System.out.println("=============");
        //定义一个字符串
        String str = "12345";
        int basicNum = Integer.parseInt(str);
        System.out.println("basicNum:" + basicNum);
    }
}
  • 资源分享QQ群
  • weinxin
  • 官方微信公众号
  • weinxin
沙海
一个Java基础入门的教程视频
Java图书管理系统
C语言郝斌老师教程
动力节点最牛Java自学基础教程

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: