JAVA_SE API文档 字符串基本操作 正则表达式 Object

本文已参与「新人创作礼」活动，一起开启掘金创作之路。 ​

 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 ="[email protected]";
		/*
		 * 验证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方法的比较规则同==

​