目录
String valueOf 将其他类型转换为String,比较常用的是将基本类型转换为String
charAt(int insex) 返回当前字符串中指定位置的字符
String startsWith() endsWith() 判断当前字符串是否是以给定的内容开始或结束的
StringBuilder 提供了修改字符串相关方法,常用的:增,删.改,插
JDK API
什么是JDK API
JDK中包含大量的API类库,所谓API(Application Programming Interface,应用程序编程接口)就是一些已写好,可供直接调用的功能(在java语言中,这些功能以类的形式封装).
JDk API包含的类库更能强大,经常使用的有:字符串操作 集合操作 文件操作 输入输出操作 网络操作 多线程等等.
JDk包结构
为了便于使用和维护,JDK类库按照包结构划分,不同功能的类划分在不同的包中;
经常使用的包如下表所示:
包 功能
java.lang java程序的基础类,如字符串 多线程等 该包中的类使用的评率非常高,不需要import,可以直接使用
java.util 常用工具类,如集合 随机数产生器 日历 时钟等
java.io 文件操作 输入/输出操作
java.net 网络操作
java.math 数学运算相关操作
java.security 安全相关操作
java.sql 数据库访问
java.text 处理文字 日期 数组 信息的格式
文档注释规范
文档注释
以/**开始,以*/结束;
加在类和方法的开头,用于说明作者,时间,版本,要实现功能的详细描述等信息;
通过javadoc工具,可以轻松的将此注释转换为HTML文档说明;学习者和程序员主要通过文档了解API的功能;
文档注释不同于普通的注释(//...或/*...*/),普通注释写在程序之中,用于程序员进行代码维护和交流,无法通过工具生成文档,而文档注释(/**...*/)写在类和方法的开头,专门用于生成供API使用者进行参考的文档资料.
String及其常用API
# String 是不可改变对象
* java.lang.String使用了final修饰,不能被继承;
* 字符串底层封装了字符数组及针对字符数组的操作算法;
* 字符串一旦创建,对象永远无法改变,但字符串引用可以重新赋值;
* 字符串中任何一个字符对应16位(两个字节)的定长Unicode编码。
# String 常量池
* 静态字符串在常量池中创建,并尽量使用同一个对象,重用静态字符串;
* 对于重复出现的字符转直接量,JVM会首先在常量池中查找。如果存在即返回该对象。
# 内存编码及长度
* String再内存中采用Unicode编码,每个字符16位占用两个字节;任何一个字符都算1个char字符长度,占用两个字节。
* 获取字符串的长度
> String str.length();
# 使用indeOf实现检索
* indexOf方法用于实现在字符串中检索另外一个字符串
> int indexOf(String str) 在字符串中检索str,返回其第一次出现的位置,如果找不到则返回-1
> int indexOf(String str,int fromIndex) 从字符串fromIndex位置开始检索
* String还定义了lastindexOf方法:
> int lastIndexOf(String str,int from) str在字符串中多次出现时,将返回最后一个出现的位置
# 使用substring获取子串
> String substring(int beginIndex,int endIndex)
> String substring(int beginIndex) 返回字符串中从下标beginIndex(包括)开始到字符串结尾的子字符串
# trim() 去除一个字符串的前导后继空字符串
# charAt()
> char charAt(int index) 返回字串指定位置的字符。
# startsWith 和 endsWith 检查一个字符串是否以指定字符串开心或结尾
# StringBuilder 封装可变字符数组
StringBuilder封装可变的字符数组,对象创建后可以通过调用方法改变其封装的字符序列。
StringBuilder有如下常用构造方法:
public StringBuilder()
public StringBuilder(String str)
> StringBuilder append(String str) 追加字符串
> StringBuilder insert(int dstOffset,String s) 插入字符串
> StringBuilder delete(int start int end) 删除字符串
> StringBuilder replace(int start,int end,String str) 替换字符串
> StringBuilder reverse() 字符串反转
# StringBuffer 和 StringBuilder
- StringBuffer是线程安全的,同步处理的,性能稍慢
- StringBuilder是非线程安全的,并发处理的,性能稍快
String是不可变对象
字符串底层封装了字符数组及针对字符数组的操作算法;
字符串一但创建,对象永远无法改变,但字符串引用可以重新赋值;
java字符串中任何一个字符对应16位(两个字节)的定长Unicode编码.
String常量池
java为了提高性能,静态字符串(字面量/常量/常量连接的结果)在常量池中创建,并尽量使用同一个对象,重用静态字符串;
对于重复出现的字符串直接量,JVM会首先在常量池中查找,如果存在即返回对象.
内存编码及长度
String在内存中采用Unicode编码,每个字符16位占用两个字节;
任何一个字节(无论中文还是英文)都算1个char字符长度,占用两个字节.
String常用方法
String int length()返回当前字符串的长度
package string;
/**
* int length()
* 返回当前字符串的长度
* @author Administrator
*
*/
public class LengthDemo {
public static void main(String[] args) {
String str="kdsjfjdhhdgkf";
System.out.println(str.length());//13
}
}
String valueOf 将其他类型转换为String,比较常用的是将基本类型转换为String
package string;
import java.awt.Stroke;
/**
* String提供了一组静态方法valueOf
* 作用是将其他类型转换为String,比较常用的是将基本类型转换为String
* @author Administrator
*
*/
public class ValueOfDemo {
public static void main(String[] args) {
int a=123;
String str=String.valueOf(a);
System.out.println(str);
double d=123.123;
String str2=String.valueOf(d);
System.out.println(str2);
str=""+a;
System.out.println(str);
}
}
x.equals(y) 判断x与y是否相同(字)区分大小写
x.equalsIgnoreCase(y)不区分大小写
String toUpperCase()
String toLowerCase()
将当前字符串中的英文部分装转换为全大写或全小写
package string;
/**
* x.equals(y)判断x与y是否相同(字)区分大小写
* x.equalsIgnoreCase(y)不区分大小写
* String toUpperCase()
* String toLowerCase()
* 将当前字符串中的英文部分装转换为全大写或全小写
*
* @param args
*/
public class ToUpperCaseDemo {
public static void main(String[] args) {
String str="nihaio";
String upper =str.toUpperCase();
System.out.println(upper);
String lower=str.toLowerCase();
System.out.println(lower);
String c="aaa";
String d="aaa";
String cc=c.toUpperCase();
String dd=d.toUpperCase();
if(cc.equals(dd)){
System.out.println("dui");
}else{
System.out.println("cuo");
}
if (cc.equalsIgnoreCase(d)) {
System.out.println("输入正确");
} else {
System.out.println("输入有误");
}
}
}
使用indexOf实现检索
indexOf方法用于实现在字符串中检索另外一个字符串
String提供几个重载的indexOf方法
1 int indexOf(String str) 在字符串中检索str,返回其第一次出现的位置,如果找不到则返回-1
2 int indexOf(String str,int fromIndex) 从字符串的fromIndex位置开始检索
String 还定义有lastIndexOf方法:
3 int lastIndexOf(String str,int from) str在字符串中多次出现时,将返回最后一个出现的位置
package string;
/**
* int indexOf(String str)
* 检查并返回给定字符串在当前字符串中的位置,如果当前字符串
* 不包含给定的内容时,返回值-1
* @author Administrator
*
*/
public class IndexOfDemo {
public static void main(String[] args) {
String str="jdhjkongkongkjomg";
int a=str.indexOf("j");
System.out.println(a);//0
a=str.indexOf("j",2);
System.out.println(a);//3
a=str.lastIndexOf("j");
System.out.println(a);//13
使用substring获取子串
substring方法用于返回一个字符串的子字符串.
substring常用重载方法定义如下:
1 String substring(int beginIndex,int endIndex) 返回字符串从下标beginIndex(包括)开始到endIndex(不包括)结束的子字符串
2 String substring(int beginIndex) 返回字符串中下标begindex(包括)开始到字符串结尾的子字符串
package string;
/**
* String substring(int start,int end)
* 截取当前字符串中指定范围的字符串,两个参数为下标,
* 注意在API中有一个特点:通常用两个数字表示范围时都是含头不含尾的.
* @author Administrator
*
*/
public class SubstringDemo {
public static void main(String[] args) {
// 01234567890
String str="www.tedu.cn";
//截取域名部分
String sub =str.substring(4,8);
System.out.println(sub);
//只传入一个参数时,是从该字符创位置截取到末尾
sub=str.substring(4);
System.out.println(sub);
}
}
trim 去掉一个字符串的前导和后继空字符
package string;
/**
* String trim()
* 去除字符串两边的空白字符
*
* @author Administrator
*
*/
public class TrimDemo {
public static void main(String[] args) {
String str=" hello";
System.out.println(str);
String trim=str.trim();
System.out.println(trim);
System.out.println(str.trim());
}
}
charAt(int insex) 返回当前字符串中指定位置的字符
String中定义有charAt()方法:
1 char charAt(int index) 方法charAt()用于返回字符串指定位置的字符.参数index表示指定的位置
package string;
/**
* char charAt(int insex) 返回当前字符串中指定位置的字符
*
* @author Administrator
*
*/
public class CharAtDemo {
public static void main(String[] args) {
// 0123456
String str = "hello";
char c = str.charAt(4);
System.out.println(c);
for (int i = 0; i < str.length(); i++) {
System.out.println(str.charAt(i));
}
}
}
String startsWith() endsWith() 判断当前字符串是否是以给定的内容开始或结束的
package string;
/**
* boolean startsWith(String str)
* boolean endsWith(String str)
* 判断当前字符串是否是以给定的内容开始或结束的
* @author Administrator
*
*/
public class StartsWithDemo {
public static void main(String[] args) {
String str="dkfjkdsf";
boolean starts=str.startsWith("f");
System.out.println(starts);
boolean ends=str.endsWith("d");
System.out.println(ends);
}
}
StringBuilder及其API
StringBuilder 提供了修改字符串相关方法,常用的:增,删.改,插
StringBuilder封装可变字符数组
StringBuilder封装可变的字符数组,对象创建后可以通过调用方法改变其封装的字符序列
StringBuilder有如下常用构造方法:
public StringBuilder()
public StringBuilder(String str)
StringBuilder的很多方法的返回值均为 StringBuilder类型.这些方法的返回语句均为:return this
由于改变封装的字符串序列后又返回了该对象的引用.可以按照如下简洁的方式书写代码:
buf.append("ibm").append("java")
.insert(3,"oracle")
.replace(9,13,"java");
System.out.println(buf.toString());
package string;
/**
*
* String由于其优化导致它是不可改变对象,因此平凡修改字符串 性能低下.为了解决这个问题,java提供了一个专门用于修改
* 字符串的类:java.lang.StringBuilder 其内部维护一个可变的char数组,因此开销小,性能好,并且
* 还提供了修改字符串相关方法,常用的:增,删.改,插.同样 也包含了字符串中原有的相关操作方法,比如:indexOf,length等等.
*
*
* @author Administrator
*
*/
public class StringBuilderDemo {
public static void main(String[] args) {
String line="好好学习";
StringBuilder builder=new StringBuilder(line);
builder.append(",为了未来的美好");
System.out.println(builder);
builder.replace(9, 12,"@@");
System.out.println(builder);
builder.delete(5,9 );
System.out.println(builder);
builder.insert(0,"huozhe");
System.out.println(builder);
String s=builder.toString();
System.out.println(s);
}
}
StringBuilder总结
StringBuilder是可变字符串.字符串的内容计算,建议采用StringBuilder实现,这样性能会好一些;
java的字符串连接的过程是利用StringBuilder实现的
String s="AB";String s1=s+"DE"+1;
String s1=new StringBuilder(s).append("DE")
.append(1).toString();
StringBuilder和StringBuffer
StringBuilder是非线程安全的,并发处理的,性能稍快
StringBuffer是线程安全的,同步处理的,性能稍慢.
正则表达式简介
实际开发中,经常需要对字符串数据进行一些复杂的匹配 查找 替换等操作 通过"正则表达式",可以方便的实现字符串的复杂操作.
正则表达式是一串特定字符,组成一个"规则字符串",这个"规则字符串"是描述文本规则的工具
正则表达式就是记录文本规则的代码.
例如: 正则表达式:"[a-z]"表示a到z的任意一个字符
正则表达式"[a-z]+"表示由1个或多个a-z字符组成的字符串
[abc] abc中任何一个字符
[^abc] 除了abc的任意字符
[a-z] a-z中的任意一个字符
[a-zA-Z0-9] a-zA-Z0-9中的任意一个字符
[a-z&&[^bc]] a-z中除了b和c以外的任意一个字符,其中&&表示"与"的关系
"\\d" 0-9
"\\D" 除了0-9
"\\s" [\t\n\xOB\f\r]
"\\S" [^\s]
"\\w" [a-zA-Z_0-9]
"\\W" [^\w]
. 任意一个字符
\d 任意一个数字字符,相当于[0-9]
\w 单词字符,相当于[a-zA-Z_0-9]
\s 空白字符,相当于[\t\n\xOB\f\r]
\D 非空白字符
\W 分单词字符
\S 分空白字符
x? 表示0个或1个x
x* 表示0个或任意多个x
x+ 表示1个或任意多个x(大于等于1个x)
x{n} 表示n个x
x{n,} 表示n个到任意多个x(大于等于n个x)
x{n,m} 表示n个到m个x
分组"()"
分组:()圆括号表示分组,可以将一系列正则表达式看做一个 整体,分组时可以使用"|"表示"或"关系,
例如:匹配手机号码前面的区号:(\+86|0086)?\s?\d{11}
上述例子中,圆括号表示这里需要出现"+86"或者"0086"
"^"和"$" 边界匹配
^代表字符串开始
$代表字符串结束
例如:匹配用户名规则-从头到尾连续8-10个单词字符
\w{8,10}
^\w{8,10}$
如果使用第一种写法.则"abcerifghjvb_546541354"是可以验证通过的;
使用第二种写法由于有从头到尾整体的限定,则验证不能通过.
String正则API
matches方法
matches(正则表达式)方法:将一个字符串与正则表达式进行匹配如果匹配成功返回true,否则返回false
split方法
String的split方法可以将字符串按照特定的分隔符拆分成字符串数组.
String[] split(String regex) 参数regex为正则表达式以regex所表示的字符串为分隔符,将字符串拆分成字符串数组.
replaceAll方法
String提供了用于字符串替换的方法:
String replaceAll(String regex,String replacement) 将字符串中匹配正则表达式regex的字符串替换成replacement.
package string;
/**
* String支持的正则表达式方法一:
* boolean matches(String regex)
* 使用给定的正则表达式匹配当前的字符串是否符合格式要求,
* 符合返回true否则为false
* 注:无论正则表达式是否加了边界匹配,都是做完全匹配验证的
*
* @author Administrator
*
*/
public class MatchesDemo {
public static void main(String[] args) {
String email ="sdhf@trw.hf";
/*
* 验证email正则表达式是否正确
* [a-zA-Z0-9_]+@[a-zA-Z0_9]+(\.[a-zA-Z]+)+
*
*/
String regex="[a-zA-Z0-9_]+@[a-zA-Z0_9]+(\\.+[a-zA-Z]+)+";
// String regex="[a-zA-Z0-9_]+@[a-zA-Z0_9]+([.]+[a-zA-Z]+)+";
System.out.println(regex);
boolean match=email.matches(regex);
if(match){
System.out.println("是邮箱");
}else{
System.out.println("不是邮箱");
}
}
}
package string;
import java.util.Arrays;
import javax.sound.midi.Synthesizer;
/**
* String 支持正则表达式的方法二:
* String[] split(String regex)
* 讲当前字符串按照满足正则表达式的部分进行拆分,并将拆分后的
* 各部分以String数组形式返回.
*
*
* @author Administrator
*
*/
public class SplitDemo {
public static void main(String[] args) {
String str="abc123def456ghi789jkl";
/*
* 将str按照数字部分进行拆分,得到所有的字母部分
*/
String[] arr=str.split("[0-9]+");
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));
String str2="123,456,789,012";
String[] arr2=str2.split(",");
System.out.println(arr2.length);
System.out.println(Arrays.toString(arr2));
//当遇到按照正则表达式关键字符拆分是要注意转义
String str3="aaa.bbb.ccc.ddd.eee";
String[] arr3=str3.split("\\.");
System.out.println(arr3.length);
System.out.println(Arrays.toString(arr3));
/*
* 在字符串中如果遇到连续匹配两个可拆分项时,
* 中间会拆分出一个空字符串.如果字符串最开始就是拆分
* 项则左侧也会拆分出一个空字符串
*/
String str4="aaa...bbb.ccc.ddd.eee";
String[] arr4=str4.split("[.]");
System.out.println(arr4.length);
System.out.println(Arrays.toString(arr4));
//如果是末尾连续匹配则忽略所有拆分出来的空字符串
String str5="aaa...bbb.ccc.ddd.eee.......";
String[] arr5=str5.split("[.]");
System.out.println(arr5.length);
System.out.println(Arrays.toString(arr5));
}
}
package string;
/**
* String支持正则表达式的方法三:
* String replaceAll(String regex,String str)
* 将当前字符串中满足正则表达式的部分替换为给定的字符串
* @author Administrator
*
*/
public class ReplaceAllDemo {
public static void main(String[] args) {
String str="abc123def456ghi789jkl";
/*
* 将当前字符串中的数字部分替换为#NUMBER#
* abc#NUMBER#def#NUMBER#ghi#NUMBER#jkl
*/
str=str.replaceAll("\\d+", "#NUMBER#");
System.out.println(str);//abc#NUMBER#def#NUMBER#ghi#NUMBER#jkl
//去除汉字
String str1="abc123def456ghi789jkl";
str1=str1.replaceAll("[a-z]+", "#NUMBER#");
System.out.println(str1);//#NUMBER#123#NUMBER#456#NUMBER#789#NUMBER#
//和谐用语
String regex="(wqnmd|nmsl|wqnmlgb|fw|djb)";
String message="wqnmlgb你个fw";
message=message.replaceAll(regex, "***");
System.out.println(message);//***你个***
}
}
Object
在java类继承结构中,java.lang.Object类位于顶端;
如果定义一个java类时没有使用extends关键字声明其父类,则其父类默认为java.lang.Object类;
Object类型的引用变量可以指向任何类型对象.
测试Point中重写的Object中的方法
package object;
/**
* Object 对象,东西
* Object是所有类的超类
* 使用当前Point测试Object中经常被派生类重写的方法
* @author Administrator
*
*/
public class Point {
private int x;
private int y;
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Point other = (Point) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
public static void main(String[] args) {
}
}
package object;
/**
* 测试Point中重写的Object中的方法
* @author Administrator
*
*/
public class TestPoint {
public static void main(String[] args) {
/*
* Object中常被我们重写的第一个方法是:toString
* 这个方法的意思是将当前对象转换为一个字符串.
* Object默认实现时返回的字符串格式:类名@地址
*/
String str="hello";
/*
* System.out.println(Object o)
* 我们经常将一个对象输出到控制台看他的内容,但是
* 这个方法实际上是将该对象toString方法的返回值
* 输出到控制台.java提供的类如String,StringBuilder
* 等都重写了这个方法
*
*
*/
System.out.println(str);//hello
Point p=new Point(1,2);
//我们自定义的类不重写则输出通常没有价值
System.out.println(p);//Point [x=1, y=2]
/*
* 在连接字符串时,非String的类型都会隐式调用toString
* 方法转换为字符串后再连接.
*/
String line="这个p的内容是:"+p;//这个p的内容是:Point [x=1, y=2]
System.out.println(line);
Point p2=new Point(1,2);
System.out.println(p2);//Point [x=1, y=2]
System.out.println(p==p2);//false
/*
* equals方法的意义是比较两个对象的内容是否相同
* Object定义时实现的规则就是用==比较的,所以
* 实际上没有价值,如果想真实比较内容就需要子类去
* 重写这个方法.
* 注:java提供的类大多都重写了equals.
*
*
*
*/
System.out.println(p.equals(p2));//true
// Point p=new Point(1,2);
// System.out.println(p);
}
}
toString方法
如何重写 tostring方法
Object类中的重要方法,用于返回对象值的字符串表示;
原则上建议重写,格式大多数遵循“类的名字[域值]”,例如
public String tostring (){
return getclass().getName()
+"[name="+name
+",salary="+salary
+",gender="+gender
+"]";
}
1 Java语言中很多地方会默认调用对象的 tostring方法
-字符串+对象,自动调用对象的 tostring方法
-System.out. print(任意对象),直接调用 tostring方法
2 如果不重写 tostring方法,将使用 Objecte的 Tostring,方法,其逻辑为:
-类名@散列码
3 tostring方法是非常有用的调试工具;
4 JDK中的标准类库中,许多类都定义了 toString方法方便用户获得有关对象状态的必要信息;
5 强烈建议为自定义的每一个类增加 toString方法。
重写Cell的 toString()方法
public class Cell{
/**重写 toString方法,返回对cell信息的描述*/
public String tostring(){
return getclass(). getName()
+"["+row+","
+Col+"]";
}
}
String重写toString方法
String的toString()方法就是将自身返回了.
public String toString(){
return this;
}
equals方法
1 Object中的方法,作用在于检测一个对象是否等于另外一个对象;
2 在 Object类中,这个方法判断两个对象是否具有相同的引用,即是否为相同的对象;
3 在实际应用中,一般需要重写该方法,通过比较对象的成员属性,使该方法更有意义,例如:对于Cell类,如果不重写 equals方法,下面代码在cel1和cel2指向同个对象时才为true,可以将其重写为:当x和y坐标相等时两个对象即相等,这样更有意义一些。
cell1.equals( cell2);
如何重写 equals方法
public boolean equals(Object obj){
if(obj==null){
return false;
}
if (this== obj){
return true;
}
if(obj instanceof Cell){
Cell cell = (Cell)obj;
return cell.row== row && cell.col ==col;
} else {
return false;
}
}
String重写equals方法
String的equals方法用于比较两个字符串对象的字符序列是否相等。
/**测试字符串的比较*/
public class Demo{
public static void main(String[] args) {
String s1=new String("abc") ;
String s2=new String("abc") ;
String s3=new String("A") ;
System.out.println(s1.equals(s2) ; //true
System.out.println(s1.equals(s3) ) ; //false
}
}
equals和==的区别
==用于比较变量的值,可以应用于任何类型,如果用于引用类型,比较的是两个引用变量中存储的值(地址信息),判断两个变量是否指向相同的对象;
equals是Object的方法, 重写以后, 可以用于比较两个对象的内容是否“相等”需要注意的是, Object默认的equals方法的比较规则同==