[JavaSE-07]String类、static、Arrays类、Math类

最新推荐文章于 2024-08-04 22:25:20 发布

学哥斌

最新推荐文章于 2024-08-04 22:25:20 发布

阅读量231

点赞数

分类专栏： JavaSE 文章标签： java 编程语言字符串

本文链接：https://blog.csdn.net/qq_29051413/article/details/103888976

版权

JavaSE 专栏收录该内容

22 篇文章 3 订阅

订阅专栏

1、String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。
String类有几个特点：字符串的值在创建后不能被更改；因为String对象是不可变的，所以它们可以被共享；“abc” 等效于 char[ ] data={ ‘a’ , ‘b’ , ‘c’ } ，String底层是靠字符数组实现的。

1.1 使用步骤

和上一章介绍API使用步骤一样，String类也是API的一部分。

//导包
import java.lang.String	//lang包的类都不需要导入，这一步可以省略。

//构造方法
public String()	//初始化新创建的 String对象，以使其表示空字符序列。
public String(char[] value)	//通过当前参数中的字符数组来构造新的String。
public String(byte[] bytes)	//通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};    
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };    
String str3 = new String(bytes);	//默认采用ASCII码表转成 a b c

1.2 常用方法

判断：equals、equalsIgnoreCase

public class String_Demo01 {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELLO";
        // boolean equals(Object obj):比较字符串的内容是否相同
        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("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

获取：length、concat、charAt、indexOf、substring

public class String_Demo02 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "helloworld";
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s.length());	//10
        System.out.println("‐‐‐‐‐‐‐‐");
        // String concat (String str):将将指定的字符串连接到该字符串的末尾.
        String s = "helloworld";
        String s2 = s.concat("**hello itheima");
        System.out.println(s2);// helloworld**hello itheima
        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));	// h
        System.out.println(s.charAt(1));	// e
        System.out.println("‐‐‐‐‐‐‐‐");
        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
        System.out.println(s.indexOf("l"));	//2
        System.out.println(s.indexOf("owo"));	//4
        System.out.println(s.indexOf("ak"));	//-1
        System.out.println("‐‐‐‐‐‐‐‐");
        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));	//helloworld
        System.out.println(s.substring(5));	//world
        System.out.println("‐‐‐‐‐‐‐‐");
        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(0, s.length()));	//helloworld
        System.out.println(s.substring(3, 8));	//lowor
    }
}

转换：toCharArray、getBytes、replace

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for (int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        // 替换字母it为大写IT
        String str = "itcast itheima";
        String replace = str.replace("it", "IT");
        System.out.println(replace); // ITcast ITheima
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

分割：split

public class String_Demo04 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa|bb|cc";
        String[] strArray = s.split("|"); // ["aa","bb","cc"]
        for(int x = 0; x < strArray.length; x++) {
            System.out.println(strArray[x]); // aa bb cc
        }
    }
}

1.3 使用例程

例程一：拼接字符串

定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下[word1#word2#word3]。

public class StringTest1 {
    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr = {1, 2, 3};
        //调用方法
        String s = arrayToString(arr);
        //输出结果
        System.out.println("s:" + s);
    }

    /*
     * 写方法实现把数组中的元素按照指定的格式拼接成一个字符串
     * 两个明确：
     * 返回值类型：String
     * 参数列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 创建字符串s
        String s = new String("[");
        // 遍历数组，并拼接字符串
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length ‐1){
                s = s.concat(arr[x] + "]");
            } else{
                s = s.concat(arr[x] + "#");
            }
        }
        return s;
    }
}

例程一：统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

public class StringTest2 {
    public static void main(String[] args) {
        //键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();
        //定义三个统计变量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //遍历字符串，得到每一个字符
        for (int x = 0; x < s.length(); x++) {
            char ch = s.charAt(x);
            //拿字符进行判断
            if (ch >= 'A' && ch <= 'Z') {
                bigCount++;
            } else if (ch >= 'a' && ch <= 'z') {
                smallCount++;
            } else if (ch >= '0' && ch <= '9') {
                numberCount++;
            } else {
                System.out.println("该字符" + ch + "非法");
            }
        }
        //输出结果
        System.out.println("大写字符：" + bigCount + "个");
        System.out.println("小写字符：" + smallCount + "个");
        System.out.println("数字字符：" + numberCount + "个");
    }
}

2、static关键字

关于 static 关键字的使用，它可以用来修饰类的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。静态方法可以直接访问类变量和静态方法，但是不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

2.1 静态原理图解

在这里插入图片描述

2.2 静态代码块

定义在成员位置，使用static修饰的代码块{ }，随着类的加载而执行且执行一次，优先于 main方法和构造方法的执行。

public class Game {
    public static int number;
    public static ArrayList<String> list;

    static {
        // 给类变量赋值
        number = 2;
        list = new ArrayList<String>();
        // 添加元素到集合中
        list.add("张三");
        list.add("李四");
    }
}

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况
下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

3、Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。这种单词加s的大多是工具类，比如后面会学习到一个叫做Collection的类，然后还有一个叫做Collections的工具类，Collections里面的方法用来操作Collection集合的对象。同理，Arrays就是操作数组的工具类。

Arrays.toString

public class Main {
    public static void main(String[] args) {
        // 定义int 数组
        int[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
        // 打印数组,输出地址值
        System.out.println(arr); // [I@2ac1fdc4
        // 数组内容转为字符串
        String s = Arrays.toString(arr);
        // 打印字符串,输出内容
        System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
    }
}

Arrays.sort

public class Main {
    public static void main(String[] args) {
        // 定义int 数组
        int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
        // 排序前:[24, 7, 5, 48, 4, 46, 35, 11,6,2]
        System.out.println("排序前:" + Arrays.toString(arr));
        // 升序排序
        Arrays.sort(arr);
        // 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,48]
        System.out.println("排序后:" + Arrays.toString(arr));
    }
}

例程

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

public class ArraysTest {
    public static void main(String[] args) {
        // 定义随机的字符串
        String line = "ysKUreaytWTRHsgFdSAoidq";
        // 转换为字符数组
        char[] chars = line.toCharArray();
        // 升序排序
        Arrays.sort(chars);
        // 反向遍历打印
        for (int i = chars.length‐1;
        i >= 0;
        i‐‐){
            System.out.print(chars[i] + " "); // y y t s s r q o i g e d d a W U T S R K H F A
        }
    }
}

4、Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

//public static double abs(double a) ：返回 double 值的绝对值。
double d1 = Math.abs(‐5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5

//public static double ceil(double a) ：返回大于等于参数的最小的整数。
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

//public static double floor(double a) ：返回小于等于参数最大的整数。
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

//public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

例程

使用 Math 相关的API，计算在 - 10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少个？

public class MathTest {
    public static void main(String[] args) {
        // 定义最小值
        double min = ‐10.8;
        // 定义最大值
        double max = 5.9;
        // 定义变量计数
        int count = 0;
        // 范围内循环
        for (double i = Math.ceil(min); i <= max; i++) {
            // 获取绝对值并判断
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                // 计数
                count++;
            }
        }
        System.out.println("个数为: " + count + " 个");
    }
}

5、总结

String类和数组一样，创建后不可更改，执行String的添加和删除其实在内存都是新建了一个字符串，占用了内存资源。static关键字修饰的成员方法是属于类的方法，最好的方式是使用类名来调用。大多数集合类都有对用的操作该集合的工具类，比如Arrays就是专门操作数组的工具类。Math类是数学工具类包，里面包含了常用的数学运算成员方法，静态调用。
（本章内容为自学笔记，转载请注明来源，有错误地方欢迎评论区指出。）