Java常用类

String 类

String 类初始化

  1. 使用字符串常量直接初始化一个 String 对象

    String 变量名 = "字符串";

  2. 使用 String 的构造方法初始化字符串对象

    String 变量名 = new String("字符串");

String 类常用构造方法

  • String() 创建一个内容为空的字符串
  • String(String value) 根据指定的字符串内容创建对象
  • String(char[] value) 根据指定的字符数组创建对象

String 类常见操作

字符串基本操作

  • str.length()：返回字符串长度

  • str.charAt(int index)：返回字符串中 index 位置上的字符

  • str.indexOf(int ch)：返回指定字符在字符串中第一次出现处的索引

    str.lastIndexOf(int ch)：返回指定字符在字符串中最后一次出现处的索引

  • str.indexOf(String str)：返回指定子字符串在字符串中第一次出现处的索引

    str.lastIndexOf(String str)：返回指定子字符串在字符串中最后一次出现处的索引

String str = "abcabcbacdba";

//str.length()：返回字符串长度
System.out.println("字符串长度为："+str.length());

//str.charAt(int index)：返回字符串中 index 位置上的字符
System.out.println("字符串中第一个字符为："+str.charAt(0));

//str.indexOf(int ch)：返回指定字符在字符串中第一次出现处的索引
System.out.println("字符c第一次出现位置为："+str.indexOf('c'));
//str.lastIndexOf(int ch)：返回指定字符在字符串中最后一次出现处的索引
System.out.println("字符c最后一次出现位置为："+str.lastIndexOf('c'));

//str.indexOf(String str)：返回指定子字符串在字符串中第一次出现处的索引
System.out.println("子字符串'ab'第一次出现位置为："+str.indexOf("ab"));
//str.lastIndexOf(String str)：返回指定子字符串在字符串中最后一次出现处的索引
System.out.println("子字符串'ab'最后一次出现位置为："+str.lastIndexOf("ab"));

字符串转换操作

  • str.toCharArray()：将字符串转换为一个字符数组

  • String.valueOf(int i)：返回int参数的字符串表示形式

  • str.toUpperCase()：将String中的所有字符转换为大写

    str.toLowerCase()：将String中的所有字符转换为小写

String str = "java";
String str1 = "JAVA";

//str.toCharArray()：将字符串转换为一个字符数组
char[] charArray = str.toCharArray();
for (char c : charArray) {
    System.out.print(c+" ");
}
System.out.println();

//String.valueOf(int i)：返回int参数的字符串表示形式
System.out.println("将int值转换为String类型后的结果为："+String.valueOf(10));

//str.toUpperCase()：将String中的所有字符转换为大写
System.out.println("将"+str+"转换为大写字母后的结果为："+str.toUpperCase());
//str.toLowerCase()：将String中的所有字符转换为小写
System.out.println("将"+str1+"转换为小写字母后的结果为："+str1.toLowerCase());

字符串替换和去除空格操作

  • str.trim()：返回一个新字符串，去除了原字符串首尾的空格（不能去除中间空格）
  • str.replace(oldstr,newstr)：通过用newstr替换字符串中出现的所有oldstr
String str = "   http :// localhost : 8080   ";
System.out.println(str);
//str.trim()：返回一个新字符串，去除了原字符串首尾的空格（不能去除中间空格）
System.out.println("去除字符串两端空格："+str.trim());
//str.replace(oldstr,newstr)：通过用oldstr替换字符串中出现的所有oldstr
System.out.println("使用替换去除字符串中所有空格："+ str.replace(" ",""));

字符串判断操作

  • str.startsWith(String prefix)：判断字符串是否以指定字符串开始

    str.endsWith(String suffix)：判断字符串是否以指定字符串结尾

  • str.contains(String str)：判断字符串中是否包含指定字符序列

  • str.isEmpty()：当且仅当字符串长度为0时返回true

  • str1.equals(str2)：将字符串与指定的字符串比较

    • == 和 equals() 比较：equals() 方法用于比较两个字符串中的字符值是否相等；==方法用于比较两个字符串对象的内存地址是否相同
String str1 = "starter";
String str2 = "st";
//str.startsWith(String prefix)：判断字符串是否以指定字符串开始
System.out.println("判断是否以字符串st开头："+str1.startsWith("st"));
//str.endsWith(String suffix)：判断字符串是否以指定字符串结尾
System.out.println("判断是否以字符串er结尾："+str1.endsWith("er"));
//str.contains(String str)：判断字符串中是否包含指定字符序列
System.out.println("判断是否包含字符串ar："+str1.contains("ar"));
//str.isEmpty()：当且仅当字符串长度为0时返回true
System.out.println("判断字符串是否为空："+str1.isEmpty());
//str1.equals(str2)：将字符串与指定的字符串比较
System.out.println("判断两个字符串是否相等："+str1.equals(str2));

字符串截取和分割

  • str.substring(int begin)：返回从指定的begin起始角标处开始，直到字符串末尾的所有字符

    str.substring(int begin,int end)：返回从指定的 begin 起始角标处开始，直到索引 end-1 角标处所有字符

  • str.split(String regex)：根据参数 regex 将字符串分割为若干子字符串，并存放到一个 String 类型的数组中

String str = "2021-03-14";
//str.substring(int begin)：返回从指定的begin起始角标处开始，直到字符串末尾的所有字符

System.out.println("从第6个字符截取到结束："+str.substring(5));
//str.substring(int begin,int end)：返回从指定的 begin 起始角标处开始，直到索引 end-1 角标处所有字符
System.out.println("从第6个字符截取到第8个字符："+str.substring(5,8));
//str.split(String regex)：根据参数 regex 将字符串分割为若干子字符串
System.out.println("分割后为：");
String[] strArray = str.split("-");
for (String s : strArray) {
    System.out.print(s+" ");
}

StringBuffer 类

StringBuffer 常用方法

  • sb.append(char c)：添加字符到 StringBuffer 对象中末尾
  • sb.insert(int offset,String str)：在 StringBuffer 对象中的 offset 位置插入字符串 str
  • sb.deleteCharAt(int index)：移除 StringBuffer 对象中指定位置的字符
  • sb.delete(int start,int end)：删除 StringBuffer 对象中指定范围的字符或字符串
  • sb.replace(int start,int end,String s)：将 StringBuffer 对象中指定范围的字符或字符串用新的字符串 s 替换
  • sb.setCharAt(int index,char ch)：修改指定位置 index 处的字符
  • sb.reverse()：将 StringBuffer 对象用其反转形式取代
  • sb.toString()：返回 StringBuffer 缓冲区中的字符串对象
public static void main(String[] args) {
    System.out.println("1.添加-------------------");
    add();
    System.out.println("2.修改-------------------");
    update();
    System.out.println("3.删除-------------------");
    delete();
    }

private static void delete() {
    StringBuffer sb = new StringBuffer("abcdef");
    System.out.println(sb.toString());
    
    //sb.delete(int start,int end)：删除 StringBuffer 对象中指定范围的字符或字符串
    sb.delete(0,2);
    System.out.println("删除指定位置结果："+sb);
    
    //sb.deleteCharAt(int index)：移除 StringBuffer 对象中指定位置的字符
    sb.deleteCharAt(0);
    System.out.println("删除指定位置结果："+sb);
    
    sb.delete(0,sb.length());
    System.out.println("清空缓冲区："+sb);
}

private static void update() {
    StringBuffer sb = new StringBuffer("ABCDEF");
    
    //sb.setCharAt(int index,char ch)：修改指定位置 index 处的字符
    sb.setCharAt(2,'c');
    System.out.println("修改指定位置结果："+sb);
    
    //sb.replace(int start,int end,String s)：将 StringBuffer 对象中指定范围的字符或字符串用新的字符串 s 替换
    sb.replace(3,5,"de");
    System.out.println("替换指定位置字符串结果："+sb);
    
    //sb.reverse()：将 StringBuffer 对象用其反转形式取代
    System.out.println("字符串反转："+sb.reverse());
}

public static void add(){
    StringBuffer sb = new StringBuffer();
    
    //sb.append(char c)：添加字符到 StringBuffer 对象中末尾
    sb.append("abc");
    System.out.println("添加结果："+sb);
    
    // sb.insert(int offset,String str)：在 StringBuffer 对象中的 offset 位置插入字符串 str 
    sb.insert(3,"def");
    System.out.println("插入结果："+sb);
}

StringBuilder 类

StringBuffer 是线程安全，StringBuilder 没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑 StringBuilder 类

System 类

System 类定义了一些与系统相关的属性和方法，它所提供的方法和属性都是静态的

  1. getProperties() 方法：用于获取当前系统的全部属性，该方法会返回一个 getProperties 对象，其中封装了系统的所以属性，其中属性是以键值对的形式存在

    getProperty(String key)：获取指定键描述的系统属性

    //getProperties() 方法
Properties properties = System.getProperties();

System.out.println(properties);
Set<String> strings = properties.stringPropertyNames();
for (String key : strings) {
    //getProperty(String key)
    String vaule = System.getProperty(key);
    
    System.out.println(key+"---->"+vaule);
}

  2. currentTimeMillis() 方法：返回一个 long 类型的值，表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳

    long start = System.currentTimeMillis();
int sum = 1;
for (int i = 0; i < 1000000000; i++) {
    sum+=i;
}
long end = System.currentTimeMillis();
System.out.println("运行时间为："+(end-start)+"毫秒");

  3. arraycopy(Object src,int srcPos,Object dest,int destPos,int length)方法：将一个数组元素拷贝到另一个数组

    • src：源数组
    • srcPos：源数组拷贝元素起始位置
    • dest：目标数组
    • destPos：拷贝到目标数组的起始位置
    • length：拷贝元素的个数
    int[] src = {101,102,104,105,106,107,108};
int[] dest = {201,202,203,204};
System.arraycopy(src,2,dest,0,3);
for (int i : dest) {
    System.out.println(i);
}

  4. gc() 方法：启动 Java 的垃圾回收器，并且对内存中的垃圾对象进行回收

  5. exit(int status) 方法：用来终止当前正在运行的 Java 虚拟机，其中参数 status 用于表示当前发生的异常状态，通常指定为0，表示正常退出，否则表示异常终止

Runtime 类

Runtime 类用于表示 Java 虚拟机运行时的状态，它用于封装 Java 虚拟机进程。应用程序不能创建自己的 Runtime 实例，若想要获得一个 Runtime 实例，可以通过 getRuntime() 方法获取与之相关的 Runtime 对象

  1. getRuntime() 方法：

    Runtime runtime = Runtime.getRuntime();

System.out.println("处理器个数为："+runtime.availableProcessors());

System.out.println("空闲内存大小为："+runtime.freeMemory()/1024/1024+"M");

System.out.println("最大可用内存为："+runtime.maxMemory()/1024/1024+"M");

  2. exec() 方法：用于执行一个 DOS 命令。exec() 方法会返回一个 Process 对象，该对象表示操作系统的一个进程，通过 Process 对象可以产生的新进程进行管理

    public static void main(String[] args) throws Exception{
    Runtime runtime = Runtime.getRuntime();
    Process exec = runtime.exec("notepad.exe");
    Thread.sleep(3000);
    exec.destroy();
}

Math 类

  • Math.abs(-1)：绝对值

  • Math.sin(1.57)：正弦

  • Math.cos(2.0)：余弦

  • Math.tan(0.8)：正切

  • Math.sqrt(4)：平方根

  • Math.cbrt(9)：立方根

  • Math.pow(2,3)：乘方2^3

  • Math.ceil(4.6)：大于参数的最小整数

  • Math.floor(-5.2)：小于参数的最大整数

  • Math.round(-8.6)：对小数进行四舍五入

  • Math.max(5.1,5.5)：两个数的较大值

  • Math.min(5.1,5.5)：两个数的较小值

  • Math.random()：生成一个大于等于0.0小于1.0的随机值

Random 类

  • Random 类构造方法
    • Random()：创建一个随机数生成器
    • Random(long seed)：使用 long 型的 seed(种子)创建伪随机数生成器，当 seed相同时，生成的随机数相同
  • Random 类常用方法
    • random.nextBoolean()：随机生成 boolean 类型的随机数
    • random.nextDouble()：随机生成 double 类型的随机数
    • random.nextFloat()：随机生成 float 类型的随机数
    • random.nextInt()：随机生成 int 类型的随机数
    • random.nextInt(int n)：随机生成[0,n)之间 int 类型的随机数
    • random.nextLong()：随机生成 long 类型的随机数

包装类

包装类：通过包装类可以将基本数据类型的值包装为引用数据类型的对象

  • byte--->Byte
  • short--->Short
  • int--->Integer
  • long--->Long
  • float--->Float
  • double--->Double
  • char--->Character
  • boolean--->Boolean

自动装箱和自动拆箱：自动装箱是指将基本数据类型的变量赋给对应的包装类变量；自动拆箱是指将包装类对象类型直接赋给一个对应的基本数据类型变量

基本数据类型、基本数据包装类与字符串之间的相互转换：

  1. 通过引用数据类型字符串 String 类的 value() 方法可以将8种基本数据类型转换为对应的字符串类型

    int num = 123;
String str = String.valueOf(num);
System.out.println("int变量转换为字符串："+str);

  2. 通过8种包装类的静态方法 value() 可以将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character包装类除外）

    String string = "987";
Integer integer = Integer.valueOf(num);
Integer integer1 = Integer.valueOf(string);
System.out.println("int变量转换为包装类："+integer);
System.out.println("字符串变量转换为包装类："+integer1);

  3. 通过8种包装类的有参构造方法可以将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character包装类除外）

    Integer integer2 = new Integer(num);
Integer integer3 = new Integer(string);
System.out.println("通过构造器将int变量转换为包装类："+integer2);
System.out.println("通过构造器将字符串变量转换为包装类："+integer3);

  4. 通过8种包装类的静态方法 parseXxx() 可以将变量内容匹配的字符串转换为对应的基本数据类型

    int parseInt = Integer.parseInt(string);
System.out.println("将字符串转换为基本类型的结果："+parseInt);

  5. 包装类都重写了 Object 类中的 toString() 方法，以字符串的形式返回被包装的基本数据类型的值

    String string1 = integer.toString();
System.out.println("将包装类转换为字符串："+string1);

日期和时间类

Data 类

Data 类：用于表示日期和时间。随着 JDK 版本的升级和发展，Data 类中大部分构造方法和方法已经不再推荐使用。在 JDK 8中只有两个构造方法可以使用：

  • Data()：创建当前日期时间的 Data 对象
  • Data(long data)：创建指定对象时间的 Data 对象，data 参数表示1970年1月1日0时0分0以来的毫秒数，即时间戳
Date date = new Date();
Date date1 = new Date(System.currentTimeMillis()+1000);
System.out.println(date);
System.out.println(date1);

Calendar 类

Calendar 类：用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分。Calendar 类是一个抽象类，不能被实例化，需要调用静态方法 getInstance() 来得到一个 Calendar 对象

Calendar 的常用方法：

  • calendar.get(int field)：返回指定日历字段的值

    Calendar.MONTH：月份的起始值是从0开始的，因此要获取当前的月份需要在 Calendar.MONTH 的基础上加1

  • calendar.set(int field,int value)：为指定日历字段设置指定值

    calendar.set(int year,int month,int date)：设置 Calendar 对象的年、月、日字段的值

    calendar.set(int year,int month,int date,int hour,int minute,int second)：设置 Calendar 对象的年、月、日、时、分、秒字段的值

  • calendar.add(int field,int amount)：根据日历规则，为指定的日历字段增加或减去指定的时间量

Calendar calendar = Calendar.getInstance();

int year = calendar.get(Calendar.YEAR);
//Calendar.MONTH：月份的起始值是从0开始的，因此要获取当前的月份需要在 Calendar.MONTH 的基础上加1
int month = calendar.get(Calendar.MONTH)+1;
int date = calendar.get(Calendar.DATE);
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
System.out.println("当前时间为："+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");

calendar.set(2021,1,1);
calendar.add(Calendar.DATE,100);
int year1 = calendar.get(Calendar.YEAR);
int month1 = calendar.get(Calendar.MONTH);
int date1 = calendar.get(Calendar.DATE);
System.out.println("竣工时间为："+year1+"年"+month1+"月"+date1+"日");

Calendar 有两种解释日历字段的模式：lenient 模式（容错模式）和 non-lenient 模式（非容错模式）。Calendar 处于 lenient 模式下，它的字段可以接收超过允许范围的值，此时会自动发生进位；Calendar 处于 non-lenient 模式下，如果某个字段的值超出了它允许的范围，程序会抛出异常。调用 calendar.setLenient(false) 方法开启 non-lenient 模式

JDK 8的日期与时间类

  • Clock：获取指定时区的当前日期、时间

    Clock clock = Clock.systemUTC();
System.out.println("获取 UTC 时区转换的当前时间："+clock.instant());
System.out.println("获取 UTC 时区转换的毫秒数："+clock.millis());

  • Duration：表示持续时间

    Duration duration = Duration.ofDays(2);
System.out.println("两天等于"+duration.toHours()+"小时");
System.out.println("两天等于"+duration.toMinutes()+"分钟");
System.out.println("两天等于"+duration.toMillis()+"秒");

  • Instant：表示一个具体时刻，可以精确到纳秒

    Instant instant = Instant.now();
System.out.println("获取 UTC 时区的当前时间为："+instant);
System.out.println("当前时间一小时后时间为为："+instant.plusSeconds(3600));
System.out.println("当前时间一小时前时间为为："+instant.minusSeconds(3600));

  • LocalDate：表示不带时区的日期

    LocalDate localDate = LocalDate.now();
System.out.println("从默认时区的系统时钟获得当前日期："+localDate);

  • LocalTime：表示不带时区的时间

    LocalTime localTime = LocalTime.now();
System.out.println("从默认时区的系统时钟获得当前日期："+localTime);

  • LocalDateTime：表示不带时区的日期、时间

    LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("从默认时区的系统时钟获得日期、时间"+localDateTime);
LocalDateTime time = localDateTime.plusDays(1).plusHours(3).plusMinutes(30);
System.out.println("当前的日期、时间加上1天3小时30分钟后："+time);

  • 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);

  • ZoneId：表示一个时区

    ZoneId zoneId = ZoneId.systemDefault();
System.out.println("当前默认时区为："+zoneId);

格式化类

DateFormat 类

DateFormat 类：用于将日期格式化为字符串或者将用特定格式显示的日期字符串转换成一个 Data 对象

DateFormat 常用方法：

  • DateFormat.getDateInstance()：用于创建默认语言环境和格式化风格的日期格式器

    DateFormat 类定义常量：

    • FULL常量：表示完整格式
    • LONG常量：表示长格式
    • MEDIUM常量：表示普通格式
    • SHORT常量：表示短格式

  • fullFormat.format(date)：将一个 Date 格式化为日期/时间字符串

Date date = new Date();
DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
DateFormat mediumFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
DateFormat shortFormat = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println("当前日期的完整格式为："+fullFormat.format(date));
System.out.println("当前日期的长格式为："+longFormat.format(date));
System.out.println("当前日期的普通格式为："+mediumFormat.format(date));
System.out.println("当前日期的短格式为："+shortFormat.format(date));
  • dateInstance.parse(Sting str)：将给定字符串解析成一个日期
DateFormat dateInstance = DateFormat.getDateInstance();
String str = "2021-03-15";
System.out.println(dateInstance.parse(str));

SimpleDateFormat 类

SimpleDateFormat 类：是 DateFormat 类的子类，它可以使用 new 关键字创建实例对象。在创建实例对象时，它的构造方法需要接收一个表示日期格式模板的字符串参数

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("Gyyyy 年 MM 月 dd 日：今天是 yyyy 年的第 D 天，E");
System.out.println(simpleDateFormat.format(new Date()));

SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy/MM/dd");
String str = "2021/03/15";
System.out.println(simpleDateFormat1.parse(str));

DateTimeFormatter 类

DateTimeFormatter 类：可以将日期、时间对象格式化成字符串，还能将特定格式的字符串解析成日期、时间对象

获取 DateTimeFormatter 对象方式：

  1. 使用静态变量创建 DateTimeFormatter 格式器。在 DateTimeFormatter 类中包含大量的静态变量，如 BASIC_ISO_DATE、ISO_LOCAL_DATE、ISO_LOCAL_TIME等
  2. 使用不同的枚举值创建 DateTimeFormatter 格式器。在 FormatStyle 类中定义了 FULL、LONG、MEDIUM 和 SHORT 四个枚举值
  3. 根据模式字符串创建 DateTimeFormatter 格式器
LocalDateTime date = LocalDateTime.now();

//1.使用常量创建 DateTimeFormatter
System.out.print("使用常量创建 DateTimeFormatter：");
DateTimeFormatter dtf1 = DateTimeFormatter.ISO_DATE_TIME;
System.out.println(dtf1.format(date));

//2.使用 MEDIUM 类型风格的 DateTimeFormatter
System.out.print("使用 MEDIUM 类型风格的 DateTimeFormatter：");
DateTimeFormatter dft2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
System.out.println(dft2.format(date));

//3.根据模式字符串创建 DateTimeFormatter 格式器
System.out.print("根据模式字符串创建 DateTimeFormatter：");
DateTimeFormatter dft3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println(dft3.format(date));

解析字符串：

String str = "2021-03-15 18:02:40";
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime localDateTime = LocalDateTime.parse(str, dateTimeFormatter);
System.out.println(localDateTime);
posted @ 2021-03-15 18:06  %新手上路%  阅读(55)  评论(0)    收藏  举报