JAVA基础7 常用类库
JAVA基础
7.常用类库
7.1String,StringBuffer,StringBuilder如何创建对象？有哪些常用方法？相互转换【String与基本数据类型 / String与字节数组/字符数组】？
Java中的字符串是java提供的一个java类。
1.java.lang.String由于String类是属于java.lang包，因此在使用的时候不需要导包。
2.String类的定义
public final class String
extends Object
implements Serializable, Comparable, CharSequence
1.使用了final 修饰符，说明String类没有子类，不可被继承。
2.实现了implements Serializable, Comparable, CharSequence
3.String类的使用
1.可以像基本数据类型使用方式一样创建对象。
int a=100;
String s=”hello”; ”hello”–字符串常量
2.可以通过String类提供的构造方法创建对象
String常用构造方法:
String() 创建一个空字符串对象。
String(String original) 通过指定的字符串常量，创建一个字符串对象。
String(byte[] bytes, int offset, int length)通过字节数组创建一个字符串对象。【字节数组转换成字符串】。
String(char[] value, int offset, intcount) 通过字符数组创建一个字符串对象。【字符数组转换成字符串】。
例如：
package com.click369.test1;
public class StringTest1 {
public static void main(String[] args) {
//String的对象创建
//1.可以像基本数据类型使用方式一样创建对象。
String s1="hello";
//2.可以通过String类提供的构造方法创建对象
/*
* 常用构造方法:
String() 创建一个空字符串对象。
String(String original) 通过指定的字符串常量，创建一个字符串对象。
String(byte[] bytes, int offset, int length)通过字节数组创建一个字符串对象。【字节数组转换成字符串】。
//byte[] bytes---被转换的字节数组
//int offset---字节数组转换数据的起始位置
//int length---被转换的个数
//将字节数组中的数字值转换成了字符串
String(char[] value, int offset, int count) 通过字符数组创建一个字符串对象。【字符数组转换成字符串】。
//char[] value---被转换的字符数组
//int offset---字符数组转换数据的起始位置
//int count---被转换的个数
*/
String s2=new String();
String s3=new String("hello");
byte bytes[]={97,98,99,100};
String s4=new String(bytes,0,4);
System.out.println("s4=="+s4);
char value[]={'h','e','l','l','o'};
String s5=new String(value,0,value.length);
System.out.println("s5=="+s5);
}
}
String类中常用方法的使用：
1.public char charAt(int index)得到原始字符串的指定位置[从0开始]的字符
2.public byte[] getBytes(String charsetName)
public byte[] getBytes()
3.public boolean equals(Object anObject)
4.public boolean equalsIgnoreCase(String anotherString)不考虑大小写
5.public boolean startsWith(String prefix)
6.public boolean endsWith(String suffix)
7.public int indexOf(String str)
8.public int lastIndexOf(String str)
9.public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
10.public String concat(String str)
11.public String replace(String oldChar,String newChar)
12.public boolean matches(String regex) 匹配正则表达式
13.public boolean contains(String s)
14.public String[] split(String regex)
15.public String toLowerCase()转换为小写
16.public String toUpperCase()
17.public String trim()
18.public char[] toCharArray()
例如：
package com.click369.test1;
public class StringTest2 {
public static void main(String[] args) {
String s1=new String("hello,world");
//public char charAt(int index)得到原始字符串的指定位置[从0开始]的字符
char ch=s1.charAt(5);
System.out.println("ch=="+ch); //,
//public byte[] getBytes(String charsetName)将原始字符按照指定字符编码转换成字节数组。
//charsetName--字符编码【utf-8,GBK,GB2312...】
//public byte[] getBytes()将原始字符换成字节数组。
byte bytes[]=s1.getBytes();
for(byte b:bytes){
System.out.println("b=="+b);
}
//?????????
//public boolean equals(Object anObject)比较两个字符串是否相等。
boolean b=s1.equals("hello,world");
System.out.println("b=="+b);
//public boolean equalsIgnoreCase(String anotherString)比较两个字符串是否相等,不考虑大小写
boolean b1=s1.equalsIgnoreCase("HELLO,world");
System.out.println("b1=="+b1);
//public boolean startsWith(String prefix)前缀匹配【从一组用户名中得到所有姓李的用户名】
String names[]={"李三","张三","李四","张四"};
for(String name:names){
if(name.startsWith("李")){
System.out.println("name=="+name);
}
}
//public boolean endsWith(String suffix)后缀匹配【从一组用户名中得到所有用“四”结尾的用户】
for(String name:names){
if(name.endsWith("四")){
System.out.println("name=="+name);
}
}
//public int indexOf(String str)得到指定字符串在原始字符串中第一次出现的位置。[没有就-1]
int in=s1.indexOf("a");
System.out.println("in=="+in);
//public int lastIndexOf(String str)得到指定字符串在原始字符串中最后一次出现的位置。[没有就-1]
int ind=s1.lastIndexOf("o");
System.out.println("ind=="+ind);
//public String substring(int beginIndex)截取字符串
//public String substring(int beginIndex,int endIndex)【包前不包后】
String sub1=s1.substring(2, 9);
System.out.println("sub1=="+sub1);
//http://e.hiphotos.baidu.com/image/pic/item/4610b912c8fcc3cef70d70409845d688d53f20f7.jpg
String imgurl="http://e.hiphotos.baidu.com/image/pic/item/4610b912c8fcc3cef70d70409845d688d53f20f7.jpg";
String imgname=imgurl.substring(imgurl.lastIndexOf("/")+1);
System.out.println("imgname=="+imgname);
//public String concat(String str) 类似与“+”，字符串链接符
String newstr=s1.concat(",网星软件");
System.out.println("newstr=="+newstr);
//public String replace(String oldChar,String newChar)替换字符串
String info="name=zhangsan,age=23";
String newinfo=info.replace("zhangsan","lisi");
System.out.println("newinfo=="+newinfo);
//public boolean matches(String regex) 匹配正则表达式
//public boolean contains(String s)判断指定的字符串是否在原始字符串中存在
boolean b2=s1.contains("Hello");
System.out.println("b2=="+b2);
//public String[] split(String regex)把原始字符串按照指定的分隔符拆分成String数组
String info1="name=zhangsan,age=23";
String infoArray[]=info1.split("=");
for(String stri:infoArray){
System.out.println("stri:"+stri);
}
//public String toLowerCase()转换为小写
//public String toUpperCase()转换为大写
//public String trim()//去除两端空格
String s2=" zhang san ";
System.out.println("s2:"+s2.length());
String zhangsanstring=s2.trim();
System.out.println("zhangsanstring:"+zhangsanstring.length());
//public char[] toCharArray()将字符串转换成字符数组
char charray[]=s1.toCharArray();
for(char c:charray){
System.out.println("c=="+c);
}
}
}
1.字节数组与String的转换
1.1字节数组---->String [String的构造方法【String(byte[] bytes, int offset, int length)】]
1.2 String—>字节数组[String的public byte[] ()]
2.字符数组与String的转换
2.1字符数组—>String[String的构造方法String(char[] value, int offset, int count)]
2.2String---->字符数组[String的public char[] toCharArray()]
3.基本数据类型与String的转换。
3.1基本数据类型---->String
valueOf的静态方法
static String valueOf(boolean b)返回 boolean 参数的字符串表示形式。
static String valueOf(char c) 返回 char 参数的字符串表示形式。
static String valueOf(double d) 返回 double 参数的字符串表示形式。
static String valueOf(float f) 返回 float 参数的字符串表示形式。
static String valueOf(int i) 返回 int 参数的字符串表示形式。
static String valueOf(long l) 返回 long 参数的字符串表示形式。
3.2String----->基本数据类型[基本类型的封装类]
封装类—基本类型的封装类[只有基本类型具有封装类]
基本数据类型对应的复合数据类型【java类】
基本数据类型 封装类类型java类
byte[字节型] Byte[java类]
short[短整型] Short[java类]
int[整型] Integer[java类]
long[长整型] Long[java类]
float[单精度浮点型] Float[java类]
double[双精度浮点型] Double[java类]
char[字符型] Character[java类]
boolean【布尔型】 Boolean[java类]
基本数据类型与对应的封装类的转换
1.基本数据类型----->对应的封装类[装箱操作]将基本类型的数据值/变量赋值给对应的封装类
1.将基本类型的数据值/变量赋值给对应的封装类
2.通过封装类的构造方法
例如：
//int num=100; //num是基本类型变量，没有可供调用的变量和方法
//Integer number=num; //装箱操作 //number对应的封装类对象，提供一系列可供调用的变量和方法。
//System.out.println("number=="+number);
//Integer number=100;
Integer number1=new Integer(100);
int num=100;
Integer number2=new Integer(num);
Integer number3=new Integer("100"); //String---》int型封装类对象
2.对应的封装类----->基本数据类型[拆箱操作]将封装类对象转换基本数据类型
Integer number21=new Integer(200);
int num1=number21; //拆箱操作
String----->基本数据类型[通过基本类型的封装类提供的parseXXX(String value)]
例如：
String dou="12.5";
double d=Double.parseDouble(dou);
例如：
京东购买商品的时候，需要商品的价格和数量【String】,得到总价格就需要把商品的价格和数量【String】数据，转换成double类型，才能进行加减乘除运算，否则String类型的数据是不能进行加减乘除运算，需要使用String转换基本数据类型的这个操作。
String类final修饰的不可变字符串类
java.lang.StringBuilder类—一个final修饰的可变的字符序列
不可变字符串与可变的字符序列？？？？
我们在需要很多的字符串相连接的时候，最好使用StringBuilder类，不要使用String类，因为使用String类会造成存储空间的浪费。
定义：
public final class StringBuilder
extends Object
implements Serializable, CharSequence
| 构造方法摘要 |
|---|
| StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。 |
| StringBuilder(int capacity) 构造一个不带任何字符的字符串生成器，其初始容量由 capacity 参数指定。 |
| StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。 |
例如：
//StringBuilder()创建一个初始容量为16个字符的空的可变的字符串
StringBuilder sbui1=new StringBuilder();
//StringBuilder(int capacity) 创建一个指定初始容量的空的可变的字符串
StringBuilder sbui2=new StringBuilder(30);
//StringBuilder(String str)通过String对象创建一个可变的字符串【String转换成StringBuilder】
StringBuilder sbui3=new StringBuilder("hello");
//String
String s1="hello"; // 字符串常量池中创建一个"hello"
String s2="world"; // 字符串常量池中创建一个"world"
String s3="hello"+"world"; //字符串常量池中创建一个"helloworld";
StringBuilder sbui=new StringBuilder();//创建一个初始容量为16个字符的存储空间
sbui.append("hello"); //在16个字符的存储空间---》hello
sbui.append("world"); //在16个字符的存储空间---》helloworld
常用方法
1.StringBuilder append(Object o)向StringBuilder中追加任何类型的数据。
2.int capacity()返回当前容量。
3.char charAt(int index) 得到指定位置的字符数据
4.deleteCharAt(int index)移除此序列指定位置上的 char。
5.int indexOf(String str)得到指定的字符串在StringBuilder中第一次出现的位置。
6.lastIndexOf(String str)得到指定的字符串在StringBuilder中最后一次出现的位置。
7.insert(int offset,Object o)向StringBuilder中的指定位置插入指定数据。
8.replace(int start, int end, String str)替换
9.reverse()将此字符序列用其反转形式取代。
10.String substring(int start)/substring(int start, int end)截取字符串，注意用String变量收取结果。
11toString()将StringBuilder转换成String
例如：
StringBuilder sbui=new StringBuilder();//创建一个初始容量为16个字符的存储空间
sbui.append("hello"); //在16个字符的存储空间---》hello
sbui.append("world"); //在16个字符的存储空间---》helloworld
sbui.append(1234);
sbui.append(true);
sbui.append(12.34);
System.out.println(sbui);
//int capacity()返回当前容量。
System.out.println(sbui.capacity());
//char charAt(int index) 得到指定位置的字符数据
System.out.println(sbui.charAt(1));//e
//4.deleteCharAt(int index)移除此序列指定位置上的 char。
//["zhangsan","lisi","wangwu"]
String names[]={"zhangsan","lisi","wangwu"};
StringBuilder sbui11=new StringBuilder();
sbui11.append("[");
for(String name:names){
sbui11.append("\""+name+"\",");
}
sbui11.deleteCharAt(sbui11.length()-1);
sbui11.append("]");
System.out.println(sbui11);
//5.int indexOf(String str)得到指定的字符串在StringBuilder中第一次出现的位置。
//6.lastIndexOf(String str)得到指定的字符串在StringBuilder中最后一次出现的位置。
//7.insert(int offset,Object o)向StringBuilder中的指定位置插入指定数据。
System.out.println(sbui);
sbui.insert(5, "##");
System.out.println(sbui);
//8.replace(int start, int end, String str)替换
sbui.replace(5, 7, "@@");
System.out.println(sbui);
//reverse()将此字符序列用其反转形式取代。
sbui.reverse();
System.out.println(sbui);
//10.String substring(int start)/substring(int start, int end)截取字符串，注意用String
变量收取结果。
StringBuilder与String的转换
1.StringBuilder—>String
1.1通过StringBuilder的toString方法
1.2通过String的构造方法String(StringBuilder builder)
2.String-----》StringBuilder
2.1通过StringBuilder的构造方法StringBuilder(String str)
2.2通过StringBuilder的append方法
java.lang.StringBuffer–线程安全的可变字符序列
public final class StringBuffer
extends Object
implements Serializable, CharSequence
| 构造方法摘要 |
|---|
| StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。 |
| StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区。 |
| StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 |
1.StringBuffer append(Object o)向StringBuffer中追加任何类型的数据。
2.int capacity()返回当前容量。
3.char charAt(int index) 得到指定位置的字符数据
4.deleteCharAt(int index)移除此序列指定位置上的 char。
5.int indexOf(String str)得到指定的字符串在StringBuffer中第一次出现的位置。
6.lastIndexOf(String str)得到指定的字符串在StringBuffer中最后一次出现的位置。
7.insert(int offset,Object o)向StringBuffer中的指定位置插入指定数据。
8.replace(int start, int end, String str)替换
9.reverse()将此字符序列用其反转形式取代。
10.String substring(int start)/substring(int start, int end)截取字符串，注意用String变量收取结果。
11.toString()将StringBuffer转换成String
7.2String,StringBuffer,StringBuilder区别？
String是不可变字符串，StringBuilder StringBuffer可变字符串
StringBuilder非线程安全，从jdk5.0中开始出现
StringBuffer线程安全，从jdk1.0中开始出现
当字符串拼接极少的情况下使用String,
当出现大规模的字符串拼接动作时使用StringBuilder StringBuffer。如果需要这样的同步，则建议使用 StringBuffer。
7.3Date/SimpleDataFormat如何创建对象？有哪些常用方法？
时间处理类
java.util.Date 类 Date 表示特定的瞬间，精确到毫秒。
构造方法
Date() 得到当前系统的日期时间
Date(long date)分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
例如：
//Date() 得到当前系统的日期时间
Date d1=new Date();
//Thu Sep 05 10:45:10 GMT+08:00 2019
System.out.println(d1);
//Date(long date)分配 Date 对象并初始化此对象，
//以表示自从标准基准时间（称为“历元（epoch）”，
//即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
Date d2=new Date(5000);
//Thu Jan 01 08:00:05 GMT+08:00 1970
System.out.println(d2);
实例方法
after(Date when)测试此日期是否在指定日期之后。
before(Date when)测试此日期是否在指定日期之前。
toString() 将Date转换String.
通过Date(long date)得到当前系统时间
1.得到1970 年 1 月 1 日 00:00:00 GMT到当前时间的毫秒数。
System类中 static long currentTimeMillis()返回以毫秒为单位的当前时间。
2.通过Date(long date)构造方法得到当前系统时间
例如：
/*
* 通过Date(long date)得到当前系统时间
1.得到1970 年 1 月 1 日 00:00:00 GMT到当前时间的毫秒数。
System类中 static long currentTimeMillis()返回以毫秒为单位的当前时间。
2.通过Date(long date)构造方法得到当前系统时间
*/
long haomiaoshu=System.currentTimeMillis();
Date d3=new Date(haomiaoshu);
//Thu Sep 05 10:55:28 GMT+08:00 2019
System.out.println(d3);
注意：我们通过Date类得到的时间日期格式都不符合我们的使用习惯
【Fri Nov 08 10:28:37 GMT+08:00 2019】
【2019年11月8日 10:28:37 星期五】
【2019/11/8 10:28:37 星期五】
【2019-11-8 10:28:37 星期五】
时间日期格式转换
java.text.SimpleDateFormat—时间日期的格式化类
构造方法
SimpleDateFormat(String pattern) 通过指定的格式创建SimpleDateFormat对象
String pattern—时间日期格式。
日期和时间格式由日期和时间格式字符串指定规范：
yyyy-MM-dd HH:mm:ss E [2019-09-05 11:05:30 星期四]
yyyy/MM/dd HH-mm-ss E [2019/09/05 11-05-30 星期四]
yyyy年MM月dd日 HH时mm分ss秒 E [2019年09月05日 11时05分30秒 星期四]
实例方法
String format(Date date) 将一个 Date 格式化为日期/时间字符串
Date parse(String source) 从给定字符串的开始解析文本，以生成一个Date。
例如：
//Date----时间日期格式----String
//得到当前系统时间
Date d=new Date();
//设置时间日期格式
String geshi="yyyy-MM-dd HH:mm:ss E";
//创建时间日期格式化对象
SimpleDateFormat sdf=new SimpleDateFormat(geshi);
//通过format()方法格式时间日期
String newdate=sdf.format(d);
//2019-09-05 11:28:07 星期四
System.out.println(newdate);
try{
//String----时间日期格式----Date
String datetime="2019-09-05 11:28:07 星期四";
String geshi1="yyyy-MM-dd HH:mm:ss E";
//创建时间日期格式化对象
SimpleDateFormat sdf1=new SimpleDateFormat(geshi1);
Date dd=sdf1.parse(datetime);
//Thu Sep 05 11:28:07 GMT+08:00 2019
System.out.println(dd);
}catch(Exception e){
e.printStackTrace();
}
7.4Math类有哪些常用方法？
java.lang.Math
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
成员变量
static double E 自然常数
static double PI 圆周率
静态方法
random() 得到0.0-1.0之间的随机数
round(float a)返回最接近参数的 int。
例如：
//static double E 自然常数
//static double PI 圆周率
System.out.println("E=="+Math.E);
System.out.println("PI=="+Math.PI);
//静态方法
//random() 得到0.0-1.0之间的随机数
//System.out.println("random=="+Math.random());
//得到1--100之间的随机数
int d1=(int)(Math.random()*100);
System.out.println("d1=="+d1);
//round(float a)返回最接近参数的 int。
System.out.println("round=="+Math.round(11.5)); //12
System.out.println("round=="+Math.round(-11.5)); //-11
7.5正则表达式？
正则表达式，又称规则表达式。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。通常都是用来验证输入的字符串数据是否复合正则表达式定义的规范，常被用来做验证操作。
元字符和限定字符
元字符
\d{3}—”123”,”111”
[a-z0-9]{3,5}—”abc”
通常在使用的时候我们都不会自己书写正则表达式，是在使用的时候上网查找一个自己需要的正则表达式完成验证工作。
通常通过String提供得matches方法完成字符串数据的校验。
| boolean | matches(String regex)告知此字符串是否匹配给定的正则表达式。 |
|---|
常用的正则表达式：
- Email地址：^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$
- 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
- InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$
- 手机号码（可根据目前国内收集号扩展前两位开头号码）：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
- 电话号码(“XXX-XXXXXXX”、“XXXX-XXXXXXXX”、“XXX-XXXXXXX”、“XXX-XXXXXXXX”、"XXXXXXX"和"XXXXXXXX)：^((\d{3,4}-)|\d{3.4}-)?\d{7,8}$
- 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7.15位身份证号：1\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}$
8.18位身份证号：2\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$ - 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：3[a-zA-Z0-9_]{4,15}$
- 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：4\w{5,17}$
- 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.\d)(?=.[a-z])(?=.*[A-Z]).{8,10}$
- 日期格式：^\d{4}-\d{1,2}-\d{1,2}
中文字符的正则表达式：[\u4e00-\u9fa5]
腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
IP地址：((??:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d)
例如：
package com.click369.test1;
import java.util.Scanner;
public class ZhengZeTest1 {
public static void main(String[] args) {
/*
String regex="^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}$";
Scanner input=new Scanner(System.in);
System.out.println("请输入手机号码");
String phoneNum=input.nextLine();
boolean b=phoneNum.matches(regex);
if(b){
System.out.println("合法手机号码");
}else{
System.out.println("非法手机号码");
}
*/
String regex="[\u4e00-\u9fa5]{2,4}";
Scanner input=new Scanner(System.in);
System.out.println("请输中文:");
String zhongwen=input.nextLine();
boolean b=zhongwen.matches(regex);
if(b){
System.out.println("中文");
}else{
System.out.println("非中文");
}
}
}
1-9 ↩︎
1-9 ↩︎
a-zA-Z ↩︎
a-zA-Z ↩︎