Java_String字符串类

  • 2020 年 09 月 26 日
  • 29次
  • 1057 字
  • 暂无评论

Java中的String字符串类的构造方法与常用方法

public class String字符串类 {
    public static void main(String[] args) {
        {
            // String 类的构造方法
            System.out.println("String类的构造方法:");
            
            byte[] b = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
            char[] c = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
            
            String s = new String();    // 构造一个空字符串对象
            System.out.println("构造一个空字符串对象 s = " + s);
            String sb_copy = new String("acb123");    // 构造一个非字符串对象
            System.out.println("构造一个非字符串对象:sb_copy = " + sb_copy);
            
            String sb = new String(b);    // 通过 byte 数组构造字符串对象
            System.out.println("通过 byte 数组构造字符串对象:sb = " + sb);
            String sb_sub = new String(b, 3, 2);    // 通过 byte 数组构造字符串对象并从第3(参数二)位开始至取出2(参数三)位
            System.out.println("通过 byte 数组构造字符串对象并从第3位(参数二)开始至取出2位(参数三):sb_sub = " + sb_sub);
            
            String sc = new String(c);    // 通过 char 数组构造字符串对象
            System.out.println("通过 char 数组构造字符串对象:sc = " + sc);
            String sc_sub = new String(c, 3, 2);    // 通过 char 数组构造字符串对象并从第3(参数二)位开始至取出2(参数三)位
            System.out.println("通过 char 数组构造字符串对象并从第3位(参数二)开始至取出2位(参数三):sc_sub = " + sc_sub);
            System.out.println();
        }
        {    
            // String 类方法
            System.out.println("String 类方法:");
            // String charAt(int index):取字符串中的某一个字符,其中的参数 index 指的是字符串中序数。字符串的充数从 0 开始到 length() - 1;
            String s = "0123456";
            System.out.println("从字符串中取出字符:s.charAt(3) = " + s.charAt(3));
            System.out.println();
            
            // int compareTo(String anothesString):对两个字符串进行对比,相等关系返回0;
            // 不相等时,从第0个字符开始比较,返回第一个不相等的字符差;
            // 另外,较长的字符串前端部分刚好是较短的字符串,返回它们的长度差
            String s1 = "abcdef";
            String s2 = "abc";
            String s3 = "abcDef";
            System.out.println("对两个字符串进行对比:s1.compareTo(s2) = " + s1.compareTo(s2));
            System.out.println("对两个字符串进行对比:s1.compareTo(s3) = " + s1.compareTo(s3));
            System.out.println();
            
            // String concat(String str):将该 String 对象与  str 连接在一起
            String s4 = "123";
            String s5 = "456";
            System.out.println("将该 String 对象与  str 连接在一起:s4.concat(s5) = " + s4.concat(s5));
            System.out.println();
            
            // boolean contenEquals(StringBuffer sb):将该 String 对象与 StringBuffer 对象 sb 进行比较
            String s6 = "123";
            StringBuffer sb = new StringBuffer("123");
            System.out.println("将该 String 对象与 StringBuffer 对象 sb 进行比较:s6.contentEquals(sb) = " + s6.contentEquals(sb));
            System.out.println();
            
            // static String copyValueOf(char[] data, int offset, int count) 其中:int offset, int count可省略,省略即为 0 ~ data.length-1;
            // 将 char 数组转换成 String    , 通过 char 数组构造字符串对象类似
            char[] data = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
            System.out.println("将 char 数组转换成 String: String.copyValueOf(data) = " + String.copyValueOf(data));
            System.out.println("截取 char 数组中部分字符转换成 String: String.copyValueOf(data, 3, 7) = " + String.copyValueOf(data, 3, 7));
            System.out.println();
            
            // boolean endsWith(String suffix) 该 String 对象是否心 suffix 结尾
            String s7 = "123456";
            String suffix = "456";
            System.out.println("该 String 对象是否心 suffix 结尾:s7.endsWith(suffix) = " + s7.endsWith(suffix));
            System.out.println();
            
            // boolean equals(Object anObject):当 anObject 不为空并且与当前 String 对象一样时,返回 true ; 否则,返回 flase;
            String s8 = "abc";
            Object anObject = "abc";
            System.out.println("判该对象是否与 String 对象一样:" + s8.equals(anObject));
            System.out.println();
            
            // byte[] getBytes():将该 String 对象转换成 byte 数组
            String s9 = "abc123";
            byte[] b = s9.getBytes();
            System.out.print("将该 String 对象转换成 byte 数组:byte[] b = s9.getBytes() = ");
            for(byte by : b)
                System.out.print(by + " ");
            System.out.println();
            System.out.println();
            
            // void getChars(int srcBegin, int secEnd, char[] dst, int dstBegin):该方法将字符串复制到字符数组中。
            // 其中,srcBegin 为复制的起始位置(包括该位置的字符)、srcEnd 为复制的结束位置(不包括该位置的字符)
            // 字符串数值 dst 为目标字符数组、dstBegin 为目标字符数组复制的起始位置
            // Tips: 实际复制的字符串为:dst[srcBegin] ~ dst[srcEnd - 1]; 
            // 另:如果从 dst.length - 1 - dfsBegin(数组长度-起始位置=数组这段的容量) > srcEnd - 1 - srcBegin(即实际复制字符串的长度)
            char[] dst = new char[10];
            String src = "0123456789";
            int srcBegin = 1, srcEnd = 5, dstBegin = 5;
            src.getChars(srcBegin, srcEnd, dst, dstBegin);
            System.out.print("该方法将字符串复制到字符数组中:src.getChars(srcBegin, srcEnd, dst, dstBegin) = ");
            for(char ch : dst)
                System.out.print(ch + ",");
            System.out.println();
            System.out.println();
            
            // int hashCode():返回当前字符的哈希表码
            String hash = "00";
            System.out.println("返回当前字符的哈希表码:hash.hashCode() = " + hash.hashCode());
            System.out.println();
            
            // 查找字符
            // int indexOf(int ch):只找第一个匹配字符位置,注意这里是字符:a = 97
            int ch = 97;
            String s10 = "123321abccba";
            System.out.println("只找第一个匹配 字符 位置:s10.indexOf(ch) = " + s10.indexOf(ch));
            
            // int indexOf(int ch, int fromIndex):从 fromIndex 开始找第一个匹配字符的位置
            System.out.println("从第 7 位置开始找第一个匹配 字符 的位置:s10.indexOf(ch, 7) = " + s10.indexOf(ch, 7));
            System.out.println();
            
            // int indexOf(String str):只找第一个匹配 字符串 位置
            System.out.println("只找第一个匹配 字符串 位置:s10.indexOf(\"abc\") = " + s10.indexOf("a"));
            
            // int indexOf(String str, int fromInedex):从 fromIndex 开始找第一个
            System.out.println("从第 7 位置开始找第一个匹配 字符串 的位置:s10.indexOf(\"a\", 7) = " + s10.indexOf("a", 7));
            System.out.println();
            
            // int lastIndexOf(String str):找最后一个匹配的内容(即从后往前找)
            System.out.println("找最后一个匹配的内容(即从后往前找): "+ s10.lastIndexOf("a"));
            // int lastIndexOf(String str, int fromIndex):从 fromIndex 开始往前找最后一个匹配的内容
            System.out.println("找最后一个匹配的内容(即从后往前找): "+ s10.lastIndexOf("a", 10));
            System.out.println();
            
            // int length():返回当前字符串的长度
            System.out.println("返回当前字符串长度:s10.length() = " + s10.length());
            System.out.println();
            
            // String replace(char oldChar, char newChar);将字符串中 oldChar 全部替换成 newChar;
            System.out.println("将字符串中 a 全部替换成 A: s10.replace('a', 'A') " +  s10.replace('a', 'A'));
            System.out.println();
            
            // boolean startsWith(String prdfix):该 String 对象是否以 prefix 开始
            System.out.println("该 String 对象是否以 123 开始:s10.startsWith(\"123\") = " + s10.startsWith("123"));
            // boolean startsWith(String prefix, int toffset):该 String 对象从 toffset 位置算起,是否以 prefix 开始
            System.out.println("该 String 对象从第 3 位置算起,是否以 321 开始 + s10.startsWith(\"321\", 3) = " +  s10.startsWith("321", 3));
            System.out.println();
            
            // String substring(int beginIndex):取从 beginIndex 位置开始到结束的子字符串
            System.out.println("取从第 6 位置开始到结束的子字符串:s10.substring(6) = " + s10.substring(6));
            // String substring(int beginIndex, int endIndex):取从 beginIndex 位置开始到 endIndex 位置的子字符串
            System.out.println("取从 6 位置开始到 9 位置的子字符串:" + s10.substring(6, 9));
            System.out.println();
            
            // char[] toCharArray():将该 String 对象转换成 char 数组
            char [] c = s10.toCharArray();
            System.out.println("将该 String 对象转换成 char 数组:char [] c = s10.toCharArray() = ");
            for(char cha : c)
                System.out.print(cha + ", ");
            System.out.println();
            System.out.println();
            
            // String toLowerCase():将字符串转换成小写
            System.out.println("将字符串转换成小写:\"ABCDEF\".toLowerCase() = " + "ABCDEF".toLowerCase());
            
            // String toUppCase():将字符串转换成大写
            System.out.println("将字符串转换成小写:\"abcdef\".toUppCase() = " + "abcdef".toUpperCase());
        }
    }
}

运行结果:

String字符串类.jpg

如有错误请留言,非常感谢。


版权属于:Houzi0

本文链接:https://houzi0.com/archives/8.html



—— 暂无评论 ——

OωO