JAVA基础学习总结，day8(String 类,静态代码块,Arrays类:工具类,Math类:工具类)

最新推荐文章于 2022-07-22 23:17:15 发布

原创最新推荐文章于 2022-07-22 23:17:15 发布 · 201 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java基础 #string类 #静态代码块 #arrays类 #math类

java基础专栏收录该内容

24 篇文章

订阅专栏

本文深入讲解Java中的String类，涵盖其特性、构造方法、成员方法及应用实例，帮助读者掌握字符串操作技巧。

String 类:

1.包:java.lang 不需要导包

2.类的解释说明

概述:String 类代表字符串,Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的对象.

大白话:创建String类对象其实就是创建字符串对象,或者所有的字符串其实就是String类对象

特点:String 对象是不可变的，所以可以共享

3.构造方法

String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。
String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String(String original) 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

private static void method02() {
    // 根据构造方法来创建字符串对象
    String str1 = new String();// 创建了一个空字符串: ""

    // 通过byte数组来创建字符串对象  把byte数组转换为字符串
    byte[] bys = {97,98,99};
    String str2 = new String(bys);// "abc"
    System.out.println(str2);

    // 通过char数组来创建字符串对象  把字符数组转换为字符串
    char[] chs = {'a','b','c','d'};
    String str3 = new String(chs);
    System.out.println(str3);// "abcd"

    // 根据字符串创建一个字符串
    String str4 = "ABC";// 直接使用双引号创建字符串对象
    String str5 = new String("ABC");// 使用构造方法创建字符串对象
    System.out.println(str4);// "ABC"
    System.out.println(str5);// "ABC"
}

4.成员方法

判断功能的方法

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

总结: 2个字符串使用==比较运算符,比较的是地址值,如果使用的是equals方法,比较的是字符串内容是否相等

private static void method05() {
    String str1 = "abc";
    String str2 = "ABC";

    // equals方法  不忽略大小的比较
    boolean res1 = str1.equals(str2);
    System.out.println(res1);// false

    // equalsIgnoreCase  忽略大小的比较
    boolean res2 = str1.equalsIgnoreCase(str2);
    System.out.println(res2);// true
}

获取功能的方法

public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。拼接
public char charAt (int index) ：返回指定索引处的 char值。字符串中的每一个字符都有一个对应的索引,索引是从0开始,最大索引:长度-1
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。包括beginIndex
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex


private static void method06() {
    String str1 = "Hello World!";

    // 获取str1字符串的长度
    int len = str1.length();
    System.out.println("str1的长度是:"+len);//12

    // 拼接字符串
    String concat = str1.concat("Hello java!");
    System.out.println(concat);// Hello World!Hello java!
    System.out.println(str1);// Hello World!

    // 获取索引为1的字符
    char ch1 = str1.charAt(1);
    System.out.println("索引为1对应的字符是:"+ch1);// e

    // 获取倒数第二个字符  倒数第二个字符的索引:字符串长度-2
    char ch2 = str1.charAt(len - 2);
    System.out.println("倒数第二个字符是:"+ch2);// d
}

转换功能的方法

public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。重要
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

如果参数的类型CharSequence,就可以传入字符串对象

private static void method09() {
    String str = "Hello World!";
    // 把str转换为字符数组
    char[] chs = str.toCharArray();

    for (int i = 0;i<chs.length;i++){
        System.out.println(chs[i]);
    }

    System.out.println("=======================");
    // 把str转换为字节数组
    String str1 = "abcdefg";
    byte[] bytes = str1.getBytes();
    for (int i = 0;i<bytes.length;i++){
        System.out.println(bytes[i]);
    }

    // 把str1中的bcd替换成dcb
    String replace = str1.replace("bcd", "dcb");
    System.out.println(replace);// adcbefg
    System.out.println(str1);// abcdefg
}

分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

public static void main(String[] args) {

    // 特殊的地方
    String str1 = "hello.world.hello.java";

    //  需求:以点拆分str字符串
    String[] split = str1.split("\\.");// 告诉编译器这个点就是一个字符串点,并不是正则表达式的一种规则
    System.out.println(split.length);//4
    for (int i = 0;i<split.length;i++){
        System.out.println(split[i]);
    }

  // String[] split = str1.split(".");// 传入的参数regex,可能会是正则表达式  点是正则表达式中的一种规则,代表任意字符
  // System.out.println(split.length);//0

    System.out.println("======================");
    String str = "hello,world,hello,java";

    // 最基本的使用
    // 需求:以逗号拆分str字符串
    String[] arr = str.split(",");

    for (int i = 0;i<arr.length;i++){
        System.out.println(arr[i]);
    }

}

回家自己练习:

boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
boolean isEmpty() 当且仅当 length() 为 0 时返回 true。 “”
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String trim() 返回字符串的副本，忽略前导空白和尾部空白。
static String valueOf(int i) 返回 int 参数的字符串表示形式。 10+""–>“10”

static:静态的意思

static静态关键字
static可以用来修饰成员变量和成员方法

static修饰成员变量:

1.格式: static 数据类型成员变量名;

2.特点:被static修饰的成员变量会变成静态变量,静态变量不单单仅仅只是属于某一个对象的,而是属于类的,

所以静态变量会被该类的所有对象共享,也就是说所有该类的对象使用的是同一份数据

3.静态变量的访问方式:

对象名.静态成员变量名
类名.静态成员变量名推荐

static修饰成员方法

1.格式: 其实就是在定义方法的时候,在返回值类型前面加static关键字即可

        修饰符 static 返回值类型 方法名(参数列表){

             方法体

        }

2.静态成员方法访问方式:

对象名.静态方法名(实参);
类名.静态方法名(实参); 推荐

3.注意事项:

非静态方法中可以直接访问静态成员和非静态成员
静态方法中只能直接访问静态成员,不能直接访问非静态成员
静态方法中不能出现this
静态成员:包含静态成员变量和静态成员方法
非静态成员:包含非静态成员变量和非静态成员方法

static可以用来修饰代码块–>静态代码块

1.格式:

    static{

        代码

    }

2.- 位置：类中方法外。

3.- 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

第一次使用类的使用就会加载该类,并且只会加载一次


public class Demo4 {
    public static void main(String[] args) {
        // 创建一个Person类对象
        Person p1 = new Person();

        // 给p1对象的属性赋值
        p1.name = "张无忌";
        p1.age = 18;
        p1.country = "中国";

        // 姓名:张无忌,年龄:18,国籍:中国
        System.out.println("姓名:"+p1.name+",年龄:"+p1.age+",国籍:"+p1.country);

        // 类可以创建多个对象,多个对象之间是相互独立的
        Person p2 = new Person();

        // 姓名:null,年龄:0,国籍:中国
        System.out.println("姓名:"+p2.name+",年龄:"+p2.age+",国籍:"+p2.country);

        // 类名.静态成员变量名
        System.out.println(Person.country);// 中国

    }
}

Arrays类:工具类

1.包:java.util 导包

2.此类包含用来操作数组（比如排序和搜索）的各种方法

特点:

该类中的方法都是静态方法,所以可以直接使用类名.方法名(实参)调用

3.查看成员方法:

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。把数组转换为字符串
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

public class Demo7 {
    public static void main(String[] args) {

        // 请使用Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
        // 定义随机的字符串
        String line = "ysKUreaytWTRHsgFdSAoidq";

        // 先把字符串转换为字符数组
        char[] chs = line.toCharArray();

        // 对该数组进行升序排序
        Arrays.sort(chs);
        System.out.println(Arrays.toString(chs));// 排序之后的数组

        // 倒叙打印
        for (int i = chs.length-1;i>=0;i--){
            System.out.print(chs[i]+" ");
        }

    }

Math类:工具类

1.包:java.lang 不需要导包

2.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

特点:该类中的方法都是静态方法,所以可以直接使用类名.方法名(实参)调用

3.常用成员方法:

public static double abs(double a) ：返回 double 值的绝对值。
public static double ceil(double a) ：返回大于等于参数的最小的整数。
public static double floor(double a) ：返回小于等于参数最大的整数。
public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
static int max(int a, int b) 返回两个 int 值中较大的一个。
static int min(int a, int b) 返回两个 int 值中较小的一个。

    private static void method01() {
        // 获取绝对值
        double abs1 = Math.abs(3.14);
        double abs2 = Math.abs(-3.14);
        System.out.println(abs1);// 3.14
        System.out.println(abs2);// 3.14

        // 返回大于等于参数的最小的整数。
        double ceil1 = Math.ceil(3.14);
        System.out.println(ceil1);// 4.0

        // 返回小于等于参数的最大的整数
        double floor = Math.floor(3.14);
        System.out.println(floor);//3.0

        double floor2 = Math.floor(-3.14);
        System.out.println(floor2);//-4.0

        // 返回最接近参数的 long
        long round1 = Math.round(3.14);
        System.out.println(round1);//3

        long round2 = Math.round(3.54);
        System.out.println(round2);//4

        System.out.println(Math.max(10,20));//20
        System.out.println(Math.min(10,20));//10
    }
}