【JavaSE】常用类 String 类、StringBuffer、StringBuilder 类、Date 类、 DateFormat 类、Calendar 类、Random、Math

最新推荐文章于 2024-07-29 14:22:26 发布

晏楠先生

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量315

点赞数

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/maikotom/article/details/122677855

版权

JavaSE 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

常用类

一、String 类
二、StringBuffer、StringBuilder 类
- StringBuffer VS StringBuilder VS String
三、Date & DateFormat 类
四、Calendar（日历）类
五、Random类与Math类
六、BigDecimal 类

一、String 类

String类较常用构造方法:

String(s)，
String (char a[ ])，
String(char a[ ],int startIndex,int count)

String 类的常用方法

public boolean startsWith(String s)
public boolean endsWith(String s) :判断当前字符串对象的前缀（后缀）是否是参数s指定的字符串
public int compareTo(String s):按字典序与参数s指定的字符串比较大小
public int compareToIgnoreCase(String s)
public boolean contains(String s):判断当前字符串对象是否含有参数指定的字符串 s
public int indexOf (String s):从当前字符串的头开始检索字符串 s，并返回首次出现 s 的位置
int indexOf(String s ,int startpoint)
int lastIndexOf (String s)
public String substring(int startpoint):获得一个当前字符串的子串
String substring(int start ,int end)
public String trim(): 得到一个去掉前后空格后的字符串对象
String[ ] split(String regex)：以regex切割字符串，形成字符串数组
String replace (String old, String new)：替换字符串

字符串与基本数据的相互转化

public static int parseInt(String s)：可以将由“数字”字符组成的字符串
类似地,使用java.lang包中的 Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。

字符串与字符、字节数组

字符串与字符数组：
String 类的构造方法：String(char[ ]) 和 String(char[ ]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
String类提供了将字符串存放到数组中的方法：public void getChars(int start,int end,char c[ ],int offset )
将字符串中的全部字符存放在一个字符数组中的方法：public char[ ] toCharArray()

字符串与字节数组
String(byte[])用指定的字节数组构造一个字符串对象。
String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。
public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。


public class Text {
    public static void main(String[] args) {
//		//构建字符串对象
//		//字面量的方式构建字符串对象
//		String s = "hello";
//
//		//通过构造方法构建字符串对象
//		String s0 = new String("sss");
//
//		char[] c = new char[]{'a','b','c','d'};
//		String s1 = new String(c);
//		System.out.println(s1);
//
//		String s2 = new String(c, 1, 2);
//		System.out.println(s2);

        String s = "hello";

        System.out.println(s.startsWith("hel"));//判断当前的字符串是否是以某个字符串开头
        System.out.println(s.endsWith("lo"));//判断当前的字符串是否是以某个字符串结尾

        /**
         * s.compareTo(b)
         * 先比两个字符串的第一位字符，如果不同，就不用往下比，直接计算第一位的两个字符的差(字符的ASCII码的值的差)
         * 如果第一位相同，就比较第二位，如果不同，就不用往下比，直接计算第二位的两个字符的差
         * 依次往下比较
         * 如果在比较的过程中，字符串都相同，只是一个字符串比另一个字符串长，比如："abcd"与"abc"
         * 这样的情况就是计算两个字符串的长度的差(第一个字符串减去第二个字符串)
         * 字符串的compareTo方法是严格的区分大小写的
         * 如果返回值是0代表字符串相同
         */
        System.out.println(s.compareTo("Hello"));

        /**
         * String的compareToIgnoreCase与compareTo基本相同，唯一的不同点是compareToIgnoreCase不区分大小写
         */
        System.out.println(s.compareToIgnoreCase("Hello"));

//		System.out.println('h' - 'H');

        System.out.println("hello".contains("el"));//判断字符串是否含有某个字符串

        System.out.println("abcdebc".indexOf("bcd"));//判断一个"bcd"在"abcdebc"字符串中所处的位置，从0位开始

        System.out.println("abcdebc".indexOf("b",2));//从第2个元素开始判断"b"字符串在"abcdebc"字符串中的位置

        System.out.println("abcdebc".lastIndexOf("b"));//获取字符串"b"在"abcdebc"中最后一次出现的位置

        System.out.println("hello".substring(1));//从字符串"hello"的第1个位置向后截取到最后返回一个新的字符串

        System.out.println("hello".substring(1,3));//截取字符串"hello"的[1,3)区间的元素返回新的字符串

        System.out.println("   hello   ".trim());//去掉字符串前后的空格，返回新的字符串

        String str = "hello,world,!!";

        String[] strs = str.split(",");//可以按照指定字符串把一个字符串切割成字符串数组

        for(String ss : strs){
            System.out.println(ss);
        }

        System.out.println("abcde".replace("bc", "ppp"));//对字符串中子串进行替换，参数1是原有的字符串，参数2是替换的新字符串

    }
}

package day16;

import java.io.UnsupportedEncodingException;

public class Test1 {
	public static void main(String[] args) {
		String s = "10";
		
		int i = Integer.parseInt(s);
		
		System.out.println(i);
		
		System.out.println(Boolean.parseBoolean("true"));
		
		char[] c = new char[]{'a','b','c','d'};
		
		
		System.out.println(new String(c));
		
		System.out.println(new String(c,1,2));//从字符数组c的第一个元素开始，总共截取两个元素形成一个新的字符串
		
		char[] c1 = new char[10];
		
		"abcdef".getChars(1, 3, c1, 2);//从字符串"abcdef"中截取[1,3)区间的元素，放到c1字符数组中，从第2个位置开始放
		
		for(int m = 0; m < c1.length; m++){
			System.out.println("第" + m + "个元素:" + c1[m]);
		}
		
		char[] c2 = "abcdef".toCharArray();//把字符串转化为字符数组
		
		for(int m = 0; m < c2.length; m++){
			System.out.println("第" + m + "个元素:" + c2[m]);
		}
		
		byte[] b = "abcd".getBytes();//把字符串转化为字节数组,转化的编码格式是平台默认的编码，目前默认是GBK
		
		System.out.println(new String(b));//把字节数组b转化为字符串
		
		System.out.println(new String(b,1,3));//把字节数组b转化为字符串，从b的第1个元素开始，总共截取3个元素来转化
		
		try {
			byte[] b1 = "abcd".getBytes("UTF-8");//把字符串按照指定的编码转化为字节数组
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		
	}
}

二、StringBuffer、StringBuilder 类

StringBuffer对象的创建

StringBuffer()
StringBuffer(int size)
StringBuffer(String s)

StringBuffer类的常用方法

StringBuffer append(String s) StringBuffer append(int n)
StringBuffer append(Object o) StringBuffer append(char n)
StringBuffer append(long n),StringBuffer append(boolean n),
StringBuffer append(float n),StringBuffer append(double n),
public char charAt(int n )
public void setCharAt(int n ,char ch)
StringBuffer insert(int index, String str) :
public StringBuffer reverse()
StringBuffer delete(int startIndex, int endIndex)
StringBuffer replace( int startIndex ,int endIndex, String str)


public class Test2 {
    public static void main(String[] args) {
        String s = new String("我喜欢学习");//在内存中有一个"我喜欢学习"的对象

        s = s + "数学";//在内存中形成一个"我喜欢学习数学"的对象

        StringBuffer bf = new StringBuffer("我喜欢学习");//内存中生成一个内容是"我喜欢学习"的StringBuffer对象

        bf.append("数学");//改变内容是"我喜欢学习"的StringBuffer对象的内容为"我喜欢学习数学"

        /**
         * 从上面可以看出，如果是s = s + "数学";这种方式来频繁改变字符串，时间上会生成很多个对象
         * 就会大量占用内存
         * 处理这样的问题，最后用StringBuffer，不论怎么频繁改变内容，都是始终只有一个StringBuffer对象
         */

        StringBuffer bf1 = new StringBuffer();//构建一个空的StringBuffer对象，随着加入内容扩展所需要的内存空间

        StringBuffer bf2 = new StringBuffer(1024);//构建一个空的StringBuffer对象，同时给这个对象初始化一定的内存空间

        StringBuffer bf3 = new StringBuffer("abcd");//构建一个StringBuffer对象,初始化的内容是"abcd"

        System.out.println(bf3.toString());//把StringBuffer对象转化为字符串

        bf3.append("!!");//在StringBuffer的原有内容结尾追加新的内容

        bf3.append(true).append(100);//可以使用append连续追加

        System.out.println(bf3.toString());//把StringBuffer对象转化为字符串

        System.out.println(bf3.charAt(2));//获取指定位置的字符

        bf3.setCharAt(3, '*');//在第3个位置插入字符'*'

        System.out.println(bf3.toString());//把StringBuffer对象转化为字符串

        bf3.insert(2, "123");//在第2个位置插入字符串"123"

        System.out.println(bf3.toString());//把StringBuffer对象转化为字符串

//		StringBuffer bf4 = bf3.reverse();//把原来的StringBuffer对象的内容进行，并且把倒序结果放到新的StringBuffer对象中
//		
//		System.out.println(bf4.toString());

//		StringBuffer bf5 = bf3.delete(0, 3);//把StringBuffer对象的内容进行删除，删除区间是[0,3)之间的元素
//		
//		System.out.println(bf5.toString());

        StringBuffer bf6 = bf3.replace(1, 3, "666");//把内容替换掉，替换的区间[1,3)的元素，替换内容是"666"

        System.out.println(bf6.toString());

        /**
         * StringBuilder与StringBuffer用法一致
         * 不同点是，StringBuilder是线程不安全，StringBuffer是线程安全
         * 所谓的线程安全与不安全，指定是作为线程的共享资源的时候，是否会发生错乱，如果不会就是线程安全，反之就是不安全
         */
        StringBuilder bu = new StringBuilder("123");
        System.out.println(bu.toString());


    }
}

StringBuffer VS StringBuilder VS String

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样

String：不可变字符序列
StringBuilder：可变字符序列、效率高、线程不安全
StringBuffer：可变字符序列、效率低、线程安全

String使用陷阱：
string s=“a”; //创建了一个字符串 s=s+“b”; //实际上原来的“a”字符串对象已经丢弃了，现在又产生了一个字符串 s+“b“ （也就是”ab”)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

三、Date & DateFormat 类

Date类在java.util包中。使用Date类的无参数构造方法创建的对象可以获取本地当前时间。
SimpleDateFormat来实现日期的格式化。

public SimpleDateFormat(String pattern);

该构造方法可以用参数pattern 指定的格式创建一个对象，该对象调用：

public String format(Date date)：方法格式化时间对象date

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test3 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        /**
         * yyyy代表年份
         * MM代表月份
         * dd代表日
         * HH代表小时
         * mm代表分钟
         * ss代表秒
         *
         * 格式化的分隔符可以自由定义
         *
         * 在格式化时候，可以把年月日时分秒单独拿出一个或者拿出其中几个来组合使用
         * 例如new SimpleDateFormat("yyyy-MM-dd");
         * new SimpleDateFormat("MM-dd");
         * new SimpleDateFormat("dd HH");
         *
         */

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        // DateFormat df = new SimpleDateFormat("HH");
		// DateFormat df = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        String s = df.format(date);
        System.out.println(s);
    }
}

四、Calendar（日历）类

Calendar是一个抽象基类，主用于完成日期字段之间相互操作。

获取Calendar实例的方法

使用Calendar.getInstance()方法
调用它的子类GregorianCalendar的构造器。

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND

public void set(int field,int value)
public void add(int field,int amount)
public final Date getTime()
public final void setTime(Date date)
Calendar calendar = Calendar.getInstance();
// 从一个 Calendar 对象中获取 Date 对象
Date date = calendar.getTime();
//使用给定的 Date 设置此 Calendar 的时间
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, 8);
System.out.println(“当前时间日设置为8后,时间是:” + calendar.getTime());
calendar.add(Calendar.HOUR, 2);
System.out.println(“当前时间加2小时后,时间是:” + calendar.getTime());
calendar.add(Calendar.MONTH, -2);
System.out.println(“当前日期减2个月后,时间是:” + calendar.getTime());

package day16;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Test4 {
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();//创建Calendar对象
		
		Date date = new Date();
		
		c.setTime(date);//把当前的date传入c里面，后面c的操作就可以获取当前date的信息
		
		System.out.println(c.get(c.YEAR));
		System.out.println(c.get(c.MONTH));
		System.out.println(c.get(c.DAY_OF_MONTH));//几号，当前月的第几天
		System.out.println(c.get(c.DAY_OF_WEEK));//星期几
		System.out.println(c.get(c.HOUR));//12小时制
		System.out.println(c.get(c.HOUR_OF_DAY));//24小时制
		System.out.println(c.get(c.MINUTE));//分钟
		System.out.println(c.get(c.SECOND));//秒
		
		
		/**
		 * public void set(int field,int value)
		 * 可以设置指定日期中的某个值，例如年份或者月份等等
		 * 参数1是设置日期的部分，如c.YEAR、c.MONTH
		 * 参数2是设置的值
		 */
		c.set(c.YEAR, 2030);//设置年份
		
		System.out.println(c.get(c.YEAR));
		
		c.set(c.DAY_OF_MONTH, 11);//设置为11号
		
		System.out.println(c.get(c.DAY_OF_MONTH));
		
		/**
		 * public void add(int field,int amount)
		 * 对日期的某一部分做加减
		 * 参数1是设置日期的部分，如c.YEAR、c.MONTH
		 * 参数2是加减的值，正数就是加，负数就是减
		 */
		
		c.add(c.YEAR, 10);//当前年份加10
		
		System.out.println(c.get(c.YEAR));
		
		c.add(c.YEAR, -10);//当前年份减10
		
		System.out.println(c.get(c.YEAR));
		
		Date newDate = c.getTime();//返回经过各种设置加减操作之后的时间
		
		DateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		
		System.out.println(sf.format(newDate));
	}
}

五、Random类与Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

abs 绝对值
acos,asin,atan,cos,sin,tan 三角函数
sqrt 平方根
pow(double a,doble b) a的b次幂
max(double a,double b)
min(double a,double b)
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
toRadians(double angdeg) 角度—>弧度

package day16;

public class Test5 {
	public static void main(String[] args) {
		System.out.println(Math.abs(-1));//取绝对值
		
		System.out.println(Math.sin(3));//三角函数
		
		System.out.println(Math.sqrt(4));//平方根
		
		System.out.println(Math.pow(2, 3));//2的3次方
		
		System.out.println(Math.max(3, 4));//最大值
		
		System.out.println(Math.min(3, 4));//最小值
		
		System.out.println(Math.random());//在0到1之间double类型随机数
		
		System.out.println(Math.round(3.46));//对数据四舍五入
		
		System.out.println(Math.round(3.56));//对数据四舍五入
		
		System.out.println(Math.toRadians(60));//角度转化为弧度
		
	}
}

六、BigDecimal 类

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。
构造器

public BigDecimal(double val)//不建议使用
BigDecimal b1 = new BigDecimal(Double.toString(0.2));//如果必须使用数字，通过其封装类的toString方法转化为字符串
public BigDecimal(String val)

常用方法

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
*参数1是除数
* 参数2是保留小数点后几位
* 参数3是舍入的方式
ROUND_CEILING //向正无穷方向舍入
ROUND_DOWN //向零方向舍入
ROUND_FLOOR //向负无穷方向舍入
ROUND_HALF_DOWN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
ROUND_HALF_EVEN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN
ROUND_HALF_UP //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
ROUND_UNNECESSARY //计算结果是精确的，不需要舍入模式
ROUND_UP //向远离0的方向舍入


import java.math.BigDecimal;

public class Text5 {
    public static void main(String[] args) {
//		System.out.println(0.2 + 0.1);
//		System.out.println(0.3 - 0.1);
//		System.out.println(0.2 * 0.1);
//		System.out.println(0.3 / 0.2);
//		
//		/**
//		 * 在计算机浮点型数据无法精确的表示
//		 */
//		
		BigDecimal b1 = new BigDecimal(0.2);//不建议使用，可以以下方式处理
//		BigDecimal b1 = new BigDecimal(Double.toString(0.2));//如果必须使用数字，通过其封装类的toString方法转化为字符串
//		
//		System.out.println(b1.toString());
//		
//		BigDecimal b2 = new BigDecimal("0.2");
//		
//		System.out.println(b2.toString());

//		BigDecimal a = new BigDecimal("0.2");
//		
//		BigDecimal b = new BigDecimal("0.3");
//		
//		System.out.println(a.add(b));//加
//		
//		System.out.println(a.subtract(b));//减
//		
//		System.out.println(a.multiply(b));//乘
//		
//		System.out.println(b.divide(a));//除

        BigDecimal a = new BigDecimal("4.5");

        BigDecimal b = new BigDecimal("1.3");

//		System.out.println(a.divide(b));//在两个数不能整除时报异常

        /**
         * 在两个数字不能整除时，例如4.5/1.3
         * 要使用divide(BigDecimal  divisor, int scale, int roundingMode)
         * 参数1是除数
         * 参数2是保留小数点后几位
         * 参数3是舍入的方式
         */
        System.out.println(a.divide(b,2,BigDecimal.ROUND_CEILING));

        System.out.println(a);
        System.out.println(b);

        /**
         * 注意：BigDecimal做加减乘除，都是生成一个新的BigDecimal对象，对原有对象没有影响
         */

    }
}

晏楠先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【JavaSE】常用类 String 类、StringBuffer、StringBuilder 类、Date 类、 DateFormat 类、Calendar 类、Random、Math

常用类一、String 类二、StringBuffer、StringBuilder 类StringBuffer VS StringBuilder VS String三、Date & DateFormat 类四、Calendar（日历）类五、Random类与Math类六、BigDecimal 类一、String 类String类较常用构造方法:String(s)，String (char a[ ])，String(char a[ ],int startIndex,int count)
复制链接

扫一扫