1. day03【常用API】

1.1. 今日内容

  • Object类
  • 时间日期类
  • Math类
  • System类
  • BigInteger类
  • BigDecimal类
  • Arrays类
  • 包装类
  • String类的常用方法

1.2. 教学目标

  • [ ] 能够说出Object类的特点
  • [ ] 能够重写Object类的toString 和 equals方法
  • [ ] 能够使用Date类获取当前系统时间
  • [ ] 能够使用DateFormat完成日期的格式化和解析
  • [ ] 能够使用Calendar类的get、set、add方法操作日历时间
  • [ ] 能够使用Math类的abs、ceil、floor、pow、round方法
  • [ ] 能够使用System类的currentTimeMillis方法获取时间
  • [ ] 能够说出BigInteger可以解决的问题
  • [ ] 能够说出BigDecimal可以解决的问题
  • [ ] 能够使用Arrays类的sort、toString方法
  • [ ] 能够说出自动装箱、自动拆箱的概念
  • [ ] 能够完成基本数据类型与字符串之间的转换
  • [ ] 能够熟悉String类常用方法的功能及使用

2. 第一章 Object类

2.1. 1 概述

java.lang.Object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是Object。

如果一个类没有特别指定父类, 那么默认则继承自Object类。

例如:

public class MyClass /*extends Object*/ {
      // ...
}

根据JDK源代码及Object类的API文档,Object类当中包含的方法有11个。今天我们主要学习其中的2个:

  • public String toString():返回该对象的字符串表示。
  • public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。

2.2. 2 toString方法

2.2.1. 方法摘要

  • public String toString():返回该对象的字符串表示。

toString方法返回该对象的字符串表示,其实该字符串内容就是:对象的类型名+@+内存地址值。

由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。

2.2.2. 覆盖重写

如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:

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

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

    // 省略构造器与Getter Setter
}

在IntelliJ IDEA中,可以点击Code菜单中的Generate...,也可以使用快捷键alt+insert,点击toString()选项。选择需要包含的成员变量并确定。

小贴士: 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

小结:toString方法可以将对象转成字符串。

2.3. 3 equals方法

2.3.1. 方法摘要

  • public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

2.3.2. 默认地址比较

如果没有覆盖重写equals方法,那么Object类中默认进行==运算符的对象地址比较,只要不是同一个对象,结果必然为false。

2.3.3. 对象内容比较

如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。例如:

import java.util.Objects;

public class Person {    
    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;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等,并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

这段代码充分考虑了对象为空、类型一致等问题,但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中,可以使用Code菜单中的Generate…选项,也可以使用快捷键alt+insert,并选择equals() and hashCode()进行自动代码生成。

tips:Object类当中的hashCode等其他方法,今后学习。

小结:equals方法可以判断两个对象是否相同,如果要定义自己的比较规则,需要进行重写。

2.4. 4 native本地方法

在Object类的源码中定义了 native 修饰的方法, native 修饰的方法称为本地方法。

  • 本地方法的作用: 就是Java调用非Java代码的接口。方法的实现由非Java语言实现,比如C或C++。

  • 当我们需要访问C或C++的代码时,或者访问操作系统的底层类库时,可以使用本地方法实现。

    也就意味着Java可以和其它的编程语言进行交互。

Object类源码(部分):

package java.lang;
/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {
    //本地方法
    private static native void registerNatives();
    //静态代码块
    static {
        registerNatives();
    }
    ......
    ......
}

2.5. 5 Objects类

在刚才IDEA自动重写equals代码中,使用到了java.util.Objects类,那么这个类是什么呢?

JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。方法如下:

  • public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码,学习一下:

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

3. 第二章 Date类

3.1. 1概述

java.util.Date类 表示特定的瞬间,精确到毫秒。

继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,我们重点看以下两个构造函数

  • public Date():从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象,分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。
  • public Date(long date):将指定参数的毫秒值date,转换成Date对象,分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。

tips: 由于中国处于东八区(GMT+08:00)是比世界协调时间/格林尼治时间(GMT)快8小时的时区,当格林尼治标准时间为0:00时,东八区的标准时间为08:00。

简单来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。例如:

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        // 创建日期对象,把当前的时间
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020
        // 创建日期对象,把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

tips:在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。

3.2. 2 常用方法

Date类中的多数方法已经过时,常用的方法有:

  • public long getTime() 把日期对象转换成对应的时间毫秒值。
  • public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象

示例代码

public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();

        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
        //System.out.println(d.getTime());
        //System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //public void setTime(long time):设置时间,给的是毫秒值
        //long time = 1000*60*60;
        long time = System.currentTimeMillis();
        d.setTime(time);

        System.out.println(d);
    }
}

小结:Date表示特定的时间瞬间,我们可以使用Date对象对时间进行操作。

4. 第三章 DateFormat类

4.1. 1概述

java.text.DateFormat 是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

  • 格式化:按照指定的格式,把Date对象转换为String对象。
  • 解析:按照指定的格式,把String对象转换为Date对象。

4.2. 2 构造方法

由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:

  • public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串,代表日期时间的自定义格式。

4.3. 3 格式规则

常用的格式规则为:

标识字母(区分大小写) 含义
y
M
d
H
m
s

备注:更详细的格式规则,可以参考SimpleDateFormat类的API文档。

4.4. 4 常用方法

DateFormat类的常用方法有:

  • public String format(Date date):将Date对象格式化为字符串。

  • public Date parse(String source):将字符串解析为Date对象。

    public class SimpleDateFormatDemo {
        public static void main(String[] args) throws ParseException {
            //格式化:从 Date 到 String
            Date d = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String s = sdf.format(d);
            System.out.println(s);
            System.out.println("--------");
    
            //从 String 到 Date
            String ss = "2048-08-09 11:11:11";
            //ParseException
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date dd = sdf2.parse(ss);
            System.out.println(dd);
        }
    }
    

小结:DateFormat可以将Date对象和字符串相互转换。

5. 第四章 Calendar类

5.1. 1 概述

  • java.util.Calendar类表示一个“日历类”,可以进行日期运算。它是一个抽象类,不能创建对象,我们可以使用它的子类:java.util.GregorianCalendar类。
  • 有两种方式可以获取GregorianCalendar对象:
    • 直接创建GregorianCalendar对象;
    • 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象【本次课使用】

5.2. 2 常用方法

方法名 说明
public static Calendar getInstance() 获取一个它的子类GregorianCalendar对象。
public int get(int field) 获取某个字段的值。field参数表示获取哪个字段的值,
可以使用Calender中定义的常量来表示:
Calendar.YEAR : 年
Calendar.MONTH :月
Calendar.DAY_OF_MONTH:月中的日期
Calendar.HOUR:小时
Calendar.MINUTE:分钟
Calendar.SECOND:秒
Calendar.DAY_OF_WEEK:星期
public void set(int field,int value) 设置某个字段的值
public void add(int field,int amount) 为某个字段增加/减少指定的值

5.3. 3 get方法示例

public class Demo {
    public static void main(String[] args) {
        //1.获取一个GregorianCalendar对象
        Calendar instance = Calendar.getInstance();//获取子类对象

        //2.打印子类对象
        System.out.println(instance);

        //3.获取属性
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH) + 1;//Calendar的月份值是0-11
        int day = instance.get(Calendar.DAY_OF_MONTH);

        int hour = instance.get(Calendar.HOUR);
        int minute = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);

        int week = instance.get(Calendar.DAY_OF_WEEK);//返回值范围:1--7,分别表示:"星期日","星期一","星期二",...,"星期六"

        System.out.println(year + "年" + month + "月" + day + "日" + 
                               hour + ":" + minute + ":" + second);
        System.out.println(getWeek(week));

    }

    //查表法,查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

5.4. 4 set方法示例

public class Demo {
    public static void main(String[] args) {
        //设置属性——set(int field,int value):
        Calendar c1 = Calendar.getInstance();//获取当前日期

        //计算班长出生那天是星期几(假如班长出生日期为:1998年3月18日)
        c1.set(Calendar.YEAR, 1998);
        c1.set(Calendar.MONTH, 3 - 1);//转换为Calendar内部的月份值
        c1.set(Calendar.DAY_OF_MONTH, 18);

        int w = c1.get(Calendar.DAY_OF_WEEK);
        System.out.println("班长出生那天是:" + getWeek(w));


    }
    //查表法,查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

5.5. 5 add方法示例

public class Demo {
    public static void main(String[] args) {
        //计算200天以后是哪年哪月哪日,星期几?
        Calendar c2 = Calendar.getInstance();//获取当前日期
        c2.add(Calendar.DAY_OF_MONTH, 200);//日期加200

        int y = c2.get(Calendar.YEAR);
        int m = c2.get(Calendar.MONTH) + 1;//转换为实际的月份
        int d = c2.get(Calendar.DAY_OF_MONTH);

        int wk = c2.get(Calendar.DAY_OF_WEEK);
        System.out.println("200天后是:" + y + "年" + m + "月" + d + "日" + getWeek(wk));

    }
    //查表法,查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

6. 第五章 Math类

6.1. 1 概述

  • java.lang.Math(类): Math包含执行基本数字运算的方法。
  • 它不能创建对象,它的构造方法被“私有”了。因为他内部都是“静态方法”,通过“类名”直接调用即可。

6.2. 2 常用方法

方法名 说明
public static int abs(int a) 获取参数a的绝对值:
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整

6.3. 3 示例代码

public class Demo {
    public static void main(String[] args) {
        System.out.println("-5的绝对值:" + Math.abs(-5));//5
        System.out.println("3.4向上取整:" + Math.ceil(3.4));//4.0
        System.out.println("3.4向下取整:" + Math.floor(3.4));//3.0
        System.out.println("2的8次幂:" + Math.pow(2, 8));//256.0
        System.out.println("3.2四舍五入:" + Math.round(3.2));//3
        System.out.println("3.5四舍五入:" + Math.round(3.5));//4

    }
}

7. 第六章 System

7.1. 1 概述

java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作。

7.2. 2 常用方法

方法名 说明
public static void exit(int status) 终止当前运行的 Java 虚拟机,非零表示异常终止
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)

7.3. 3 练习

在控制台输出1-10000,计算这段代码执行了多少毫秒

import java.util.Date;
//验证for循环打印数字1-9999所需要使用的时间(毫秒)
public class SystemDemo {
    public static void main(String[] args) {
           //获取当前时间毫秒值
       System.out.println(System.currentTimeMillis()); 
      //计算程序运行时间
       long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒:" + (end - start));
    }  
}

8. 第七章 BigInteger类

8.1. 1 概述

java.math.BigInteger 类,不可变的任意精度的整数。如果运算中,数据的范围超过了long类型后,可以使用 BigInteger类实现,该类的计算整数是不限制长度的。

8.2. 2 构造方法

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围,已经不能称为数字了,因此构造方法中采用字符串的形式来表示超大整数,将超大整数封装成BigInteger对象。

8.3. 3 成员方法

BigInteger类提供了对很大的整数进行加、减、乘、除的方法,注意:都是与另一个BigInteger对象进行运算。

方法声明 描述
add(BigInteger value) 返回其值为 (this + val) 的 BigInteger,超大整数加法运算
subtract(BigInteger value) 返回其值为 (this - val) 的 BigInteger,超大整数减法运算
multiply(BigInteger value) 返回其值为 (this * val) 的 BigInteger,超大整数乘法运算
divide(BigInteger value) 返回其值为 (this / val) 的 BigInteger,超大整数除法运算,除不尽取整数部分

【示例】

public static void main(String[] args){
  BigInteger big1 = new BigInteger("8327432493258329432643728320843");
  BigInteger big2 = new BigInteger("98237473274832382943274328834");
  //加法运算
  BigInteger add = big1.add(big2);
  System.out.println("求和:"+add);
  //减法运算
  BigInteger sub = big1.subtract(big2);
  System.out.println("求差:"+sub);
  //乘法运算
  BigInteger mul = big1.multiply(big2);
  System.out.println("乘积:"+mul);
  //除法运算
  BigInteger div = big1.divide(big2);
  System.out.println("除法:"+div);
}

9. 第八章、BigDecimal类

9.1. 1 引入

使用基本类型做浮点数运算精度问题;

看程序说结果:

public static void main(String[] args) {
    System.out.println(0.09 + 0.01);//0.09999999999999999
    System.out.println(1.0 - 0.32);//0.6799999999999999
    System.out.println(1.015 * 100);//101.49999999999999
    System.out.println(1.301 / 100);//0.013009999999999999
}

对于浮点运算,不要使用基本类型,而使用"BigDecimal类"类型

9.2. 2 概述

相关内容 具体描述
java.math 使用时需要导包
类声明 public class BigDecimal extends Number implements Comparable
描述 BigDecimal类提供了算术,缩放操作,舍入,比较,散列和格式转换的操作。提供了更加精准的数据计算方式

9.3. 3 构造方法

构造方法名 描述
BigDecimal(double val) 将double类型的数据封装为BigDecimal对象
BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal

注意:推荐使用第二种方式,第一种存在精度问题;

9.4. 4 常用方法

BigDecimal类中使用最多的还是提供的进行四则运算的方法,如下:

方法声明 描述
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算

注意:对于divide方法来说,如果除不尽的话,就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法;

​ BigDecimal divide(BigDecimal divisor, int scale, int roundingMode): divisor:除数对应的BigDecimal对象; 参数说明:scale:精确的位数;roundingMode取舍模式

小结:Java中小数运算有可能会有精度问题,如果要解决这种精度问题,可以使用BigDecimal

public class Test01 {


    public static void main(String[] args) {

        // 1234567890987654321
        BigInteger a = new BigInteger("1234567890987654326");

        System.out.println(a);

        // +1
        System.out.println(a.add(new BigInteger("1")));
        // -1
        System.out.println(a.subtract(new BigInteger("1")));
        // *2
        System.out.println(a.multiply(new BigInteger("2")));
        // 除2
        System.out.println(a.divide(new BigInteger("2")));


        // 12.0   /3
        BigDecimal b = new BigDecimal("10");

       // System.out.println(b.divide(new BigDecimal("3")));
        // 当遇到除不尽的时候 就会报下面的异常  。
//ava.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
        // 取若干位小数   被干掉的数字 选择一个 取整的方式 (向上,向下)
        System.out.println(b.divide(new BigDecimal("3"), 2, RoundingMode.CEILING));
    }
}

10. 第九章 Arrays类

10.1. 1 Arrays类概述

​ java.util.Arrays类:该类包含用于操作数组的各种方法(如排序和搜索)

10.2. 2 Arrays类常用方法

  • public static void sort(int[] a):按照数字顺序排列指定的数组

  • public static String toString(int[] a):返回指定数组的内容的字符串表示形式

  • 示例代码:

    public static void main(String[] args) {
        int[] arr = {432, 53, 6, 323, 765, 7, 254, 37, 698, 97, 64, 7};
        //将数组排序
        Arrays.sort(arr);
        //打印数组
        System.out.println(Arrays.toString(arr));
    }
    

    打印结果:

    [6, 7, 7, 37, 53, 64, 97, 254, 323, 432, 698, 765]
    

11. 第十章 包装类

11.1. 1 概述

Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:

基本类型 对应的包装类(位于java.lang包中)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

11.2. 2 Integer类

  • Integer类概述

    包装一个对象中的原始类型 int 的值

  • Integer类构造方法及静态方法

方法名 说明
public Integer(int value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象
  • 示例代码
public class IntegerDemo {
    public static void main(String[] args) {
        //public Integer(int value):根据 int 值创建 Integer 对象(过时)
        Integer i1 = new Integer(100);
        System.out.println(i1);

        //public Integer(String s):根据 String 值创建 Integer 对象(过时)
        Integer i2 = new Integer("100");
        //Integer i2 = new Integer("abc"); //NumberFormatException
        System.out.println(i2);
        System.out.println("--------");

        //public static Integer valueOf(int i):返回表示指定的 int 值的 Integer 实例
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        //public static Integer valueOf(String s):返回保存指定String值的Integer对象 
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
    }
}

11.3. 3 装箱与拆箱

基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:

  • 装箱:从基本类型转换为对应的包装类对象。
  • 拆箱:从包装类对象转换为对应的基本类型。

用Integer与 int为例:(看懂代码即可)

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

11.4. 4 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。

11.5. 5 基本类型与字符串之间的转换

11.5.1. 基本类型转换为String

  • 转换方式
  • 方式一:直接在数字后加一个空字符串
  • 方式二:通过String类静态方法valueOf()
  • 示例代码
public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}

11.5.2. String转换成基本类型

除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:

  • public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s):将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s):将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s):将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s):将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s):将字符串参数转换为对应的boolean基本类型。

代码使用(仅以Integer类的静态方法parseXxx为例)如:

  • 转换方式
    • 方式一:先将字符串数字转成Integer,再调用valueOf()方法
    • 方式二:通过Integer静态方法parseInt()进行转换
  • 示例代码
public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1:String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java.lang.NumberFormatException异常。

12. 第十一章 String类常用方法

12.1. 1 concat

  • 方法原型:public String concat (String str)

  • 功能:将当前字符串与参数字符串进行"拼接",返回一个新字符串。

    String s1 = "Hello";
    String s2 = "World";
    String result = s1.concat(s2);
    System.out.println("result = " + result);
    System.out.println("s1 = " + s1);
    System.out.println("s2 = " + s2);
    

    concat的作用和+符号的不同:

    ​ 1). concat只能拼接String类型,不能拼接其它类型。

    ​ +符号可以拼接任何类型。

    ​ 2). concat的效率要高于+符号。

12.2. 2 contains

  • 方法原型:public boolean contains (CharSequence s)

    CharSequence是一个接口,String类是它的实现类。

  • 功能:判断参数字符串在当前字符串中是否存在(区分大小写)。存在,返回true,否则,返回false。

    String s = "我爱Java,我爱学习!";
    System.out.println("字符串中是否包含Java:" + s.contains("Java"));//true
    System.out.println("字符串中是否包含java:" + s.contains("java"))//false
    

12.3. 3 endsWith

  • 方法原型:public boolean endsWith(String suffix)

  • 功能:测试此字符串是否以指定的后缀结尾(区分大小写)。

    String name = "Test.java";
    System.out.println("判断name是否以java结尾:" + name.endsWith("java"));//true
    System.out.println("判断name是否以Java结尾:" + name.endsWith("Java"));//false
    

12.4. 4 startsWith

  • 方法原型:public boolean startsWith(String prefix)

  • 功能:测试此字符串是否以指定的前缀开始(区分大小写)

    String name = "我爱Java";
    System.out.println("字符串是否以‘我’开头:" + name.startsWith("我"));//true
    

12.5. 5 indexOf

  • 方法原型:public int indexOf(String str)

  • 功能:返回指定子字符串第一次出现的字符串内的索引。如果不包含,则返回-1.

    String str = "我爱Java,我爱学习!";
    System.out.println("在字符串中,Java第一次出现的位置:" + str.indexOf("Java"));//2
    System.out.println("在字符串中,java第一次出现的位置:" + str.indexOf("java"));//-1
    

12.6. 6 lastIndexOf

  • 方法原型:public int lastIndexOf(String str)

  • 功能:返回指定子字符串最后一次出现的字符串中的索引。 如果不包含,则返回-1.

    String str = "我爱Java,我爱学习!";
    System.out.println("在字符串中,'我'最后一次出现的位置:" + str.lastIndexOf("我"));//7
    

12.7. 7 replace

  • 方法原型:public String replace(CharSequence target,CharSequence replacement)

  • 功能:将与字面目标序列匹配的字符串的每个子字符串替换为指定的文字替换序列。 替换从字符串开始到结束,例如,在字符串“aaa”中用“b”替换“aa”将导致“ba”而不是“ab”。

    String str = "我爱吃红烧鲤鱼,我太想吃红烧鲤鱼了!";
    System.out.println("将'红烧鲤鱼'替换为'咸水鸡':" + str.replace("红烧鲤鱼","咸水鸡"));
    System.out.println("原字符串:" + str);
    

12.8. 8 substring

  • 方法原型:public String substring(int beginIndex):将当前字符串从beginIndex开始截取到末尾。

  • 方法原型:public String substring(int beginIndex, int endIndex):将当前字符串从beginIndex开始截取到endIndex - 1处。

  • 功能:截取字符串,并将截取后的字符串返回。原字符串不变。

    String str = "我爱Java";
    System.out.println("截取'Java':" + str.substring(2));//Java
    System.out.println("截取'我爱':" + str.substring(0,2))//我爱
    

12.9. 9 toCharArray

  • 方法原型:public char[] toCharArray()

  • 功能:将当前字符串转换为char[]数组。

    String str = "身无彩凤双飞翼";
    char[] chArray = str.toCharArray();
    System.out.println(chArray);
    

12.10. 10 toLowerCase

  • 方法原型: public String toLowerCase()

  • 功能:将当前字符串中的所有英文字符转换为小写,并返回一个转换后的新字符串,原字符串不变。

    String str = "我爱Java";
    System.out.println("转换为小写:" + str.toLowerCase());//我爱java
    System.out.println("原字符串:" + str);//我爱Java
    

12.11. 11 toUpperCase

  • 方法原型:public String toUpperCase()

  • 功能:将当前字符串中的所有英文字符转换为大写,并返回一个转换后的新字符串,原字符串不变。

    String str = "我爱Java";
    System.out.println("转换为大写:" + str.toUpperCase());//我爱JAVA
    System.out.println("原字符串:" + str);//我爱Java
    

12.12. 12 trim

  • 方法原型:public String trim()

  • 功能:去掉当前字符串的前后空格,并返回一个新字符串,原字符串不变。

    String str = "  ad  min     ";
    System.out.println("去掉前后空格后|" + str.trim() + "|");//去掉前后空格后|ad  min|
    System.out.println("原字符串|" + str + "|");//原字符串|  ad  min     |
    

12.13. 13 split

  • 方法原型:public String[] split(String regex)

  • 功能:切割字符串——将字符串以regex作为分隔符进行切割。

    String str = "张三,20,男,13513153355";
    String[] arr = str.split(",");
    for(int i = 0;i < arr.length ; i++){
        System.out.println(arr[i]);
    }
    

    说明:此方法的参数实际上是一个"正则表达式",功能很强大,后边学到正则表达式时会再次看到此方法。

results matching ""

    No results matching ""