Java常用API

时间：2023-03-08 11:01:08


文章目录

  • ​​Scanner类​​
  • ​​Random类​​
  • ​​ArrayList类​​
  • ​​基本类型拆箱装箱​​
  • ​​public boolean add(E e)​​
  • ​​public E get(int index)​​
  • ​​public E remove(int index)​​
  • ​​public int size()​​
  • ​​String类​​
  • ​​创建String对象​​
  • ​​常量池​​
  • ​​String内置方法​​
  • ​​Arrays类​​
  • ​​Math类​​
  • ​​public static double ads(double num)​​
  • ​​public static double ceil(double num)​​
  • ​​public static double floor(double num)​​
  • ​​public static long round(double num)​​
  • ​​Object类​​
  • ​​toString方法​​
  • ​​equals方法​​
  • ​​时间日期类​​
  • ​​Date​​
  • ​​无参构造​​
  • ​​带参构造​​
  • ​​getTime方法​​
  • ​​DateFormat​​
  • ​​SimpleDateFormat​​
  • ​​构造方法​​
  • ​​format方法​​
  • ​​parse方法​​
  • ​​日历类（Calendar）​​
  • ​​static Calendar getInstance()​​
  • ​​int get(int field)​​
  • ​​void set(int field, int value)​​
  • ​​abstract void add(int field, int amount)​​
  • ​​Date getTime()​​
  • ​​System类​​
  • ​​public static long currentTimeMillis()​​
  • ​​public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)​​
  • ​​StringBuilder类​​
  • ​​无参构造和有参构造​​
  • ​​public StringBuilder append(...)​​
  • ​​public String toString()​​
  • ​​Integer包装类​​
  • ​​装箱拆箱的函数调用​​
  • ​​自动装箱拆箱​​
  • ​​基本类型与字符串类型转换​​

Scanner类

java.lang包下的内容不需要导包 其他的包都需要import语句

  • 获取键盘输入的一个int数字：int num=sc.nextInt()
  • 获取键盘输入的一个字符串：String str=sc.next()
public static void main(String[] args) {
            //创建
            //System.in代表从键盘进行输入
            Scanner sc=new Scanner(System.in);

            //获取键盘输入的int数字
            int num=sc.nextInt();
            System.out.println("输入的数字是:"+num);

            //获取键盘输入的字符串
            String str =sc.next();
            System.out.println("输入的字符串是："+str);
    }

Random类

Random类用来生成随机数字

  • 获取一个随机的int数字(范围是int所有的范围 由正负两种);int num=r,nextInt()
  • 获取一个随机的int数字(参数代表了范围 左闭右开区间)：int num=r.nexInt(3)
  • 实际上代表的含义是[0,3) 也就是0到2
public static void main(String[] args) {
        Random r=new Random();
        int randomNum=r.nextInt(100)+1;

        Scanner sc=new Scanner(System.in);
        while(true){
            int guessNum=sc.nextInt();
            if(guessNum>randomNum)
                System.out.println("猜大了");
            else if(guessNum<randomNum)
                System.out.println("猜小了");
            else {
                System.out.println("恭喜你 猜中了");
                break;
            }
        }
        System.out.println("游戏结束");
    }

ArrayList类

数组长度不可以改变

  • 但是ArrayList可以随意变化
  • 对于ArrayList来说 有一个尖括号代表泛型
  • 泛型： 也就是装在集合当中的所有元素，全都是统一的什么类型
  • 注意：泛型只能是引用类型，不能是基本类型
  • 注意事项：
  • 对于ArrayList集合来说 直接打印得到的不是地址值 而是内容
  • 如果内容为空 得到的是空的中括号
public static void main(String[] args) {
        //创建了一个ArrayList集合 集合的名称是List 里边装的全都是String字符串类型的数据
        //备注：从jdk1.7开始 右侧的尖括号内部可以不写内容 但是<>本身还是要写的
        ArrayList<String> list=new ArrayList<>();
        System.out.println(list);

        //向集合当中添加一些数据 需要add方法
        list.add("张三");
        System.out.println(list);

        list.add("李四");
        list.add("王五");
        list.add("赵六");
        System.out.println(list);


//        list.add(100);//错误写法 因为创建的时候尖括号担心已经说了是字符 添加进去的元素必须都是字符串才可以
    }

基本类型拆箱装箱

import java.util.ArrayList;
/*
* 如果希望向集合ArrayList当中存储基本类型 必须使用基本类型对应的包装类
*
* 基本类型              包装类（引用类型都位于java.lang包下）
* byte                  Byte
* short                 Short
* int                   Integer【特殊】
* long                  Long
* float                 Float
* double                Double
* char                  Character【特殊】
* boolean               Boolean
*
* 从JDK1.5开始，支持自动装箱 自动拆箱
*
* 自动装箱：基本类型-->包装类型
* 自动拆箱：包装类型-->基本类型*/
public class Demo05ArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String> listA=new ArrayList<>();
       //错误写法 泛型之能事引用类型 不能基本类型
//        ArrayList<int> listB=new ArrayList<>();

        ArrayList<Integer> listC=new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC);


        int num=listC.get(1);
        System.out.println("第一号元素是"+num);
    }
}

public boolean add(E e)

向集合当中添加元素 参数的类型和泛型一致

  • 备注：对于ArrayList集合来说，add添加动作是一定成功的 所以返回值可用可不用
    但是对于其他集合（今后学习）来说add添加动作不一定成功

public E get(int index)

从集合当中获取元素 参数是索引编号 返回值就是对应的位置元素

public E remove(int index)

从集合中删除元素 参数是索引编号 返回值就是被删除的元素

public int size()

获取集合的尺寸长度 返回值是集合中包含的元素个数

public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        System.out.println(list);

        //向集合中添加元素：add
        boolean success=list.add("张三");
        System.out.println(list);
        System.out.println("添加的动作是否成功:"+success);

        list.add("李四");
        list.add("王五");
        list.add("赵六");
        System.out.println(list);

        //从集合中获取元素：get，索引值从零开始
        String name=list.get(2);
        System.out.println("第二号索引位置："+name);

        //从集合中删除元素：remove,索引值从零开始
        String whoRemove=list.remove(3);
        System.out.println("被删除的人是谁"+whoRemove);
        System.out.println(list);

        //获取集合的长度尺寸 也就是元素的个数
        int size=list.size();
        System.out.println("集合的长度："+size);
    }

String类

java.lang.String

  • API当中说 java程序中的所有字符串（如“abc”）都作为此类实例实现
  • 其实就是说 程序当中所有的双引号字符串 都是String类的对象（就算没有new 也照样是）
  • 字符串的特点：
  • 1，字符串的内容永不可变
  • 2，正是因为字符不可改变 所以字符串是可以共享使用的
  • 3，字符串效果上相当于char[]*字符数组 但是底层原理是byte[]字节数组。
  • 创建字符串的3+1中方式
  • 三种构造方法
  • public String():创建一个空白字符串 不含与任何内容
  • public String(char[] array):根据字符数组的内容 来创建相应的字符串
  • public String(byte[] array):根据字节数内容 来创建相应的字符串
  • 一种直接创建
  • String str=“hello”
  • 注意 直接写上双引号 就是字符串对象

创建String对象

public static void main(String[] args) {
        //使用空参构造
        String str1=new String();//小括号留空 说明字符串什么内容都没有
        System.out.println("第一个字符串："+str1);

        //根据字符数组创建字符串
        char[] charArray={'a','b','c'};
        String str2=new String(charArray);
        System.out.println("第二个字符串"+str2);

        //第三个构造方法创建字符串
        byte[] byteArra={97,98,99};
        String str3=new String(byteArra);
        System.out.println("第三个字符串"+str3);

        //直接创建
        String str4="hello";
        System.out.println("第四个字符串："+str4);
    }

常量池

/*
* 字符串常量池：程序中直接协商双引号字符串 就在字符串常量池中
*
* 对于基本类型来说 ==是进行数值的比较
* 对于引用类型来说 ==是进行【地址值】的比较
* */
public class Demo02StringPool {
    public static void main(String[] args) {
        String str1="abc";
        String str2="abc";

        char[] charArray={'a','b','c'};
        String str3=new String(charArray);

        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str2==str3);
    }
}

Java常用API

String内置方法

​​参考另一篇博客​​

Arrays类

java.util.Arrays是一个与数组相关的工具类 里面提供了大量的静态方法 用来实现数组的常见的操作

  • public class String toString(数组) 将数组变成字符串（按照默认格式：[元素1，元素二，元素三…]）
  • public static void sort(数组)：按照升序(从小到大)对数组的元素进行排序
  • 备注：
    若果是数组 sort默认按照升序从小到大
    如果是自定义类型 那么这个自定义的类型需要有(Comparatar接口的支持）
public static void main(String[] args) {
        int[] intArray = {10, 20, 30};

        //将数组按照默认格式转变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);//[10, 20, 30]

        int[] array1={2,1,3,10,6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

        String[] array2={"bbb","aaa","ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }

Math类

java.util.Math类是数学相关的工具类 里面提供了大量的静态方法 完成与数学运算相关的操作

public static double ads(double num)

获取绝对值

public static double ceil(double num)

向上取整

public static double floor(double num)

向下取整

public static long round(double num)

四舍五入

public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(0));
        System.out.println(Math.abs(-2.5));
        System.out.println("==================");

        //向上取整
        System.out.println(Math.ceil(3.9));
        System.out.println(Math.ceil(3.1));
        System.out.println(Math.ceil(3.0));
        System.out.println("==================");

        //向下取整
        System.out.println(Math.floor(30.1));
        System.out.println(Math.floor(30.9));
        System.out.println(Math.floor(30.0));
        System.out.println("==================");

        //四舍五入
        System.out.println(Math.round(20.4));
        System.out.println(Math.round(20.5));

    }

Object类

Java.lang.Object

  • 类Object是所有类的超（父）类
  • 所有对象（包括数组）都实现这个类的方法

toString方法

public class Demo01ToString {
    public static void main(String[] args) {
        /*
        * Person类默认继承了Object类 所以可以使用toString方法
        * */
        Person p=new Person("张三",20);
        String s=p.toString();
        System.out.println(s);

        //直接打印对象的名字 其实就是调用对象的toString
        System.out.println(p);
        //看一个类是否重写了toString
        //直接打印这个类的对象即可
        // 如果没有重写toString打印的是地址值
        Random r=new Random();
        System.out.println(r);

        Scanner sc=new Scanner(System.in);
        System.out.println(sc);

        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.toString();
        System.out.println(list);

    }
}

equals方法

  • equals方法源码
    public boolean equals(Object obj) {
    return (this == obj);
    }
    参数：
    Object可以传递任意对象
  • 基本数据类型：比较的是值
  • 引用数据类型：比较的是两个对象的地址值
public class Demo02Equals {
    public static void main(String[] args) {
    //可在Person类中覆盖重写 equals方法
        Person p1=new Person("张三",20);
        Person p2=new Person("李四",19);
        System.out.println(p1);
        System.out.println(p2);
        boolean b=p1.equals(p2);
        System.out.println(b);


        p1=p2;
        b=p1.equals(p2);
        System.out.println(b);

        ArrayList<String> list=new ArrayList<>();
        b=p1.equals(list);
        System.out.println(b);
    }
}

时间日期类

Date

java.util.Date:表示日期和时间类
注意：中国属于东八区 会把时间增加八个小时

无参构造

public static void demo01(){
        Date date=new Date();
        //输出当前时间
        System.out.println(date);//Wed May 06 17:59:32 GMT+08:00 2020
    }
}

带参构造

public static void demo02(){
        //带参构造 Date（long Data）:传递毫秒值 将毫秒值转换为Data日期
        Date date=new Date(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 GMT+08:00 1970
    }

getTime方法

/*
    * Long getTime() 把日期转换为毫秒值 （相当于 System.currentTimeMillis()方法）
    * 返回1970年1月1日 00:00:00 GMT以来此 Date对象表示的毫秒值*/
    public static void demo03(){
        Date date=new Date();
        Long time=date.getTime();
        System.out.println(time);//1588759254787
        System.out.println(System.currentTimeMillis());//1588759254788
    }

DateFormat

DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间。 日期/时间格式化子类（如SimpleDateFormat ）允许格式化（即日期文本），解析（文本日期）和归一化。

SimpleDateFormat

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。 它允许格式化（日期文本），解析（文本日期）和归一化。

Java常用API

构造方法

SimpleDateFormat(String pattern)
使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。
pattern:
y 年
M 月
d 日
H 时
m 分
s 秒
“yyyy-MM-dd HH:mm:ss”
注意：模式中的字母不能更改 连接模式的符号可以改变

format方法
/*format() 把日期格式化为文本*/
    public static void demo01(){
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date=new Date();
        String d=sdf.format(date);
        System.out.println(date);//Wed May 06 21:05:23 GMT+08:00 2020
        System.out.println(d);//2020年05月06日 21时05分23秒
    }
parse方法
/*parse()解析文本为data日期*/
    public static void demo02() throws ParseException {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2088年08月08日 15时51分54秒");
        System.out.println(date);//Sun Aug 08 15:51:54 GMT+08:00 2088
    }

日历类（Calendar）

java.util.Calendar类：日历类

  • Calendar类是一个抽象类 里边提供了很多操作日历字段的方法
  • Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance()

static Calendar getInstance()

使用默认时区和区域设置获取日历。

public class Demo01Calendar {
    public static void main(String[] args) {
        Calendar c=Calendar.getInstance();
        System.out.println(c);             /*java.util.GregorianCalendar[time=1589001964377,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="GMT+08:00",offset=28800000,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=4,WEEK_OF_YEAR=19,WEEK_OF_MONTH=2,DAY_OF_MONTH=9,DAY_OF_YEAR=130,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=1,HOUR_OF_DAY=13,MINUTE=26,SECOND=4,MILLISECOND=377,ZONE_OFFSET=28800000,DST_OFFSET=0]*/
    }
}

int get(int field)

返回给定日历字段的值。

private static void demo01(){
        Calendar c=Calendar.getInstance();
        int year=c.get(Calendar.YEAR);
        System.out.println(year);

        int month=c.get(Calendar.MONTH);//西方月份0-11 东方1-12；
        System.out.println(month+1);

        int date=c.get(Calendar.DATE);
        //int date=c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date);
    }

void set(int field, int value)

int get(int field) 返回给定日历字段的值。
参数： 传递自定的日历字段（YEAR,MONTH…）
返回值： 日历字段代表具体的值

private static void demo02(){
        Calendar c=Calendar.getInstance();

        //设置年为9999
        c.set(Calendar.YEAR,9999);
        //设置月为9
        c.set(Calendar.MONTH,9);
        //设置天为9
        c.set(Calendar.DATE,9);
        //同时设置年月日 可以使用set的重载方法
        c.set(8888,9,9);


        int year=c.get(Calendar.YEAR);
        System.out.println(year);

        int month=c.get(Calendar.MONTH);//西方月份0-11 东方1-12；
        System.out.println(month+1);

        int date=c.get(Calendar.DATE);
        //int date=c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date);
    }

abstract void add(int field, int amount)

abstract void add(int field, int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段。
参数：
field:传递自定的日历字段（YEAR,MONTH…）
amount:增加/减少指定的值
* 正数：增加
* 负数：减少

private static void demo03(){
        Calendar c=Calendar.getInstance();

        //把年增加两年
        c.add(Calendar.YEAR,2);
        //把月增加减少三个月
        c.add(Calendar.MONTH,-3);


        int year=c.get(Calendar.YEAR);
        System.out.println(year);

        int month=c.get(Calendar.MONTH);//西方月份0-11 东方1-12；
        System.out.println(month+1);

        int date=c.get(Calendar.DATE);
        //int date=c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date);
    }

Date getTime()

Date getTime() 返回一个 Date表示此物体 Calendar的时间值（毫秒从偏移 Epoch “）。
把日历对象转化为日期对象

private static void demo04(){
        Calendar c=Calendar.getInstance();

        Date date=c.getTime();
        System.out.println(date);
    }

System类

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

public static long currentTimeMillis()

返回以毫秒为单位的当前时间。
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
用来程序的效率
验证for循环打印数字1-9999所需要使用的时间（毫秒）

private static void demo01() {
        //程序执行前,获取一次毫秒值
        long s = System.currentTimeMillis();
        //执行for循环
        for (int i = 1; i <=9999 ; i++) {
            System.out.println(i);
        }
        //程序执行后,获取一次毫秒值
        long e = System.currentTimeMillis();
        System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:106毫秒
    }

public 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]

private static void demo02() {
        //定义源数组
        int[] src = {1,2,3,4,5};
        //定义目标数组
        int[] dest = {6,7,8,9,10};
        System.out.println("复制前:"+ Arrays.toString(dest));
        //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后:"+ Arrays.toString(dest));
    }

StringBuilder类

java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率

Java常用API

无参构造和有参构造

  • StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
  • StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
public static void main(String[] args) {
        //空参数构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);//bu1:""

        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);//bu2:abc
    }

public StringBuilder append(…)

添加任意类型数据的字符串形式，并返回当前对象自身。

public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu = new StringBuilder();
        //使用append方法往StringBuilder中添加数据
        //append方法返回的是this,调用方法的对象bu,this==bu
        //StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
        //System.out.println(bu);//"abc"
        //System.out.println(bu2);//"abc"
        //System.out.println(bu==bu2);//比较的是地址 true

        //使用append方法无需接收返回值
//        bu.append("abc");
//        bu.append(1);
//        bu.append(true);
//        bu.append(8.8);
//        bu.append('中');
//        System.out.println(bu);//abc1true8.8中

        /*
            链式编程:方法返回值是一个对象,可以继续调用方法
         */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu);//abc1true8.8中
}

public String toString()

将当前StringBuilder对象转换为String对象。

public static void main(String[] args) {
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);
    }

Integer包装类

装箱拆箱的函数调用

  • 装箱: 把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
  • 构造方法:
  • Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
  • Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
    传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常
  • 静态方法:
  • static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
  • static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
  • 拆箱: 在包装类中取出基本类型的数据(包装类->基本类型的数据)
  • 成员方法:
  • int intValue() 以 int 类型返回该 Integer 的值。
public static void main(String[] args) {
        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //构造方法
        Integer in1 = new Integer(1);//方法！上有横线,说明方法过时了
        System.out.println(in1);//1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in1.intValue();
        System.out.println(i);
    }

自动装箱拆箱

自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
JDK1.5之后出现的新特性

public static void main(String[] args) {
        /*  自动装箱:直接把int类型的整数赋值包装类
            Integer in = 1; 就相当于 Integer in = new Integer(1); */
        Integer in = 1;

        /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
        in = in+2;

        ArrayList<Integer> list = new ArrayList<>();
        /*ArrayList集合无法直接存储整数,可以存储Integer包装类*/
        list.add(1); //-->自动装箱 list.add(new Integer(1));
        int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
    }

基本类型与字符串类型转换

  • 基本类型与字符串类型之间的相互转换
  • 基本类型->字符串(String)
  • 1.基本类型的值+"" 最简单的方法(工作中常用)
  • 2.包装类的静态方法toString(参数),不是Object类的toString() 重载
    static String toString(int i) 返回一个表示指定整数的 String 对象。
  • 3.String类的静态方法valueOf(参数)
    static String valueOf(int i) 返回 int 参数的字符串表示形式。
  • 字符串(String)->基本类型
  • 使用包装类的静态方法parseXXX(“字符串”);
  • Integer类: static int parseInt(String s)
  • Double类: static double parseDouble(String s)
public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

//        int a = Integer.parseInt("a");//NumberFormatException
//        System.out.println(a);

        double b=Double.parseDouble("3.1415");
        System.out.println(b);
    }


标签：

相关文章