常用类
一、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对象,对原有对象没有影响
*/
}
}