Java—API/Obiect类的equals toString方法/String类/StringBuffer类/正则表达式

API 

　　Java 的API（API: Application(应用) Programming(程序) Interface(接口)）　　就是JDK中提供给我们使用的类，这些类将底层的代码实现封装了起来

 Object类

　　Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。

 

equals方法

　　equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。

　　例如：

/*
     描述人这个类，并定义功能根据年龄判断是否是同龄人
     由于要根据指定类的属性进行比较，这时只要覆盖Object中的equals方法
     在方法体中根据类的属性值进行比较
 */
class Person extends Object{
    int age ;
    //复写父类的equals方法，实现自己的比较方式
    public boolean equals(Object obj) {
        //判断当前调用equals方法的对象和传递进来的对象是否是同一个
        if(this == obj){
            return true;
        }
        //判断传递进来的对象是否是Person类型
        if(!(obj instanceof Person)){
            return false;
        }
        //将obj向下转型为Perosn引用，访问其属性
        Person p = (Person)obj;
        return this.age == p.age;
    }
}

 

　　注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。

 

toString方法

　　toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

 

　　由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

class Person extends Object{
    int age ;
    //根据Person类的属性重写toString方法
    public String toString() {
        return "Person [age=" + age + "]";
    }
}

 

String类

//演示字符串
String str  = "oracle";
str = "甲骨文";

　　String 类代表字符串，而字符串是常量，它们的值在创建之后不能更改，一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。

　　字符串的本质是一个字符的数组。

 

　　通过使用双引号的方式创建对象与new的方式创建对象，有什么不同呢？

String s3 = "abc";
String s4 = new String("abc");
System.out.println(s3==s4);//false ==比较地址值
System.out.println(s3.equals(s4));//true, equals比较属性值
//因为String重写了equals方法，建立了字符串自己的判断相同的依据（通过字符串对象中的字符来判断）

 

　　s3创建，在内存中只有一个对象。这个对象在字符串常量池中

　　s4创建，在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中

String类构造方法

String s1 = new String(); //创建String对象，字符串中没有内容
    
    byte[] bys = new byte[]{97,98,99,100};
    String s2 = new String(bys); // 创建String对象，把数组元素作为字符串的内容
    String s3 = new String(bys, 1, 3); //创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素
    
    char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};
    String s4 = new String(chs); //创建String对象，把数组元素作为字符串的内容
    String s5 = new String(chs, 0, 3);//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素

    String s6 = new String(“abc”); //创建String对象，字符串内容为abc

String方法

 char charAt(int index)
          返回指定索引处的 char 值。
 int codePointAt(int index)
          返回指定索引处的字符（Unicode 代码点）。
 int codePointBefore(int index)
          返回指定索引之前的字符（Unicode 代码点）。
 int codePointCount(int beginIndex, int endIndex)
          返回此 String 的指定文本范围中的 Unicode 代码点数。
 int compareTo(String anotherString)
          按字典顺序比较两个字符串。
 int compareToIgnoreCase(String str)
          按字典顺序比较两个字符串，不考虑大小写。
 String concat(String str)
          将指定字符串连接到此字符串的结尾。
 boolean contains(CharSequence s)
          当且仅当此字符串包含指定的 char 值序列时，返回 true。
 boolean contentEquals(CharSequence cs)
          将此字符串与指定的 CharSequence 比较。
 boolean contentEquals(StringBuffer sb)
          将此字符串与指定的 StringBuffer 比较。
static String copyValueOf(char[] data)
          返回指定数组中表示该字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)
          返回指定数组中表示该字符序列的 String。
 boolean endsWith(String suffix)
          测试此字符串是否以指定的后缀结束。
 boolean equals(Object anObject)
          将此字符串与指定的对象比较。
 boolean equalsIgnoreCase(String anotherString)
          将此 String 与另一个 String 比较，不考虑大小写。
static String format(Locale l, String format, Object... args)
          使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
static String format(String format, Object... args)
          使用指定的格式字符串和参数返回一个格式化字符串。
 byte[] getBytes()
          使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
 byte[] getBytes(Charset charset)
          使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
 void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
          已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 getBytes() 方法，该方法使用平台的默认字符集。
 byte[] getBytes(String charsetName)
          使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
          将字符从此字符串复制到目标字符数组。
 int hashCode()
          返回此字符串的哈希码。
 int indexOf(int ch)
          返回指定字符在此字符串中第一次出现处的索引。
 int indexOf(int ch, int fromIndex)
          返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
 int indexOf(String str)
          返回指定子字符串在此字符串中第一次出现处的索引。
 int indexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
 String intern()
          返回字符串对象的规范化表示形式。
 boolean isEmpty()
          当且仅当 length() 为 0 时返回 true。
 int lastIndexOf(int ch)
          返回指定字符在此字符串中最后一次出现处的索引。
 int lastIndexOf(int ch, int fromIndex)
          返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
 int lastIndexOf(String str)
          返回指定子字符串在此字符串中最右边出现处的索引。
 int lastIndexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
 int length()
          返回此字符串的长度。
 boolean matches(String regex)
          告知此字符串是否匹配给定的正则表达式。
 int offsetByCodePoints(int index, int codePointOffset)
          返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
          测试两个字符串区域是否相等。
 boolean regionMatches(int toffset, String other, int ooffset, int len)
          测试两个字符串区域是否相等。
 String replace(char oldChar, char newChar)
          返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
 String replace(CharSequence target, CharSequence replacement)
          使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
 String replaceAll(String regex, String replacement)
          使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
 String replaceFirst(String regex, String replacement)
          使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
 String[] split(String regex)
          根据给定正则表达式的匹配拆分此字符串。
 String[] split(String regex, int limit)
          根据匹配给定的正则表达式来拆分此字符串。
 boolean startsWith(String prefix)
          测试此字符串是否以指定的前缀开始。
 boolean startsWith(String prefix, int toffset)
          测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
 CharSequence subSequence(int beginIndex, int endIndex)
          返回一个新的字符序列，它是此序列的一个子序列。
 String substring(int beginIndex)
          返回一个新的字符串，它是此字符串的一个子字符串。
 String substring(int beginIndex, int endIndex)
          返回一个新字符串，它是此字符串的一个子字符串。
 char[] toCharArray()
          将此字符串转换为一个新的字符数组。
 String toLowerCase()
          使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
 String toLowerCase(Locale locale)
          使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
 String toString()
          返回此对象本身（它已经是一个字符串！）。
 String toUpperCase()
          使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 String toUpperCase(Locale locale)
          使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
 String trim()
          返回字符串的副本，忽略前导空白和尾部空白。
static String valueOf(boolean b)
          返回 boolean 参数的字符串表示形式。
static String valueOf(char c)
          返回 char 参数的字符串表示形式。
static String valueOf(char[] data)
          返回 char 数组参数的字符串表示形式。
static String valueOf(char[] data, int offset, int count)
          返回 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 参数的字符串表示形式。
static String valueOf(Object obj)
          返回 Object 参数的字符串表示形式。

StringBuffer类

　　StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

StringBuffer的方法

 StringBuffer append(boolean b)
          将 boolean 参数的字符串表示形式追加到序列。
 StringBuffer append(char c)
          将 char 参数的字符串表示形式追加到此序列。
 StringBuffer append(char[] str)
          将 char 数组参数的字符串表示形式追加到此序列。
 StringBuffer append(char[] str, int offset, int len)
          将 char 数组参数的子数组的字符串表示形式追加到此序列。
 StringBuffer append(CharSequence s)
          将指定的 CharSequence 追加到该序列。
 StringBuffer append(CharSequence s, int start, int end)
          将指定 CharSequence 的子序列追加到此序列。
 StringBuffer append(double d)
          将 double 参数的字符串表示形式追加到此序列。
 StringBuffer append(float f)
          将 float 参数的字符串表示形式追加到此序列。
 StringBuffer append(int i)
          将 int 参数的字符串表示形式追加到此序列。
 StringBuffer append(long lng)
          将 long 参数的字符串表示形式追加到此序列。
 StringBuffer append(Object obj)
          追加 Object 参数的字符串表示形式。
 StringBuffer append(String str)
          将指定的字符串追加到此字符序列。
 StringBuffer append(StringBuffer sb)
          将指定的 StringBuffer 追加到此序列中。
 StringBuffer appendCodePoint(int codePoint)
          将 codePoint 参数的字符串表示形式追加到此序列。
 int capacity()
          返回当前容量。
 char charAt(int index)
          返回此序列中指定索引处的 char 值。
 int codePointAt(int index)
          返回指定索引处的字符（统一代码点）。
 int codePointBefore(int index)
          返回指定索引前的字符（统一代码点）。
 int codePointCount(int beginIndex, int endIndex)
          返回此序列指定文本范围内的统一代码点。
 StringBuffer delete(int start, int end)
          移除此序列的子字符串中的字符。
 StringBuffer deleteCharAt(int index)
          移除此序列指定位置的 char。
 void ensureCapacity(int minimumCapacity)
          确保容量至少等于指定的最小值。
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
          将字符从此序列复制到目标字符数组 dst。
 int indexOf(String str)
          返回第一次出现的指定子字符串在该字符串中的索引。
 int indexOf(String str, int fromIndex)
          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
 StringBuffer insert(int offset, boolean b)
          将 boolean 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, char c)
          将 char 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, char[] str)
          将 char 数组参数的字符串表示形式插入此序列中。
 StringBuffer insert(int index, char[] str, int offset, int len)
          将数组参数 str 的子数组的字符串表示形式插入此序列中。
 StringBuffer insert(int dstOffset, CharSequence s)
          将指定 CharSequence 插入此序列中。
 StringBuffer insert(int dstOffset, CharSequence s, int start, int end)
          将指定 CharSequence 的子序列插入此序列中。
 StringBuffer insert(int offset, double d)
          将 double 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, float f)
          将 float 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, int i)
          将 int 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, long l)
          将 long 参数的字符串表示形式插入此序列中。
 StringBuffer insert(int offset, Object obj)
          将 Object 参数的字符串表示形式插入此字符序列中。
 StringBuffer insert(int offset, String str)
          将字符串插入此字符序列中。
 int lastIndexOf(String str)
          返回最右边出现的指定子字符串在此字符串中的索引。
 int lastIndexOf(String str, int fromIndex)
          返回最后一次出现的指定子字符串在此字符串中的索引。
 int length()
          返回长度（字符数）。
 int offsetByCodePoints(int index, int codePointOffset)
          返回此序列中的一个索引，该索引是从给定 index 偏移 codePointOffset 个代码点后得到的。
 StringBuffer replace(int start, int end, String str)
          使用给定 String 中的字符替换此序列的子字符串中的字符。
 StringBuffer reverse()
          将此字符序列用其反转形式取代。
 void setCharAt(int index, char ch)
          将给定索引处的字符设置为 ch。
 void setLength(int newLength)
          设置字符序列的长度。
 CharSequence subSequence(int start, int end)
          返回一个新的字符序列，该字符序列是此序列的子序列。
 String substring(int start)
          返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
 String substring(int start, int end)
          返回一个新的 String，它包含此序列当前所包含的字符子序列。
 String toString()
          返回此序列中数据的字符串表示形式。
 void trimToSize()
          尝试减少用于字符序列的存储空间。

 　　常用代码演示：

创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
sb.append("haha"); //添加字符串
sb.insert(2, "it");//在指定位置插入
sb.delete(1, 4);//删除
sb.replace(1, 4, "cast");//替换指定范围内的内容
String str = sb.toString();　　

　　注意：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己，所以说，StringBuffer它可以改变字符序列的长度和内容。

StringBuilder类

　　StringBuilder类，它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。

　　该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

　　如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

 

正则表达式

　　正则表达式（英语：Regular Expression，在代码中常简写为regex）。

　　正则表达式是一个字符串，使用单个字符串来描述、用来定义匹配规则，匹配一系列符合某个句法规则的字符串。

　　在开发中，正则表达式通常被用来检索、替换那些符合某个规则的文本。Pattern

正则表达式的匹配规则

　　正则表达式中明确区分大小写字母　　

　　正则表达式的语法规则：

　　字符：x

　　含义：代表的是字符x

　　例如：匹配规则为 "a\"，那么需要匹配的字符串内容就是 ”a”

　　字符：\\

　　含义：代表的是反斜线字符'\'

　　例如：匹配规则为"\\" ，那么需要匹配的字符串内容就是 ”\” 

　　字符：\t

　　含义：制表符

　　例如：匹配规则为"\t" ，那么对应的效果就是产生一个制表符的空间

 　　字符：\n

　　含义：换行符

　　例如：匹配规则为"\n"，那么对应的效果就是换行,光标在原有位置的下一行

　　字符：\r

　　含义：回车符

　　例如：匹配规则为"\r" ，那么对应的效果就是回车后的效果,光标来到下一行行首

 　　字符类：[abc]

　　含义：代表的是字符a、b 或 c

　　例如：匹配规则为"[abc]" ，那么需要匹配的内容就是字符a，或者字符b，或字符c的一个

　　字符类：[^abc]

　　含义：代表的是除了 a、b 或 c以外的任何字符

　　例如：匹配规则为"[^abc]"，那么需要匹配的内容就是不是字符a，或者不是字符b，或不是字符c的任意一个字符

　　字符类：[a-zA-Z]

　　含义：代表的是a 到 z 或 A 到 Z，两头的字母包括在内

　　例如：匹配规则为"[a-zA-Z]"，那么需要匹配的是一个大写或者小写字母

　　字符类：[0-9]

　　含义：代表的是 0到9数字，两头的数字包括在内

　　例如：匹配规则为"[0-9]"，那么需要匹配的是一个数字

 　　字符类：[a-zA-Z_0-9]   

　　含义：代表的字母或者数字或者下划线(即单词字符)

　　例如：匹配规则为" [a-zA-Z_0-9] "，那么需要匹配的是一个字母或者是一个数字或一个下滑线

　　预定义字符类：.

　　含义：代表的是任何字符

　　例如：匹配规则为" . "，那么需要匹配的是一个任意字符。如果，就想使用 . 的话，使用匹配规则"\\."来实现  xxxxx@qq.com

 　　预定义字符类：\d    \D

　　含义：代表的是 0到9数字，两头的数字包括在内，相当于[0-9]

　　例如：匹配规则为"\d "，那么需要匹配的是一个数字

　　 预定义字符类：\w    \W    

　　含义：代表的字母或者数字或者下划线(即单词字符)，相当于[a-zA-Z_0-9]

　　例如：匹配规则为"\w "，，那么需要匹配的是一个字母或者是一个数字或一个下滑线

 　　边界匹配器：^

　　含义：代表的是行的开头

　　例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容从[abc]这个位置开始, 相当于左双引号

 　　边界匹配器：$

　　含义：代表的是行的结尾

　　例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容以[0-9]这个结束, 相当于右双引号

　　边界匹配器：\b

　　含义：代表的是单词边界

　　例如：匹配规则为"\b[abc]\b" ，那么代表的是字母a或b或c的左右两边需要的是非单词字符([a-zA-Z_0-9])

 　　数量词：X? 

　　含义：代表的是X出现一次或一次也没有

　　例如：匹配规则为"a?"，那么需要匹配的内容是一个字符a，或者一个a都没有

 　　数量词：X*   

　　含义：代表的是X出现零次或多次

　　例如：匹配规则为"a*" ，那么需要匹配的内容是多个字符a，或者一个a都没有

 　　数量词：X+   

　　含义：代表的是X出现一次或多次

　　例如：匹配规则为"a+"，那么需要匹配的内容是多个字符a，或者一个a

 　　数量词：X{n}   

　　含义：代表的是X出现恰好 n 次

　　例如：匹配规则为"a{5}"，那么需要匹配的内容是5个字符a

 　　数量词：X{n,}

　　含义：代表的是X出现至少 n 次

　　例如：匹配规则为"a{5, }"，那么需要匹配的内容是最少有5个字符a

 　　数量词：X{n,m}

　　含义：代表的是X出现至少 n 次，但是不超过 m 次

　　例如：匹配规则为"a{5,8}"，那么需要匹配的内容是有5个字符a 到 8个字符a之间

 

posted @ 2020-07-10 18:00  01zh  阅读(304)  评论(0)  编辑  收藏  举报