day005_String类

String字符串

1. String类的介绍

　　java.lang.String类: 用来描述的字符串的
　　Java 程序中的所有字符串字面值(字符串常量)（如 "abc" ）都作为此类的实例实现(对象)。

字符串是常量；它们的值在创建之后不能更改(但凡是你感觉它要变化的时候,其实都是创建了一个新的字符串)。

　　String类的对象的体现形式:
　　　　1.所有双引号""引起来的内容,都是String类的对象,都可以调用String类中定义的方法
　　　　2.和前面一样,使用new关键字创建String类的对象

1.1 String类的判断方法

//- public boolean equals(Object anObject)
  //将此字符串(调用分的对象)与指定对象(传递给方法的参数)进行比较内容是否相同, 区分大小写。
  //举例: s1.equals(s2):比较s1和s2的内容是否一模一样,如果一样返回true,否则返回false
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = "abc";
String s3 = new String("abc");
String s4 = "Abc";
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s1.equals(s4));
System.out.println(s2.equals(s3));
System.out.println(s2.equals(s4));
System.out.println(s3.equals(s4));
System.out.println("----------------------");

//- public boolean equalsIgnoreCase (String anotherString) ：
  //将此字符串与指定对象进 行比较内容是否相同，忽略大小写。
  //举例:s1.equalsIgnoreCase(s2):比较s1和s2的内容是否相同,但是不区分大小写
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println(s1.equalsIgnoreCase(s4));
System.out.println(s2.equalsIgnoreCase(s3));
System.out.println(s2.equalsIgnoreCase(s4));
System.out.println(s3.equalsIgnoreCase(s4));
System.out.println("----------------------");

//- public boolean contains(String str) : 当且仅当此字符串包含指定的str时，返回 true。
  //举例:s1.contains(s2): s1中包含s2,返回true,不包含返回false
System.out.println("Hello World".contains("Hello"));
System.out.println("Hello World".contains("hello"));
System.out.println("Hello World".contains("World"));
System.out.println("Hello World".contains("world"));
System.out.println("----------------------");

//- public boolean startsWith(String str) : 判断调用方法的字符串是否以参数字符串开头
  //举例:s1.startsWith(s2): s1以s2开头,返回true,否则返回false
System.out.println("Hello World".startsWith("Hello"));
System.out.println("Hello World".startsWith("hello"));

//- public boolean endsWith(String str) : 判断调用方法的字符串是否以参数字符串结尾
  //举例:s1.endsWith(s2): s1以s2结尾,返回true,否则返回false
System.out.println("Hello World".endsWith("World"));
System.out.println("Hello World".endsWith("world"));

1.2 String类的获取方法

//- public int length () ：返回此字符串的长度。
  //举例:s.length() 获取s中的字符的数量
System.out.println("".length());
System.out.println("Hello World".length());

//- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
  //举例:s1.concat(s2) 把s2连接到s1的末尾 等价于 s1 += s2
String s1 = "Hello ";
String s2 = "World";
String s3 = s1.concat(s2);
System.out.println("s1:"+s1+"  s3:"+s3);

//- public char charAt (int index) ：返回指定索引处的 char值。
  //举例:s1.charAt(5) 获取s1中索引为5的字符
String s4 = "abc";
System.out.println(s4.charAt(0)); //a
System.out.println(s4.charAt(1)); //b
System.out.println(s4.charAt(2)); //c
System.out.println(s4.charAt(s4.length()-1)); //c

//- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
  //举例:s1.indexOf(s2) 查找s2在s1中第一次出现的位置,如果不存在,返回-1
String s5 = "Hello World";
System.out.println(s5.indexOf("hello")); //-1
System.out.println(s5.indexOf("Hello")); //0
System.out.println(s5.indexOf("world")); //-1
System.out.println(s5.indexOf("World")); //6

//- public String substring (int beginIndex) ：
  //返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
  //举例:s1.substring(5) 截取s1字符串从索引5开始一直到最后的内容
String s6 = "HelloWorld!";
String s7 = s6.substring(5);
System.out.println(s7); //World!
//- public String substring (int beginIndex, int endIndex) ：
  //返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
  //举例:s1.substring(5,10) 截取s1字符串从索引5开始一直到索引10之间的内容(包含5,不包含10)
System.out.println(s6.substring(5,10)); //World
System.out.println(s6.substring(5,s6.length())); //World!

1.3 String转换功能的方法

//转换功能的方法
// - public char[] toCharArray () ：把字符串变成对应的字符数组。
//    举例:s1.toCharArray() 把s1变成字符数组
String s1 = "abc";
char[] chs = s1.toCharArray();
System.out.println("字符串长度: " + s1.length());
System.out.println("字符数组长度: " + chs.length);
//遍历字符数组
for (int i = 0; i < chs.length; i++) {
    System.out.println(chs[i]);
}

// - public byte[] getBytes () ：把字符串变成对应的字节数组。
//    举例:s1.getBytes() 把s1变成字节数组
byte[] bs = s1.getBytes();
System.out.println("字符串长度: " + s1.length());
System.out.println("字节数组长度: " + bs.length);
//遍历字节数组
for (int i = 0; i < bs.length; i++) {
    System.out.println(bs[i] + "<------>" + (char) bs[i]);
}

// - public String replace (String oldStr, String newStr) ：
//    把字符串中的所有的oldStr替换成newStr。
//    举例:s1.replace("a","A") 把s1中的所有的"a"替换成"A"
String s2 = "abacad";
s2 = s2.replace("a","A");
System.out.println(s2);


String s3 = "Hello World";
// - public String toUpperCase(): 把字符串变成对应的大写字符串
//    举例: s1.toUpperCase() 把s1变成大写字符串
System.out.println(s3.toUpperCase());//HELLO WORLD

// - public String toLowerCase(): 把字符串变成对应的小写字符串
//    举例: s1.toLowerCase() 把s1变成小写字符串
System.out.println(s3.toLowerCase());//hello world
System.out.println(s3);//Hello World

1.4 String分割方法

/*
    "aa bb cc dd"
    分割功能的方法
        - public String[] split(String regex) ：
            将此字符串按照给定的regex（规则）拆分为字符串数组
            举例:
                String[] "a,b,c,d".split(",")
                    把"a,b,c,d"按照逗号切割,将切割后的多个子字符串存入String[] 中
 */
String s1 = "aa bb cc dd";
String[] array = s1.split(" ");
System.out.println("切割出多个个字符串: " + array.length);
//遍历字符串数组
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}
System.out.println("----------");
String s2 = "java,c++,python,android";
array = s2.split(",");
System.out.println("切割出多个个字符串: " + array.length);
//遍历字符串数组
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}
System.out.println("----------");
String ip = "192.168.1.100";
/*
    split方法中的字符串是正则表达式(一种特殊字符串)
    在正则表达式中句点.具有特殊含义: 代表任意一个字符
    实际上:
        需要按照普通的句点.切割,需要写\\.
 */
//array = ip.split(".");
array = ip.split("\\.");
System.out.println("切割出多个个字符串: " + array.length);
//遍历字符串数组
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);

}

2. String 创建字符串对象两种方式的区别

通过构建方法创建：
- 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同。
- 只要是new的，内存地址值一定不相同。保存在堆内存中。
- 堆内存中new出来的String（"abc"）：它会先去常量池中看有没有 "abc"常量对象，如果有就把常量池中的地址值赋给堆内存中new 的String对象。没有就创建一个在赋值给new 的 String 对象。
直接复制方法创建：
- 以 "" 方式的字符串，只要字符序列相同（顺序和大小写），无论在代码中出现几次，JVM都只会建立一个 String 对象，并在字符串池中维护。
- "" ：保存在常量池中的字符串常量对象.

2.1 == 和 equals 的区别：

==比较基本数据类型：比较的是具体的值。
==比较引用数据类型：比较的是对象地址值。
equals：比较的是具体的值。
- 　equals 方法的内部原理，优先判断如果参数不是String类型，直接返回false。

// 判段以下输出结果，true 或 false
// 
char[] chs = {'a','b','c'};
String s1 = new String(chs);
String s2 = new String(chs);
String s3 = "abc";
String s4 = "abc";

System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // true
System.out.println(s3.equals(s4)); // true

// equals 方法的内部原理，优先判断如果参数不是String类型，直接返回false
System.out.println(s3.equals(chs)); // false

System.out.println("------------");
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
System.out.println(s3 == s4); // true

2.2 String字符串常量与变量拼接的区别

s2是变量，JVM在编译期间无法确定最终结果。
在使用 + 进行字符串拼接时，只要+左右两边出现了字符串变量，那就相当于new
+ 中有字符串变量进行拼接时，内部使用 StringBuilder 完成字符串拼接后，再把 StringBuilder 通过 new String 的方法，转换成String对象。

String s1 = "abc";
String s2 = "ab";
String s3 = s2 + "c";
System.out.println(s1 == s3); // false
System.out.println(s1.equals(s3)); // true

3. StringBuffer类

        StringBuffer buffer = new StringBuffer();
        // 添加 StringBuffer append(类型 b)
        buffer.append("寒鸦少年,");
        System.out.println(buffer); // 寒鸦少年,

        String str3 = "华晨宇的疯人院！";
        // 添加 StringBuffer append(类型 s, int start(开始长度), int end(结束长度不包含最后一个字符))
        buffer.append(str3,4,7);
        System.out.println(buffer);  // 寒鸦少年,疯人院

        // StringBuffer deleteCharAt(int index)删除指定的元素
        StringBuffer delete = buffer.deleteCharAt(4);
        System.out.println(delete);  // 寒鸦少年疯人院
        // StringBuffer delete(int start, int end) 删除指定长度的字符串
        delete.delete(4,7);
        System.out.println(delete); //  寒鸦少年


        StringBuffer str = new StringBuffer("斗牛、我管你、斗山海子、孩子");
        // char    charAt(int index)  获取0元素的字符
        System.out.println(str.charAt(0));  // 斗
        // int    indexOf(String str) 获取字符的索引
        System.out.println(str.indexOf("斗"));  // 0
        // int    indexOf(String str, int fromIndex) 在下标为5的字符出后面，找出第一个字符为"斗"的字符返回下标
        System.out.println(str.indexOf("斗",5));  // 7
        // int    lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
        System.out.println(str.lastIndexOf("子"));  // 13


        StringBuffer str1 = new StringBuffer("-华晨宇");
        // StringBuffer    insert(int offset, String str) 插入字符串
        System.out.println(str1.insert(0, "平凡之路"));  //  平凡之路-华晨宇
        // StringBuffer    reverse()  该字符序列被序列的相反代替。
        System.out.println(str1.reverse());  // 宇晨华-路之凡平
        //int length() 返回长度（字符数）。
        System.out.println(str1.length());  // 8

        StringBuffer str4 = new StringBuffer("华晨宇的我管你!");
        // StringBuffer    replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
        System.out.println(str4.replace(4,7,"南屏晚钟")); // 华晨宇的南屏晚钟!
        // String    substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。
        String substring = str4.substring(4);
        System.out.println(substring);  // 南屏晚钟!
        System.out.println(str4.substring(4,8)); // 南屏晚钟

        // void    setCharAt(int index, char ch) 指定索引处的字符设置为 ch 。
        System.out.println(str4);
        str4.setCharAt(8,'。');
        System.out.println(str4); // 华晨宇的南屏晚钟。

posted @ 2022-05-29 11:17 Amoヽ柠檬阅读(46) 评论(0) 收藏举报

刷新页面返回顶部

Amoヽ柠檬