java_String类、StringBuilder类、Arrays类、Math类的使用

时间:2022-07-23
本文章向大家介绍java_String类、StringBuilder类、Arrays类、Math类的使用，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实例

构造方法

java.lang.String ：此类不需要导入。

代码如下:

public static void main(String[] args) {
    //1.String() 创建一个空的字符串对象
    String str1=new String();
    System.out.println("str1: "+str1);
    // 2.String(String original) 根据字符串来创建一个字符串对象
    String str2=new String("abc");
    System.out.println(str2);
    // 3.String(char[] value) 通过字符数组来创建字符串对象
    char[] chs={'A','B','C','D','E'};
    String str3 = new String(chs);
    System.out.println(str3);
    // 4.String(byte[] bytes) 通过字节数组来构造新的字符串对象
    byte[] bytes={97,98,99,100,101};
    String str4 = new String(bytes);
    System.out.println(str4);
    // 5.String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象
    String str5 = new String(bytes, 1, 2);
    System.out.println(str5);
}

String特点 1. 字符串不变：字符串的值在创建后不能被更改。

String s1="abc";
s1+="d";
System.out.println(s1); //"abcd"
//内存中有"abc","abcd"两个对象,s1从指向"abc",改变指向,指向了"abcd"
  1. 因为String对象是不可变的，所以它们可以被共享。
String s1="abc";
String s2="abc";
//内存中只有一个"abc"对象被创建，同时被s1和s2共享。

常用方法

判断功能的方法

public static void main(String[] args) {
    //创建字符串对象
    String s1="abcd";
    String s2="abcd";
    String s3="ABCD";
    //boolean equals•(Object anObject) 将此字符串与指定对象进行比较。
    System.out.println(s1.equals(s2)); //true
    System.out.println(s1.equals(s3)); //false
    System.out.println("----------------");
    //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    System.out.println(s1.equalsIgnoreCase(s2)); //true
    System.out.println(s1.equalsIgnoreCase(s3)); //true
    System.out.println("----------------");
}

获取功能的方法

public static void main(String[] args) {
    String str="HelloWorld";
    //public int length () ：返回此字符串的长度。
    System.out.println(str.length());
    System.out.println("---------------");
    //public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
    String str2 = str.concat("_Java");
    System.out.println(str2);
    System.out.println("---------------");
    //public char charAt (int index) ：返回指定索引处的 char值。
    char c1 = str2.charAt(0);
    char c2 = str2.charAt(1);
    System.out.println(c1);
    System.out.println(c2);
    System.out.println("---------------");
    //public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
    int a = str.indexOf("o");
    int b = str.indexOf("l");
    int c = str.indexOf("ll");
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
    System.out.println("---------------");
    /*
    public String substring (int beginIndex) ：返回一个子字符串，
    从beginIndex开始截取字符串到字符串结尾。
    */
    String sub1 = str.substring(5);
    System.out.println(sub1);
    System.out.println("---------------");
    /*
    public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
    endIndex截取字符串。含beginIndex，不含endIndex。
    */
    String sub2 = str.substring(2, 4);
    System.out.println(sub2);
    System.out.println("---------------");
}

转换功能的方法

public static void main(String[] args) {
    String str="abcde";
    //public char[] toCharArray () ：将此字符串转换为新的字符数组。
    char[] chars = str.toCharArray();
    for(int i=0;i<chars.length;i++){
    System.out.print(chars[i]+",");
    }
    System.out.println("n-------------");
    //public byte[] getBytes ()：使用平台的默认字符集将该 String编码转换为新的字节数组。
    byte[] bytes = str.getBytes();
    for(int i=0;i<bytes.length;i++){
    System.out.print(bytes[i]+",");
    }
    System.out.println("n-------------");
    //public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。
    String lowerCase = str.toLowerCase();
    System.out.println(lowerCase);
    System.out.println("-------------");
    //public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
    String upperCase = str.toUpperCase();
    System.out.println(upperCase);
    System.out.println("-------------");
    //public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字
    符串使用replacement字符串替换。
    String str2="HelloWorld";
    String str3 = str2.replace("l", "L");
    System.out.println(str2); //注意，replace会返回一个新的字符串，新字符串才是被替换后的。这里输出
    HelloWorld
    System.out.println(str3); //HeLLoWorLd
}

分割功能的方法

public static void main(String[] args) {
String str="你好,我叫张三,我喜欢java";
String[] strs = str.split(","); //["你好","我叫张三","我喜欢java"]
for(int i=0;i<strs.length;i++){
System.out.println(strs[i]);
}
}

常量池 常量池也是JVM中的一块内存区域，在JDK1.6及以前，常量池是存储在方法区的，在JDK1.7之后，常量池被划分到了堆内存。常量池的东西只会保存一份

String s1="abc";
String s2="abc";
System.out.println(s1==s2); //返回true

因为常量池的东西只保存一份，因此 s1==s2 返回的是 true

StringBuilder类

java.lang.StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

构造方法

public StringBuilder() ：构造一个空的StringBuilder容器。

public StringBuilder(String str) ：构造一StringBuilder容器，并将字符串添加进去

public class Demo{
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用带参构造
        StringBuilder sb2 = new StringBuilder("abcd");
        System.out.println(sb2); //abcd
    }
}

常用方法

append方法 append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

public class Demo{
    public static void main(String[] args) {
        //创建对象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意类型)
        StringBuilder builder2 = builder.append("hello");
        //对比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何类型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
        //链式编程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

toString方法 通过toString方法，StringBuilder对象将会转换为不可变的String对象

public class Demo{
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法

操作数组的方法

将数组转换成字符串

public static void main(String[] args) {
    int[] arr={24,546,7,5678,58,76,83,45,435,34};
    System.out.println(arr); //[I@2460c14f
    //将数组转换成字符串
    String str = Arrays.toString(arr); //[24, 546, 7, 5678, 58, 76, 83, 45, 435, 34]
    System.out.println(str);
}

数组按数字升序进行排序

public static void main(String[] args) {
    int[] arr={24,546,7,5678,58,76,83,45,435,34};
    System.out.println("排序前： "+Arrays.toString(arr));
    //将数组升序排序
    Arrays.sort(arr);
    System.out.println("排序后： "+Arrays.toString(arr));
}

Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数，其所有方法均为静态方法

基本运算的方法

返回 double 值的绝对值

double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

返回大于等于参数的最小的整数。（向上取整）

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

返回小于等于参数最大的整数。（向下取整）

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(-3.3); //d2的值为-4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

随机文章
java知识点必读
最近更新