第四节 Java常用API

关注

原创最新推荐文章于 2026-02-13 01:32:25 发布 609 阅读 AI 写同款· GEO 优化 ›

Flink原理与实战（java版）#第6章 Flink的 DataStream API（第四节转换算子）第四介绍了Flink的23种常用的转换算子、物理分区算子链和资源组以及名字和描述的内容，同时针对比较常用的给出了相应的示例，比如OutputTag和Process算子代替Split和Select示例。阅读详情

第四节 Java常用API

1. 字符串操作API（String和String Buffer）
2.System类与Runtime类
- 2.1 System类
- 2.2 Runtime类
3. Math类和Random类
- 3.1 Math类
- 3.2 Random类
4. 包装类
- 4.1 基本数据类型、基本数据类型包装类以及字符串之间的转换
5. 日期与时间类

1. 字符串操作API（String和String Buffer）

不同的字符串之间我们可以用“+”号去连接，形成一个新的字符串。当一个不是字符串的通过加号连接，会进行自动的转换为字符串。

1.1 String类

利用String创建字符串的三种方式：
public class Stringop {
    public static void main(String[] args) {
        String str1="第一种方法创建字符串";
        String str2=new String("第二种方法去创建字符串");
        char[] ch={'a','b','c'};
        String str3=new String(ch);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    }
}

1.1.1 String类常用方法

public class Example01 {
    public static void main(String[] args) {
        //定义一个字符串
        String str1="abcdefga";
        //1.返回指定字符或字符串在字符串中第一次出现的索引
        System.out.println(str1.indexOf("ab"));
        System.out.println(str1.indexOf('a'));
        System.out.println(str1.indexOf(97));
        //2.返回指定字符或字符串在字符串中最后一次出现的索引
        System.out.println(str1.lastIndexOf('a'));
        System.out.println(str1.lastIndexOf(97));
        System.out.println(str1.lastIndexOf("ab"));
        //3.返回指定索引处的字符
        System.out.println(str1.charAt(0));
        //4.判断字符串是否以指定字符串结尾
        System.out.println("str1是以ga结尾吗？"+str1.endsWith("ga"));
        //5.返回这个字符串的长度
        System.out.println("字符串的长度为："+str1.length());
        //6.判断字符串是否与指定字符串值相等
        System.out.println(str1.equals("aaa"));
        //7.判断某字符串是否为空
        System.out.println(str1.isEmpty());
        //8.判断字符串是否以某字符串开头
        System.out.println(str1.startsWith("a"));
        //9.判断字符串是否包含某字符串
        System.out.println(str1.contains("abcd"));
        //10.将所有字符串中所有字符转换为小写
        System.out.println(str1.toLowerCase());
        //11.将所有字符串中的所有字符都转换为大写
        System.out.println(str1.toUpperCase());
        //12.将数值类型的变量转换为字符串
        System.out.println(String.valueOf(23));
        //13.将字符串转换为字符数组
        char[] ch;
        ch=str1.toCharArray();
        System.out.println(ch.toString());
        //14.将字符串中的字符串序列进行替换
        String str2=str1.replace("ab","aa");
        //15.根据参数值进行分割
        String[] strarr;
        strarr=str1.split("bc");
        System.out.println(strarr);
        //16.从指定位置进行截取
        System.out.println(str1.substring(2));
        System.out.println(str1.substring(2,4));
        //17.去除字符串首尾的空格
        System.out.println(str1.trim());
    }
}

注意：在这里面的equals（）方法和==的区别：
equals（）比较的是两个字符串的值是否相等，而==比较的是两个字符串的内存地址。

        String str3="abcd";
//        String str4=new String("abcd");(1)
        String str4="abcd";//（2）
        System.out.println(str3==str4);//(1)false,(2)true
        System.out.println(str3.equals(str4));//(1)true (2)true

1.2 StringBuffer类

与String类的区别：
（1）在Java中String类是final类型，所以使用String定义的字符串是一个常量，一旦创建，内容和长度是不可以改变的，如果要对一个字符串进行修改，则只能创建一个新的字符串。而StringBuffer它的内容和长度是可以改变的，当我们操作这个字符串就是在操作这个字符串容器。
（2）String重写了Object类的equals（）方法，而StringBuffer没有重写，Object里的equals（）方法与Object里面的不一样需要注意，String里面的只比较值，而StringBuffer比较的是内存地址与==一样，
（3）String对象中的字符串可以用“+”号连接，而StringBuffer中的字符串不可以用“+”号连接。

常见的方法使用：

public class Example02 {
    public static void main(String[] args) {
        StringBuffer strbuf=new StringBuffer("abcdefg");
        System.out.println("返回字符串对象:"+strbuf.toString());
        //进行添加
        System.out.println(strbuf.append('h'));
        //进行在指定位置插入元素
        System.out.println(strbuf.insert(strbuf.length()-1,'i'));
        //进行删除指定位置字符
        System.out.println(strbuf.deleteCharAt(strbuf.length()-1));
        //删除指定范围的字符串
        System.out.println(strbuf.delete(strbuf.length()-1,strbuf.length()));
        //指定字符串范围进行替换
        System.out.println(strbuf.replace(0,1,"cc"));
        //修改指定位置的字符
        strbuf.setCharAt(0,'a');
        System.out.println(strbuf);
        strbuf.reverse();
        System.out.println(strbuf);
    }
}

StringBuffer 与StringBuilder的区别：
StringBuilder同样可以操作字符串，并且方法与StringBuffer类似，但是与StringBuffer不同的是StringBuffer是线程安全的，而StringBuilder不是线程安全的，但是它的性能会比较高一些。

2.System类与Runtime类

2.1 System类

这个类主要用来操作系统的一些相关属性和方法。

System常用方法：
（1）static void exit（int status）：用来终止Java虚拟机运行，status值不为0表示非正常终止。我们通过状态码可以看看我们程序是否有错误出现
（2）static void gc（）：运行垃圾回收器
（3）static native long currentTimeMillis（）：返回当前据1970年1月1号的毫秒数

（4）arraycopy（Object src，int srcPos，Object dest，int destPos，int length）的使用：用来copy数组。
int[] srcArry={1,2,3,4};
int[] destArry={5,6,7,8};
System.arraycopy(srcArry,0,destArry,0,3);
结果就变成了，{1,2,3,8}

(5)static Properties getProperties():获取当前系统属性
public class Example04 {
    public static void main(String[] args) {
        Properties properties=System.getProperties();
        System.out.println(properties);
        //获取所有系统属性的属性名，返回Set对象
        Set<String> propertyNames=properties.stringPropertyNames();
        for(String key:propertyNames){
            //System的另一个方法获得指定键的系统属性值
            String value=System.getProperty(key);
            System.out.println(key+"--->"+value);
        }
    }
}

2.2 Runtime类

用于表示Java虚拟机运行时的状态，它用于封装Java虚拟机进程。每次使用java命令启动Java虚拟机都会对应一个Runtime实例，并只有一个实例，应用程序会通过该实例与其运行时的环境相连。应用程序不能创建自己的Runtime实例，但是我们可以通过Runtime.getRuntime（）方法来获取Runtime对象

Runtime的使用示例：

public class RuntimeExam {
    public static void main(String[] args) {
        Runtime rt=Runtime.getRuntime();
        System.out.println("处理器的个数："+rt.availableProcessors()+"个");
        System.out.println("空闲内存大小："+rt.freeMemory()/1024/1024+"M");
        System.out.println("最大可用内存大小："+rt.maxMemory()/1024/1024+"M");
    }
}

其中里面有一个exec（）方法用来执行DOS命令，返回一个Process对象
使用如下：

public class RuntimeExec {
    public static void main(String[] args) throws InterruptedException, IOException {
        Runtime rt=Runtime.getRuntime();
        //打开记事本
        Process process=rt.exec("notepad.exe");
        Thread.sleep(3000);
        //关闭记事本
        process.destroy();
    }
}

3. Math类和Random类

3.1 Math类

Math所有的方法都是静态的，它的构造方法被private修饰了，所以不可以创建Math对象。

//Math里面的两个常量值：PI和E，一个代表Π，一个代表e
abs(数值)//计算绝对值
sin(数值)//计算正弦值
cos(数值)//计算余弦值
tan(数值)//计算正切值
sqrt(数值)//计算平方根
cbrt(数值)//计算立方根
pow(数值1，数值2)//求乘方
ceil(数值)//大于参数的最小整数（返回的是double类型的）
floor(数值)//小于参数的最大整数（返回的是double类型的）
round(数值)//四舍五入后的结果（返回的整数）
max(数值1,数值2..)//求最大值
min(数值1，数值2...)//求最小值
random()//随机生成一个大于等于0.0，小于1.0的随机值

3.2 Random类

用来随机生成数字
两个构造方法：
（1）Random（）：空参构造方法，每次实例化都会生成不同的随机数
（2）Random（long seed）：当seed相同时，每次实例化对象生成相同的随机数。（用来创建多个Random实例对象产生相同序列的随机数）

常用方法：
（1）boolean nextBoolean（）：随机生成boolean类型的随机数
（2）double nextDouble（）：随机生成double类型的随机数（0.0到1.0之间）
（3）Float nextFloat（）：随机生成Float类型的随机数（0.0到1.0之间）
（4）int nextInt（）：随机生成int类型的随机数
（5）int nextInt（int n）：随机生成[0,n)之间int类型的随机数
（6）long nextLong（）：随机生成long类型的随机数

4. 包装类

包装类就是基本数据类型对应的引用数据类型
除了int的包装类型是Integer，char的包装类是Character，其他的包装类都是基本数据类型的首字母大写即可，比如：byte的包装类型为Byte。
在包装类和基本数据类型进行转换时有自动装箱和自动拆箱的概念。
自动装箱：将基本数据类型赋值给包装类型
自动拆箱：将包装类对象直接赋值给一个对应的基本数据类型。

4.1 基本数据类型、基本数据类型包装类以及字符串之间的转换

（1）通过引用数据类型字符串String类的valueOf（）可以将八种基本数据类型转换为对应的字符串类型
（2）通过八种包装类的静态方法valueOf()可以将对象将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character除外）例如：我们可以通过以下的形式int a=Integer.valueOf(“123”);将字符串转换为它对应的整数类型
（3）通过八种包装类的有参构造方法可以将基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character包装类除外）例如：int a=new Integer（“123”）;
（4）通过8种包装类的静态方法parseXxx（）可以将变量内容匹配的字符串转换为对应的基本数据类型。
例如：
double a=Double.parseDouble(“123.4”);
（5）包装类都重写了toString（）方法以字符串的形式返回被包装的基本数据类型值。例如：String a=new Integer(12).toString()

5. 日期与时间类

5.1 Date类

在JDK8之后使用的就比较少了（设计的时候没有考虑到国际化的问题，现在被Calendar类取代），主要使用的两个构造方法为：
（1）Date（）：用来创建当前日期时间的Date对象
（2）Date（long date）：用来创建指定时间的Date对象，参数date表示的是从1970年1月1日以来的毫秒数（时间戳）

5.2 Calendar类

它是一个抽象类，不能实例化，通过其静态方法getInstance（）来得到Calendar对象。

常用方法：
（1）int get（int field）：返回指定日历字段的值
（2）void add（int field，int amount）：为指定日历字段增加或减去时间量
（3）void set（int field，int value）：为指定字段设定值
（4）void set（int year，int month，int date）：设置年月日
（5）void set（int year，int month，int date，int hourOfDay，int minute，int second）：设置年月日，时分秒。
（6）getTime（）：获得一个Date对象
（7）setTime（）：设置一个返回类型为Calendar对象类型的，参数要为Date类型
其中：field字段是用Calendar里面的YEAR、MONTH、DATE、HOUR、MINUTE、SECOND常量表示。month是从0到11这点要注意。
Date对象和Calendar对象通过上面的getTime（）和setTime（）方法可以进行相互之间的转换。
容错模式（lenient）和非容错模式（non-lenient）
当处于容错模式时，数值可以超出允许范围的值，当我们使用get（）方法去获取某个值的时候，Calendar会自动的重新去计算所有字段的值，将字段的值去标准化，默认的是容错模式，如果设置为非容错模式了，当我们的数值超过允许的范围之后会抛异常。我们通过Calendar里面的setLenient(false)来设置为非容错模式。
JDK 8 的日期与时间类
为了满足更多的需求，JDK 8增加了一个java.time包，在这个包里有了更多的操作日期和时间的类。
这些类的使用方法如下：

public class JDK8Calendar {
    public static void main(String[] args) {
        //1.使用Clock获取指定时区的当前时间
        Clock clock=Clock.systemUTC();
        System.out.println("获取UTC时区转换的当前时间："+clock.instant());
        System.out.println("获取UTC时区转换的毫秒数："+clock.millis());
        //2.使用Duration，主要用里面的ofXxx（）方法获取指定的时间的小时、分钟、秒数等
        Duration duration=Duration.ofDays(1);
        System.out.println("一天等于："+duration.toHours()+"小时");
        System.out.println("一天等于："+duration.toMinutes()+"分钟");
        System.out.println("一天等于："+duration.toMillis()+"秒");
        //3.使用Instant，通过静态方法now（）获取当前时间，通过plusXxx（）方法来增加，minusXxx（）方法来减少
        Instant instant=Instant.now();
        System.out.println("获取UTC时区的当前时间为："+instant);
        System.out.println("当前时间一小时后的时间为："+instant.plusSeconds(3600));
        System.out.println("当前时间一个小时前的时间："+instant.minusSeconds(3600));
        //4.使用LocalDate，通过静态方法now（）获取不带时间的日期，通过plusXxx（）和minusXxx（）方法加减
        LocalDate localDate=LocalDate.now();
        System.out.println("现在日期是："+localDate);
        //5.使用LocalTime,通过静态方法now（）获取不带日期的时间
        LocalTime localTime=LocalTime.now();
        System.out.println(localTime);
        //6.使用LocalDateTime，通过静态方法now（）获取日期时间，通过plusXxx（）和minusXxx（）方法来加减
        LocalDateTime localDateTime=LocalDateTime.now();
        System.out.println(localDateTime);
        LocalDateTime times=localDateTime.plusDays(1).plusHours(3).plusMinutes(30);
        System.out.println(times);
        //7.使用Year、YearMonth、MonthDay
        Year year=Year.now();
        System.out.println("当前年份"+year);
        YearMonth yearMonth=YearMonth.now();
        System.out.println("当前年月"+yearMonth);
        MonthDay monthDay=MonthDay.now();
        System.out.println("当前的月日"+monthDay);
        //8.使用ZoneId，表示一个时区
        ZoneId zoneId=ZoneId.systemDefault();
        System.out.println("当前系统的默认时区为："+zoneId);
    }
}

注意：如果我们这里通过clock.instant()来获取时间会和通过Instant.now()来获取的时间相差8个小时，因为Instant默认使用的UTC（世界标准时间），而通过clock.instant()来获取的时间是CST（中国标准时间）。
其中还有DayOfWeek类用来定义星期一到星期日，是个枚举类，Month也是枚举类用来定义一月到12月。

5.3 格式化类

目的：获得我们想要的格式输出的时间和日期。

5.3.1 DateFormat类

它是一个抽象类，不能被实例化，但是它提供了一系列的方法来获取实例对象。它用来格式化日期。

常用方法：

方法声明	功能描述
static DateFormat getDateInstance（）	创建默认语言风格的日期格式器
static DateFormat getDateInstance（int style）	创建指定风格的日期格式器
static DateFormat getDateTimeInstance	创建默认风格的日期/时间格式器
static DateFormat getDateTimeInstance（int dateStyle，int timeStyle）	用于创建指定风格的日期/时间
String format（Date date）	将一个Date格式化为日期/时间字符串
Date parse（String source）	将给定字符串解析成一个日期

注意：前四个方法用来获取实例化对象，其中DateFormat里面有四个常量值用于作为参数传递给方法。FULL、LONG、MEDIUM、SHORT，FULL表示完整格式，LONG表示长格式、MEDIUM表示普通格式，SHORT表示短格式。
我们可以利用parse（）方法将字符串格式化成我们想要格式的Date对象。

5.3.2 SimpleDateFormat类

解决了DateFormat对象的parse（）方法将字符串解析为日期的时候，需要输入固定格式的字符串不够灵活，他是DateFormat的子类，可以用new去创建，创建实例化对象时，构造方法接受一个表示日期格式模板的字符参数。
使用如下：

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        SimpleDateFormat sdf=new SimpleDateFormat("Gyyyy年MM月dd日：今天是yyyy年的第D天，E");
        System.out.println(sdf.format(new Date()));
        //其中的G表示公元，y表示年，d表示日，M表示月，D表示天，E表示星期。
    }
}

解析比DateFormat灵活体现在下面：

        SimpleDateFormat sdf2=new SimpleDateFormat("yy/MM/dd");
        Date date=sdf2.parse("21/03/02");
        System.out.println(date);

5.3.3 DateTimeFormatter类

用来将日期、时间对象格式化成字符串和将特定格式的字符串解析成日期、时间对象。相当于DateFormat和SimpleDateFormat合体。

获得DateTimeFormatter对象的三种方式：
（1）使用静态常量创建：在DateTimeFormatter类中包含大量的静态常量，如ASIC_ISO_DATE、ISO_LOCAL_DATE、ISO_LOCAL_TIME等
（2）使用不同风格的枚举值来创建：在FormatStyle类中定义了FULL、LONG、MEDIUM和SHORT四个枚举值。
（3）根据模式字符串创建
使用如下：

public class DateTimeFormatterDemo {
    public static void main(String[] args) {
        LocalDateTime date=LocalDateTime.now();
        //1.使用常量创建
        DateTimeFormatter dtf=DateTimeFormatter.ISO_DATE_TIME;
        System.out.println(dtf.format(date));
        //2.使用不同风格的枚举值来创建
        DateTimeFormatter dtf2=DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
        System.out.println(dtf2.format(date));
        //3.使用模式字符串来创建
        DateTimeFormatter dtf3=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(date.format(dtf3));
    }
}

格式化字符串可以通过以下两种方式：
（1）调用DateTimeFormatter的format（TemporalAccessor temporal），参数是TemporalAccessor类型的接口，主要实现类有LocalDate、LocalDateTime。
（2）调用LocalDate、LocalDateTime等日期对象的format（DateTimeFormatter formatter）方法。

使用DateTimeFormatter将指定格式的字符串解析成日期、时间对象，可以通过日期、时间对象所提供的parse（CharSequence text，DateTimeFormatter formatter）方法来实现。

使用方式如下：

public class DateTimeFormatterParseDemo {
    public static void main(String[] args) {
        //定义两种日期格式的字符串
        String str1="2020-01-12 14:23:33";
        String str2="2020年01月12日 14时23分33秒";
        //定义解析所用容器
        DateTimeFormatter formatter1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        DateTimeFormatter formatter2=DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
        //使用LocalDateTime的parse（）方法执行解析
        LocalDateTime ldt1=LocalDateTime.parse(str1,formatter1);
        LocalDateTime ldt2=LocalDateTime.parse(str2,formatter2);
        //输出结果
        System.out.println(ldt1);
        System.out.println(ldt2);
    }
}