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


一、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
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值