day08_String类、static关键字、Arrays类、 Math类

String类

概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实例。类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

特点

• 字符串不变：字符串的值在创建后不能被更改。

 举例：

package demo01;

public class Test {
    public static void main(String[] args) {
        /*
       字符串的内容仍然是没有改变的
       下面有两个字符串："Hello"，"Java"
        strA当中保存的是地址值。
        本来地址值是Hello的内存地址
        后来地址值变成了Java的内存地址
         */
        String strA = "Hello";
        System.out.println(strA); // Hello
        strA = "Java";
        System.out.println(strA); // Java

    }

}

• 因为String对象是不可变的，所以它们可以被共享。

举例：

package demo01;


/*
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
 */
public class Demo02StringPool {

    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
    }

}

• 字符串效果上相当于是char[]字符数组例如："abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。，但是底层原理是byte[]字节数组。

//例如： 
String str = "abc"; 
//相当于：
char data[] = {'a', 'b', 'c'}; 
String str = new String(data);
// String底层是靠字符数组实现的。

使用步骤

查看类

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

查看构造方法

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

除了通过构造方法创建字符串对象，我们还可以直接创建

//直接创建：
String str = "Hello"; // 右边直接用双引号

构造举例，代码如下：

public class Demo01String {

    public static void main(String[] args) {
        // 使用空参构造,小括号留空，说明字符串什么内容都没有。
        String str1 = new String();
        System.out.println("第1个字符串：" + str1);//第1个字符串：

        // 根据字符数组创建字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第2个字符串：" + str2);//第2个字符串：ABC

        // 根据字节数组创建字符串
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第3个字符串：" + str3);//第3个字符串：abc

        // 直接创建
        String str4 = "Hello";
        System.out.println("第4个字符串：" + str4);//第4个字符串：Hello
    }

}

字符串常用方法

判断功能的方法

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

方法演示，代码如下：

package demo02;


/*
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用方法：
 */
public class Demo01StringEquals {

    public static void main(String[] args) {
        //创建字符串对象
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        // boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
        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

        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐：false
        // System.out.println(str5.equals("abc"));  不推荐：报错，空指针异常NullPointerException

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，严格区分大小写
        // boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。
        System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写

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

}

注意事项：

• Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。
• equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
• 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。推荐："abc".equals(str) 不推荐：str.equals("abc")

获取功能的方法

• public int length () ：返回此字符串的长度。
• public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
• public char charAt (int index) ：返回指定索引处的 char值。
• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引

方法演示，代码如下：

public class Demo02StringGet {

    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "asdasfeutrvauevbueyvb".length();
        System.out.println("字符串的长度是：" + length);//字符串的长度是：21

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

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

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

}

字符串的截取方法：

• public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
• public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。备注：[begin,end)，包含左边，不包含右边。

方法演示，代码如下

public class Demo03Substring {

    public static void main(String[] args) {
        String str1 = "HelloWorld";
        // String substring(int start):从start开始截取字符串到字符串结尾
        String str2 = str1.substring(5);
        System.out.println(str1); // HelloWorld
        System.out.println(str2); // World

        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        String str3 = str1.substring(4, 7);
        System.out.println(str3); // oWo


    }

}

转换功能的方法

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

备注：

• CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

方法演示，代码如下

package demo02;

public class Demo04StringConvert {

    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); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?

    }

}

分割功能的方法

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

方法演示，代码如下

package demo02;

/*
分割字符串的方法：
public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注意事项：
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意：如果按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）
 */
public class Demo05StringSplit {

    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]);
        }


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


        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length); // 3
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }

}

需求

键盘输入一个字符串，并且统计其中各种字符出现的次数。种类有：大写字母、小写字母、数字、其他

代码实现

package demo02;


import java.util.Scanner;

/*
思路：
1. 既然用到键盘输入，肯定是Scanner
2. 键盘输入的是字符串，那么：String str = sc.next();
3. 定义四个变量，分别代表四种字符各自的出现次数。
4. 需要对字符串一个字、一个字检查，String-->char[]，方法就是toCharArray()
5. 遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
6. 打印输出四个变量，分别代表四种字符出现次数。
 */
public class Demo07StringCount {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next(); // 获取键盘输入的一个字符串

        int countUpper = 0; // 大写字母
        int countLower = 0; // 小写字母
        int countNumber = 0; // 数字
        int countOther = 0; // 其他字符

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i]; // 当前单个字符
            if ('A' <= ch && ch <= 'Z') {
                countUpper++;
            } else if ('a' <= ch && ch <= 'z') {
                countLower++;
            } else if ('0' <= ch && ch <= '9') {
                countNumber++;
            } else {
                countOther++;
            }
        }

        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNumber);
        System.out.println("其他字符有：" + countOther);
    }

}

代码执行后的结果

static关键字

概述

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。类变量：使用 static关键字修饰的成员变量。

定义格式：

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。所以，我们可以这样定义一个静态变量numberOfStudent，代码如下：

package demo03;

public class Student {
    private String name;
    private int age;
    // 学生的id
    private int sid; // 类变量，记录学生数量，分配学号
    public static int numberOfStudent = 0;

    public Student(String name, int age) {
        this.name = name;
        this.age = age; // 通过 numberOfStudent 给学生分配学号 
        this.sid = ++numberOfStudent;
    }

    //打印属性值 
    public void show() {
        System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid);
    }
}

定义测试类

package demo03;

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);
        s1.show(); // Student : name=张三, age=23, sid=1
        s2.show(); // Student : name=李四, age=24, sid=2
        s3.show(); // Student : name=王五, age=25, sid=3
        s4.show(); // Student : name=赵六, age=26, sid=4
    }
}

注意：

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

静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

 

静态方法调用的注意事项：

• 静态方法可以直接访问类变量和静态方法。静态方法只能访问静态成员。
• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
• 静态方法中，不能使用this关键字。

举例：

package demo03;

public class MyClass {

    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态【重点】System.out.println(num); // 错误写法！

        // 静态方法中不能使用this关键字。System.out.println(this); // 错误写法！

    }

}

定义测试类

package demo03;

/*
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

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

注意事项：
1. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
 */
public class Demo02StaticMethod {

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

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); // 正确，推荐

        // 对于本来当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }

}

静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
• 它优先于对象存在，所以，可以被所有对象共享。

静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。

• 位置：类中方法外。
• 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

格式：

作用：

• 给类变量进行初始化赋值。用法演示，代码如下： 

package demo03;


import java.util.ArrayList;

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

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

Arrays类 

概述

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

操作数组的方法

• public static String toString(int[ ] a) ：返回指定数组内容的字符串表示形式。

方法演示，代码如下

package demo04;

import java.util.Arrays;

public class Test {
    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]
    }
}

• public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。 

备注：

• 如果是数值，sort默认按照升序从小到大
• 如果是字符串，sort默认按照字母升序
• 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。

方法演示，代码如下

package demo04;

import java.util.Arrays;

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

需求

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

代码实现

import java.util.Arrays;

public class Demo02ArraysPractise {

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

        // 如何进行升序排列：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.lang.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("================");

        // 向上取整
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(3.0)); // 3.0
        System.out.println("================");

        // 向下取整，抹零
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(31.0)); // 31.0
        System.out.println("================");

        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); // 11
    }

}

需求

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

代码实现

package cn.itcast.day08.demo04;

/*
分析：
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 Demo04MathPractise {

    public static void main(String[] args) {
        int count = 0; // 符合要求的数量

        double min = -10.8;
        double max = 5.9;
        // 这样处理，变量i就是区间之内所有的整数
        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); // 9
    }

}

 

 

来源：https://www.cnblogs.com/wurengen/p/12231783.html