Java基础之字符串

字符串

字符串的特点：

• 字符串的内容用不可变

• 正是因为字符串不可改变，所以字符串是可以共享使用的

• 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

创建字符串的3+1种方法

1. public String() 创建一个空白字符串，不含有任何内容

2. public String(char[] array) 根据字符数组的内容，来创建对应的字符串

3. public String(byte[] array) 根据字节数组的内容，来创建字符串

package com.dcits.day07.demo01;
​
public class Demo01String {
    public static void main(String[] args) {
        // 使用空参构造
        String str1 = new String();
        System.out.println(str1);
        // 根据字符数组创建
        char[] charArray = {'a','b','c'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串" + str2);
        // 根据字节数组串讲
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println(str3);
        // 直接创建
        String str4 = "hello";
        System.out.println(str4);
    }
}

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说，==是进行数值的比较

对于引用来说，==是进行地址的比较

字符串中的方法：

1.equals

package com.dcits.day07.demo02;
​
public class Demo01Equals {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        char[] array = {'h','e','l','l','o'};
        String str3 = new String(array);
​
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("hello"));
        System.out.println("hello".equals(str1));
    }
}

2.public int length() 获取字符串中含有的字符个数，拿到字符串的长度

3.public String concat(String str) 将当前字符串和参数字符串拼接成为返回值新得字符串

4.public char charAt(int index) 获取索引位置的单个字符。（索引从0开始）

5.public int indexof(string str) 查找参数字符串在本地字符串当中首次出现的索引位置，如果没有返回-1值

package com.dcits.day07.demo02;
​
public class Demo02StringGet {
    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "zczxcasadsadadsad".length();
        System.out.println("字符串的长度：" + length);
​
        // 拼接字符串
        String str1 = "hello";
        String str2 = "world";
        String str3 = str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        
        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);
​
​
        // 查找参数字符串在本来字符串当中出现的第一次索引位置
        // 如果根本没有，就返回 -1 值
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次的索引值是：" + index);
​
        System.out.println("HelloWOrld".indexOf("abc"));
    }
}

6.public String substring(int index) 截取从参数位置一直到字符串末尾，返回新字符串

public String substring(int begin,int end) 截取从begin开始，一直到end结束，中间的字符串

注意： [begin,end) 包含左边，不包含右边

package com.dcits.day07.demo02;
​
public class Demo03Substring {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);
        System.out.println(str2);
        
        String str3 = str1.substring(4,7);
        System.out.println(str3);
        
        String strA = "Hello";
        System.out.println(strA);
        strA = "Java";
        System.out.println(strA);
        
    }
}

7.public char[] toCharArray() 将当前字符串拆分为字符数组作为返回值

public byte[] getBytes() 获得当前字符串底层的字节数组

public String replace(CharSequence oldString,CharSequence newString) 将所有出现的老字符串替换成为新的字符串 ，返回替换之后的结果新字符串

注意：CharSequence意思就是说可以接受字符串类型

package com.dcits.day07.demo02;
​
public class Demo04Convert {
    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);
​
        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
​
        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str1);
        System.out.println(str2);
​
        String lang1 = "会不会玩呀，你大爷的！";
        String lang2 = lang1.replace("你大爷的","****");
        System.out.println(lang2);
    }
}

8.public String[] split(String regex) 按照参数的规则，将字符串切分成为若干部分

注意：split方法的参数其实是一个“正则表达式”，如果按照英文句点进行切割，需要写成 \.

package com.dcits.day07.demo02;
​
public class Demo05Split {
    public static void main(String[] args) {
        String str1 = "aa,bbb,ccc,ddd";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
​
        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\.");
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
​
    }
}

静态static关键字

一旦使用了static关键字，那么这样的内容不再属于对象自己，而是属于类的，所以凡是本类的对象，都共享一份

一旦使用了static修饰成员方法，那么这就成为了静态方法，静态方法并不属于对象，而是属于类的。对于静态方法来说可以进行对象名来调用，也可以直接通过类名称调用

无论是成员变量还是成员方法，如果有了static，都推荐使用类名称进行调用。

• 静态变量：类名称.静态变量

• 静态方法：类名称.静态方法

注意：

1. 静态不能直接访问非静态

2. 静态方法中不能使用this

// 类
package com.dcits.day07.demo03;
​
public class myClass {
    int age;
    static String name;
    public void method() {
        System.out.println("这是一个普通的成员方法");
        // 成员方法可以访问静态变量
        System.out.println(age);
        System.out.println(name);
    }
    public static void methodStatic() {
        System.out.println("这是一个静态方法");
        System.out.println(name);
        // 静态方法不能访问成员变量
        System.out.println(age);
    }
}
// 调用
package com.dcits.day07.demo03;
​
public class Demo02StaticMethod {
    public static void main(String[] args) {
        myClass obj = new myClass();
        obj.method();
​
        // 对于静态方法来说可以进行对象名来调用，也可以直接通过类名称调用
        myClass.methodStatic();
        // 不推荐
        obj.methodStatic();
        // 对于本类中的静态方法，可以省略类名称
        myMethod();
    }
    public static void myMethod() {
        System.out.println("自己的方法");
    }
​
}
​

静态内存图：

静态代码块

特点：当第一次用到本类时，静态代码块执行唯一的一次，静态代码块比构造方法先执行

// Person类
package com.dcits.day07.demo03;
​
public class Person {
    // 静态代码块的内容
    static {
        System.out.println("静态代码块执行！！");
    }
    public Person () {
        System.out.println("构造方法执行啦！");
    }
}
// 调用
package com.dcits.day07.demo03;
​
public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}
// 静态代码块执行！！
// 构造方法执行啦！
// 构造方法执行啦！

数组工具类Arrays

注意：

• 排序时，如果是数值，sort默认按照从小到大，

• 如果是字符串，sort默认按照字母升序

• 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

package com.dcits.day07.demo04;
​
import java.util.Arrays;
​
public class Demo01Arrays {
    public static void main(String[] args) {
        // Arrays中的默认格式转换成为字符串
        int[] Array = {10,20,30};
        String intStr = Arrays.toString(Array);
        System.out.println(intStr);
        
        // Arrays中的排序方法
        int[] array1 = {2,6,1,3,5};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
​
        String[] array2 = {"bbb","aaa","ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

数学工具类

package com.dcits.day07.demo04;
​
public class Demo03Math  {
    public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(-2.1));
​
        // 向上取整
        System.out.println(Math.ceil(3.1));
​
        // 向下取整
        System.out.println(Math.floor(3.9));
​
        // 四舍五入
        System.out.println(Math.round(20.5));
        System.out.println(Math.round(3.33));
​
        // Π
        System.out.println(Math.PI);
​
​
    }
}