Notes 20180312 : String第四讲_String上的操作

　　作为一个基本的工具类,同时又是使用频率很高的类,Java为其提供了丰富的方法支持。Java中的String类中包含了50多个方法。最令人惊讶的是绝大多数方法都很有用，下面我们根据功能来分类介绍一下：

1. 关于码点的方法

　　在昨天我们探讨了一下码点，其中也详细叙述了码点的方法，这里我就不再赘述，只追加出来：

int codePointAt(int index)　　返回指定索引处的字符（Unicode代码点）。 IndexOutOfBoundsException
int codePointBefore(int index)　　返回指定索引之前的字符（Unicode代码点）。 IndexOutOfBoundsException
int codePointCount(int beginIndex, int endIndex)　　返回此 String指定文本范围内的Unicode代码点数。IndexOutOfBoundsException
int offsetByCodePoints(int index, int codePointOffset) 返回此 String内的指数，与 index codePointOffset代码点。IndexOutOfBoundsException

2. 字符串的长度

　　String中提供了两个方法用于获取长度,关于这两个方法,前面介绍码点时,也介绍过,不在详细说了;

int length() 返回此字符串的长度(码点单元数量)。
int codePointCount(int beginIndex, int endIndex)　　返回此 String指定文本范围内的Unicode代码点数。IndexOutOfBoundsException

3. 提高效率的一个方法String.intern()

　　是在不知道该怎么介绍该方法,所以取了这么个名字,该方法本人在另一篇文章中详细说过,参见之;

4. 根据给定条件查询字符串

　　Java中针对数组提供了两种查询方式,一种是根据已知的索引查询该位置的代码单元,一种是根据已知的字符查询索引位置,下面我们来看看:

4.1 根据字符查询索引

　　根据字符来查询对应索引,String提供了8个这样的方法,这8个方法不会出现索引越界的异常,查询不到会返回-1,这8个方法分为正向查找(indexOf)和反向查找(lastIndexOf);

　 indexOf(int ch)　　返回指定字符第一次出现的字符串内的索引。
indexOf(int ch, int fromIndex)　　返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
indexOf(String str)　　返回指定子字符串第一次出现的字符串内的索引。
indexOf(String str, int fromIndex)　　返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
lastIndexOf(int ch)　　返回指定字符的最后一次出现的字符串中的索引。
lastIndexOf(int ch, int fromIndex)　　返回指定字符的最后一次出现的字符串中的索引，从指定的索引(包含)开始向后搜索。
lastIndexOf(String str)　　返回指定子字符串最后一次出现的字符串中的索引。
lastIndexOf(String str, int fromIndex)　　返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。

/**
     * 根据给定信息查询字符串
     */
    @Test
    public void fun3(){
        String str1 = "归云一去无踪迹,何处是前期?";
        String str2 = "123242543534121214";
        System.out.println("字符一在字符串中的位置:"+str1.indexOf('一'));
        System.out.println("字符何从索引2开始寻找,索引是:"+str1.indexOf('何', 2));
        System.out.println("字符串何处的索引是:"+str1.indexOf("何处"));
        System.out.println("字符串何处的索引从给定索引找是:"+str1.indexOf("何处", 3));
        System.out.println("----"+str1.indexOf("何处", 9));//查找不到返回-1
        System.out.println("字符1最后一次出现的位置是:"+str2.lastIndexOf('1'));
        System.out.println("字符1从索引5开始反向寻找,最后一次出现的位置是:"+str2.lastIndexOf('2', 5));
        System.out.println("字符串12出现的最后位置:"+str2.lastIndexOf("12"));
        System.out.println("字符串12出现的最后位置,从给定的索引反向查询:"+str2.lastIndexOf("12", 15));
        System.out.println("如果lastIndexOf的参数是空字符串,那么返回的结果和求字符串长度是一样的:"+str2.lastIndexOf(""));
        System.out.println("字符串长度:"+str2.length());
        System.out.println("如果查询的在字符串中没有出现:"+str1.indexOf('1'));
        System.out.println("如果查询的在字符串中没有出现:"+str2.lastIndexOf("  "));
        String str = "jojjjjj";
        //查找指定字符在字符串中第一次出现的位置,若字符串中没有要查找的字符返回-1
        System.out.println("j第一次出现的位置是："+str.indexOf('。'));
        //返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。若字符串中没有要查找的字符返回-1
        System.out.println("o在脚标2后第一次出现的索引："+str.indexOf('o', 2));    
        System.out.println(str2.lastIndexOf(100));//索引越界不会异常,会返回负值-1 字符串中凡是查询不到那么就返回-1
    }

　　下面我们再看一个涉及到辅助字符的操作；

 String str3 = "𝕆is the set 𝕆is";
        System.out.println(str3.indexOf(105));//2
        System.out.println(str3.indexOf(56646));//1  查询辅助字符第二个代码单元
        System.out.println(str3.indexOf("𝕆"));// 0  占用了两个代码单元,所以给出了第一个代码单元的索引
        System.out.println(str3.indexOf("𝕆", 4));//13
        System.out.println(str3.lastIndexOf(56646));//14
        System.out.println(str3.lastIndexOf("𝕆"));//13
        System.out.println(str3.lastIndexOf("i", 15));//15
        System.out.println(str3.lastIndexOf(56646, 12));//1

4.2 根据给定字符查询索引

　　上面我们看过了给定字符查询索引，那么同样的我们也可以按照给定字符查询索引：

char charAt(int index) 返回 char指定索引处的值(字符)。

System.out.println(str3.charAt(0)+"___"+str3.charAt(1)+"____"+str3.charAt(2));//?___?____i

//       System.out.println(str3.charAt(1000));java.lang.StringIndexOutOfBoundsException: String index out of range: 1000

这段代码是对上面str3的再次测试,我们发现,针对辅助字符的查询是不能正常查询出来的

4.3 总结

　　根据给定索引查找字符,遇到辅助字符不能正常查询,并且会出现索引越界异常;
　　根据给定字符查询索引,不会出现越界异常,如果查询不到返回-1,可以完成对辅助字符的查询,如果给定辅助字符的给定代码单元,那么查询到该代码单元所在的位置,如果给定辅助字符,那么查询到该辅助字符的第一个辅助字符的第一个代码单元.按照从后向前查找的话,那么会从给定的索引开始查起,包含该索引;

5. 字符串的比较与判断

　　我们对于数据的操作往往是增删改查,而查往往是需要通过比较的,String中自然也提供了一系列用于比较的方法:

int compareTo(String anotherString)按字典顺序比较两个字符串。
int compareToIgnoreCase(String str)按字典顺序比较两个字符串，忽略大小写差异。
boolean contentEquals(CharSequence cs)　　将此字符串与指定的CharSequence进行 CharSequence 。区别大小写
boolean contentEquals(StringBuffer sb)　　将此字符串与指定的StringBuffer进行 StringBuffer 。区别大小写
boolean endsWith(String suffix)　　测试此字符串是否以指定的后缀结尾。
boolean equals(Object anObject)　　将此字符串与指定对象进行比较。
boolean equalsIgnoreCase(String anotherString)　　将此 String与其他 String比较，忽略案例注意事项。
boolean isEmpty()　　返回 true如果，且仅当 length()为 0 。
startsWith(String prefix)测试此字符串是否以指定的前缀开头。
startsWith(String prefix, int toffset)测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。
matches(String regex)　　告诉这个字符串是否匹配给定的 regular expression 。正则表达式
regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。可以给定参数判断是否考虑大小写
regionMatches(int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。
contains(CharSequence s)　　当且仅当此字符串包含指定的char值序列时才返回true。

/**
     * 按照字典书序比较两个字符串
     * 按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
     * 按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。
     * 如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
     * 如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
     * 如果这两个字符串相等，则结果为 0；
     * compareTo 只在方法 equals(Object) 返回 true 时才返回 0。 
     */
    @Test
    public void compareStrings(){
        String str1 = "𝕆is The set 𝕆is";
        String str2 = "𝕆is the est 𝕆is";
        System.out.println("比较两个字符串的字典顺序,考虑大小写:" + str1.compareTo(str2) );
        System.out.println("T:" + str1.codePointAt(5) + "--" + "t:" + str2.codePointAt(5));
        System.out.println("比较两个字符串的字典顺序,不考虑大小写:" + str1.compareToIgnoreCase(str2));
        System.out.println("s:" + str1.codePointAt(9) + "--" + "e:" + str2.codePointAt(9));
    }

@Test
    public void test(){
        String str = "绿黛红颜两相发,千娇百媚情无歇!";
        System.out.println("判断是否以字符串结尾:" + str.endsWith("情无歇."));
        System.out.println("判断是否以字符串结尾:" + str.endsWith("情无歇!"));
        System.out.println("判断是否以字符串开始:" + str.startsWith("绿黛红颜"));
        System.out.println("判断是在指定索引处是否以字符串开始:" + str.startsWith("千娇百媚", 3));
　　　　 System.out.println(str.contains("千娇百媚"));//true
    }

@Test
    public void test2(){
        String str1 = "aabbccdd";
        String str2 = "aabcccdd";
        String str3 = "aabbccdd";
        String str4 = "Aabbccdd";
        StringBuffer sb1 = new StringBuffer(str3);
        StringBuffer sb2 = new StringBuffer(str4);
        System.out.println(str1.contentEquals(str2));//false
        System.out.println(str1.contentEquals(str3));//true
        System.out.println(str1.contentEquals(str4));//false
        System.out.println(str1.contentEquals(sb1));//true
        System.out.println(str1.contentEquals(sb2));//false
　　　　 System.out.println(str1.equals(str3));//true
        System.out.println(str1.equals(str4));//false
        System.out.println(str1.equalsIgnoreCase(str4));//true

    }

    /**
     * 字符串非空判断
     */
    @Test
    public void test3(){
        String str1 = "aabcccdd";
        String str2 = "";
        String str3 = " ";
        String str4 = null;
        System.out.println(str1.isEmpty());
        System.out.println(str2.isEmpty());
        System.out.println(str3.isEmpty());
//        System.out.println(str4.isEmpty());空指针异常
        test4(str1);
        test4(str2);
        test4(str3);
        test4(str4);
    }
    public void test4(String str){
        //伪非空判断
        if(str == null || str.isEmpty()){
            System.out.println(str + "该字符串为空!");
        }
        //非空判断的真是操作
        if(str != null && !str.isEmpty()){
            System.out.println("str:"+str+"__"+"该字符串为空!");
        }
    }

@Test
    public void fun1(){
        String str1 = "aabbccdd";
        String str2 = "aabcccDd";
        System.out.println(str1.regionMatches(2, str2, 2, 2));//false
        System.out.println(str1.regionMatches(4, str2, 4, 2));//true
        System.out.println(str1.regionMatches(4, str2, 4, 3));//false
        System.out.println(str1.regionMatches(true, 4, str2, 4, 3));//true
        System.out.println(str1.regionMatches(false, 4, str2, 4, 3));//false
        System.out.println(str1.matches("\\p{Lower}{3,}"));//匹配出现至少3个小写字母  true
    }

6. 字符串的连接

　　前面我们讲过通过重载"+"可以将实现将两个对象连接到一起,并且返回一个字符串,底层是通过调用各自的toString和StringBuilder,String中除了重载"+",提供了另一种连接字符串的方法:

String concat(String str)将指定的字符串连接到该字符串的末尾。

package cn.charsequence.string.concat;

public class StringConcat {
    public static void main(String[] args) {
        String str1 = "23131";
        String str2 = "dsfa";
        String str3 = "";
        String str4 = null;
        System.out.println(str1.concat(str2));
        System.out.println(str1.concat(str3));
//        System.out.println(str1.concat(str4));注意不能和null在一起操作,否则会出现nullPointException
    }
}

7. 获取新字符串

　　获取新字符串是个很大的概念,之所以取这样一个名称,是因为我把很多通过一些的给定条件返回一个字符串的方法都放在这节来讲;

7.1 根据给定的字符数组得到String

　　String的底层是char[],

copyValueOf(char[] data)　　相当于 valueOf(char[]) 。
copyValueOf(char[] data, int offset, int count)　　相当于 valueOf(char[], int, int) 。

package cn.charsequence.string.getString;

public class CopyValueOf {
    public static void main(String[] args) {
        String str1 = "aaaa";
        char[] ch = {'b','b','b','b','b','b'};
        System.out.println(String.copyValueOf(ch));
        System.out.println(String.copyValueOf(ch, 2, 4));//小心IndexOutOf
        System.out.println(str1.copyValueOf(ch));//对象调用,那么不会考虑对象原有内容
        System.out.println(str1.copyValueOf(ch, 2, 4));
    }
}

7.2 通过字符序列获取字符串

　　String是字符序列,但是字符序列并不包含String这一种,而是很多种组成的,那么String就提供了一种方式,用于将不同的字符序列组成一个字符串,方法如下;

join(CharSequence delimiter, CharSequence... elements)　返回一个新的字符串，由 CharSequence elements的副本组成，并附有指定的delimiter的 delimiter 即以delimiter作为分隔符。
join(CharSequence delimiter, Iterable<? extends CharSequence> elements)　　返回一个新 String的副本组成 CharSequence elements与指定的副本一起加入 delimiter 。//该方法可以用于我们自己写的继承CharSequence的类,但是需要实现Iterable接口,因为该方法中有加强for循环.

package cn.charsequence.string.getString;

import java.util.ArrayList;import java.util.List;

public class CharSequenceToString{
    public static void main(String[] args) {
        StringBuffer sbf = new StringBuffer("我是StringBuffer!");
        StringBuilder sbi = new StringBuilder("我是StringBuilder!");
        String str = "__";
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        System.out.println(String.join(str, list));
        System.out.println(String.join(str, sbf,sbi,sbf));
    }

}

7.3 替换字符串中的内容

　　数据有增删改查,String自然也提供了"修改"的方法,实际上是构造一个新的char[],String的不可变并未因此发生改变。String提供了几个用于改变内容的方法如下：

replace(char oldChar, char newChar)　　返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。

replace(CharSequence target, CharSequence replacement)　　将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。

replaceAll(String regex, String replacement)　　用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

replaceFirst(String regex, String replacement)　　用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。

package cn.charsequence.string.replace;

import org.junit.Test;

public class ReplaceString {
    /**
     * 替换
     */
    @Test
    public void test1(){
        String str1 = "山中何所有 ，岭上多白 云。只可自怡悦，不堪持赠君。";
        StringBuilder sb = new StringBuilder("白云");
        System.out.println(str1.replace("白云", "黑云")+"_"+str1);
        System.out.println(str1.replace(sb, "黑云")+"_"+str1);
        System.out.println(str1.length());
        System.out.println(str1.replaceAll("\\s", "").length() + str1.replaceAll("\\s", ""));
        System.out.println(str1.replaceFirst("\\s", "").length() + str1.replaceAll("\\s", ""));
    }
}

7.4 子串获取

　　字符串提供了用于获取字符串中子串的方法，如下：

subSequence(int beginIndex, int endIndex) 　　返回一个字符序列，该序列是该序列的子序列。
substring(int beginIndex) 　　返回一个字符串，该字符串是此字符串的子字符串。
substring(int beginIndex, int endIndex) 　　返回一个字符串，该字符串是此字符串的子字符串。

7.5 截取字符串

split(String regex) 　　将此字符串分割为给定的 regular expression的匹配。
split(String regex, int limit) 　　将这个字符串拆分为给定的 regular expression的匹配。

8. 字符串的格式化

format(Locale l, String format, Object... args)

使用指定的区域设置，格式字符串和参数返回格式化的字符串。

format(String format, Object... args)

使用指定的格式字符串和参数返回格式化的字符串。

9. 字符串与字节数组的相互转换

getBytes()

使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。

getBytes(Charset charset)

使用给定的charset将该String编码为字节序列，将结果存储到新的字节数组中。

getBytes(String charsetName)

使用命名的字符集将此 String编码为字节序列，将结果存储到新的字节数组中。

10. String提供的其它方法

intern()

返回字符串对象的规范表示。

posted @ 2018-03-12 20:17 十月十四阅读(320) 评论(0) 收藏举报

刷新页面返回顶部

Abri

https://github.com/YorickYou/Notes.git