字符串，Static关键字 Arrays Math-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47044513/article/details/120158686

本文详细介绍了Java中String类的特点及创建方法，包括字符串常量池的概念，以及如何进行字符串的比较。同时讲解了Static关键字的作用，强调了静态成员的共享特性。接着探讨了Arrays类中的toString()和sort()方法，以及Math类中的数学运算方法。内容覆盖了字符串的比较、截取、替换，以及静态变量和静态代码块的使用等核心概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

String类型 java.lang.String类代表字符串

Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
其实也就是：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）
字符串特点：
1 字符串的内容永不变常量
2 正是因为字符串不可改变，所以字符串是可以共享使用的
3 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组
创建字符串的常见3+1种方案
三种构造方法
public String():创建一个空白字符串，不含有任何内容
public String(char[] array):根据字符数组的内容，来创建对应的字符串
public String(byte[] array):根据字节数组的内容，来创建对应的字符串
一种直接创建：String str = “Hello”
注意：直接写上双引号，就是字符串对象

例：

public static void main(String[] args) {
        //第一种方法
        String str1 = new String();//小括号留空，说明什么都没有
        System.out.println(str1);

        //根据字符数组创建字符串
        char [] array = {'A','B','C'};
        String st2 = new String(array);
        System.out.println(st2);

        //根据字节数组创建字符串
        byte [] byteArray = {97,98,99};
        String st3 = new String(byteArray);
        System.out.println(st3);

        //直接创建
        String st4 = "Hello";
    }
}

字符串的比较
字符串常量池，程序当中直接写上的双引号字符串，就在字符串常量池当中，new的不再常量池当中

对于基本类型来说，==是进行数值的比较
对于引用类型来说，==是进行【地址值】的比较

例：

 public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char [] charArray ={'a','b','c'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);  //true
        System.out.println(str1 == str3);  //false
        System.out.println(str2 == str3);  //false
    }
}

因为new的String是一个新的地址,但str1 str2 用的是同一个地址，所以为true，但是与str3不一样的地址，所以不同。

String字符串的内容比较：
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法

public boolean equals(Object obj):参数可以是任何对象，只是参数是一个字符串并且内容相同才会给true，否则就会返回false
注意事项：
1.任何对象都能被object进行接收
2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样
3.如果比较双方一个常量一个变量，推荐把字符串写在前面
推荐：“abc”.equals(str) 不推荐：str.equals(“abc”)
第二种方法：
public boolean equalsIgnoreCase(String str):忽略大小写，进行内容的比较

例：

 public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2)); //true
        System.out.println(str2.equals(str3)); //true
        System.out.println(str3.equals("Hello")); //true
        System.out.println("Hello".equals(str1)); //true
        System.out.println("hello".equals(str1)); //false


        System.out.println("=====================");

        String str5 = "abc";
        System.out.println("abc".equals(str5)); //推荐
        System.out.println(str5.equals("abc")); //不推荐
        //虽然结果一样但是如果为Null值的话，第一个会是false，而第二个会报错
        System.out.println("==================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); //false
        System.out.println(strA.equalsIgnoreCase(strB));//true 忽略大小写

        //注意只有英文字母区分大小写，其他都不区分
        System.out.println("abc一134".equalsIgnoreCase("abc壹134")); //false

    }

字符串的一些方法：
String当中与获取相关的常用方法有

public int length():获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index): 获取指定索引位置的单个字符。(索引从0开始)
public int indexOf(String str):查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值

例：

public static void main(String[] args) {

        //获取字符串长度
        int length = "fjiewnfodsinfoids".length();
        System.out.println("字符串的长度" + length);

        //拼接字符串
        String str1 = "Hello"; //Hello , 原封不动
        String str2 = "World";// World ，原封不动
        String str3 = str1.concat(str2); //HelloWorld，新的字符串
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);

        System.out.println("==============");

        //获取索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是" + ch);
        System.out.println("========");

        //查找参数字符串在本来字符串当中出现的第一次索引位置
        //如果没有，返回值-1值
        String Original = "HelloWorld";
        int index = Original.indexOf("llo");
        System.out.println(index);//2

        System.out.println("HelloWorld".indexOf("abx"));
    }

字符串的截取方法

public String substring(int index):截取从参数位置一直到字符串末尾，返回新的字符串
public String substring(int begin, int end):截取从begin开始，一直到end结束，中间的字符串 */

例：

public class Demo03Substring {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); //HelloWorld,原封不动
        System.out.println(str2);//World，新字符串
        System.out.println("========");

        String str3 = str1.substring(4,7);
        System.out.println(str3);  //owo
        System.out.println("========");
        
        /*下面这种写法，字符串的内容仍然是没有改变的
        * 下面有两个字符串："Hello","Java"
        * strA当中保存的是地址值
        * 本来地址值是Hello的地址值0x666
        * 后来地址变成了0x999，内容仍然不可发生改变*/
        String strA = "Hello";
        System.out.println(strA); //Hello
        strA = "Java";
        System.out.println("strA");
    }

String字符串的替换方法

String当中与转换相关的常用方法有：

public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes(): 获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString)
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串
备注：CharSequence意思就是说可以接受字符串类型

例：

 public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); //H
        System.out.println(chars.length); //5
        System.out.println("======");

        //转化成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("========");

        //字符串的替换
        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);

    }

分隔字符串的方法：

public String[] split(String regex),按照参数的规则，将字符串切分成为若干个部分
注意事项：
Split方法的参数其实是一个"正则表达式"
注意：如果按照英文句点".",进行切分，必须写为"\"(两个反斜杠)

例：

public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

        System.out.println("=========");

        String str2 ="aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("==========");

        //因为要切割“.”,所有打印不了，要加上\\才能打印
        String str3 = "xxx.yyy.zzzz";
        String[] array3 = str3.split(".");
        System.out.println(array3.length);
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
        System.out.println("===========");
        String[] split = str3.split("\\.");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);     //这样就能分隔成功
        }


    }

例题：

定义一个方法，把数组{1，2，3}按照指定格式拼成一个字符串。参照格式如下：[world1#world2#world3]

分析：
1.首先准备一个int[]数组，内容是：1，2，3
2.定义一个方法，用来将数组变成字符串
三要素：
返回值类型：String
方法名称：getString
参数列表：int[]
3.格式
用到for循环，字符串拼接，每个数组元素之前都有一个world字样，分隔使用的是#，区分一下是不是最后一个
4 调用方法，得到返回值，并得到打印结果
*注意：String类型的相加并不是变成数字的和，而是直接加在后面

public class Demo06StringPractice {

    public static void main(String[] args) {
        int[] array = {1, 2, 3};

        String result = getString(array);
        System.out.println(result);
    }

    public static String getString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {  //不断的拼接
            if (i == array.length - 1) {
                str += "world" + array[i] + "]";
            } else {
                str += "world" + array[i] + "#";
            }
        }
        return str;
    }
}

Static关键字

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据

  public static void main(String[] args) {
        Student one = new Student("W",12);
        one.room ="101教室";
        System.out.println("姓名" + one.getName() + "年龄" + one.getAge() + one.room +"学号"+ one.getId());
        Student two = new Student("Z",19);
        System.out.println("姓名" + one.getName() + "年龄" + one.getAge()+ two.room + "学号" + two.getId());
        //id会按顺序相加
    }
}

public class Student {

    private int id;//学号

    private String name;
    private int age;
    static String room; //所在教室
    private static int idCounter = 0; //学号计数器，每当new一个新对象时候，计数器++；

    public Student() {
        this.id =  idCounter++;

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id =  idCounter++;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

如面的代码，写了一个学生类，用static修饰的不需要new一个新的对象，可以直接调用，如上面的room。

Static

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类
如果没有static关键字，那么必须首先创建对象，然后通过对象使用它。
如果有了static关键字，那么就不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称来进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
1 静态不能直接访问非静态(因为先有的静态内容，后有的非静态内容)
2 静态方法中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

例：

public static void main(String[] args) {
        MyClass obj = new MyClass(); //首先创建对象
        //然后才能使用没有static关键字的内容
        obj.method();

        //对于静态方法来说，可以通过对象名进行调用，也可以通过类名称来调用。
       MyClass.methodStatic();

       //对于本类当中的静态方法，可以省略类
        myMethod();
        Demo02StaticMethod.myMethod(); //与上面一模一样 完全等效
    }
    public static void myMethod (){
        System.out.println("自己的方法");
    }
}

public class MyClass {



    public void method() {
        System.out.println("这是一个普通的成员方法");
    }
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
    }

注意：根据类名称访问静态变量的时候，全程和对象没有关系，只与类有关系。

静态代码块：

public class类名称{
```
  static{
```
```
      //静态代码块的内容
```
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值
例：

public class Person {
    static {
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("构造方法执行");
    }
}

public class Demo04Static {

    public static void main(String[] args) {

        Person one = new Person();
        Person two = new Person();
    }
}

如上的代码所示,new 了两个对象，但是静态代码块只执行了一次，构造方法执行了两次。

Arrays

java.util.Arrays 是一个与数字相关的工具类，里面提供了大量的静态方法，用来实现数组的常见操作
public static String toString(数组) : 将参数数组变成字符串(按照默认格式：[元素1,元素2,元素3…])
public static void sort(数组)：按照默认升序(从小到大)对数组的元素进行排序。
备注：
1. 如果是数值，sort默认按照升序从小到大
1. 如果是字符串，sort默认按照字母升序
1. 如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

例：

import java.util.Arrays;

public class Demo01Arrays {
    public static void main(String[] args) {
        int [] array = {1,20,50};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(array);
        System.out.println(intStr); //[1, 20, 50]


        int[] array1 = {4,5,39,1,2,98};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); //[1, 2, 4, 5, 39, 98]

        String [] array2 = {"aaa","ccc","bbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

例题：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public class Demo02ArraysPractice {

    public static void main(String[] args) {
        String str = "fefewfwefew3174971941";


        //进行升序排列：sort方法
        //必须是一个数组才能用Arrays.sort方法
        //String转化为数组：toCharArray方法

        char[] chars = str.toCharArray();
        Arrays.sort(chars);

        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }


    }
}

Math

java.util.Math类是数学类相关的工具类，里面提供了大量的静态方法，完成与数学运算的相关操作
public static double abs(double num): 获取绝对值。有多种重载
public static double ceil(double num): 向上取整
public static double floor(double num): 向下取整
public static long round (double num): 四舍五入
Math.PI代表近似的圆周率常量(double)

例：

public class Demo03Math {
    public static void main(String[] args) {
        System.out.println(Math.abs(3.14)); //3.14
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-2.5));//2.5

        //向上取整
        System.out.println(Math.ceil(3.9));//4
        System.out.println(Math.ceil(3.1));//4
        System.out.println(Math.ceil(3.0));//3

        //向下取整
        System.out.println(Math.floor(30.1));//30
        System.out.println(Math.floor(30.9));//30
        System.out.println(Math.floor(31.1));//31

        //四舍五入
        System.out.println(Math.round(20.4)); //20
        System.out.println(Math.round(20.5)); //21
    }
}

数学例题：

题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个

*
* 分析：
* 1.既然已经确定了范围，for循环
* 2.起点位置-10.8应该转化为-10，两种办法：
*       2.1 可使用Math.ceil方法,向上(向正方向取整)
*       2.2 强转成为int，自动舍弃所有小数位
* 3.每个数字都是整数，所以步进表达式应该是num++,这样每次都是+1的。
* 4.如何拿到绝对值：Math.abs方法
* 5.一旦发现了一个数字，需要让计数器++进行统计。

* 备注：如果使用Math.ceil方法，-10.8会变成-10.0，double值后面会有小数，一   样可以使用++的

public class Demo04Practice {

    public static void main(String[] args) {

        int count =0;
        double min = -10.8;
        double max = 5.9;

        for (int i = (int)min;  i<max; i++){
            int abs = Math.abs(i);
            if(abs>6 || abs <2.1){
                System.out.println(i);
                count++;
            }

        }
        System.out.println("共有" + count);

    }
}