自学Java之day08_String类、static关键字、Arrays类、 Math类

String类

概述

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

字符串的特点：

• 字符串的内容永不可变。字符串的值在创建后不能被更改

package demo01;

public class Demo01String {
    public static void main(String[] args) {
        String s = "A";
        s = s + "B";
        // 内存中有"A"，"AB"两个对象，s从指向"A"，改变指向，指向了"AB"。
        System.out.println(s);//AB
    }
}

• 正是因为字符串不可改变，所以字符串是可以共享使用的。注意通过new创建的字符串对象不能共享使用

public class Demo02String {
    public static void main(String[] args) {
        /*字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
        对于基本类型来说，==是进行数值的比较。
        对于引用类型来说，==是进行【地址值】的比较。
         */
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);//true
        char[] charArray = {'a', 'b', 'c'};
        //通过字符数组创建String对象
        String s3 = new String(charArray);
        System.out.println(s3 == s1);//false

    }
}

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

     /*
        例如： 
        String str = "abc"; 
        相当于： 
        char data[] = {'a', 'b', 'c'};
        String str = new String(data);
         */

使用步骤

查看类

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

查看构造方法

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

代码演示

package demo01;

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

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

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

代码执行后的结果

直接创建字符串对象

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

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

常用方法

判断功能的方法

• public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
• public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

代码演示

package demo02;

public class 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));//false
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

注意事项：

• 任何对象都能用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 String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
• public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

代码演示

package demo02;

public class Demo02 {

    public static void main(String[] args) {
        //创建字符串对象
        String s = "helloWorld12223324";
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s.length());//18

        // String concat (String str):将将指定的字符串连接到该字符串的末尾.
        System.out.println(s.concat("我爱你中国"));//helloWorld12223324我爱你中国

        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));//h
        System.out.println(s.charAt(1));//e

        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
        System.out.println(s.indexOf("l"));//2
        System.out.println(s.indexOf("12"));//10
        System.out.println(s.indexOf("美国"));//-1

        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));//helloWorld12223324
        System.out.println(s.substring(5));//World12223324

        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        System.out.println(s.substring(0, s.length()));//helloWorld12223324
        System.out.println(s.substring(3, 8));//loWor

    }
}

转换功能的方法

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

代码演示

package demo02;

public class Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "2019年886";
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        //遍历字符数组
        for (int x = 0; x < chs.length; x++) {
            System.out.print(chs[x] + " ");//2 0 1 9 年 8 8 6 
        }
        System.out.println("");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        //遍历字节数组
        for (int x = 0; x < bytes.length; x++) {
            System.out.print(bytes[x] + " ");//50 48 49 57 -27 -71 -76 56 56 54 
        }
        System.out.println("");
        // 替换字母it为大写IT

        String str = "我爱你it,一步一个脚印";
        String replace = str.replace("it", "中国");
        System.out.println(replace);//我爱你中国,一步一个脚印

    }
}

注意：

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

分割功能的方法

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

代码演示

package demo02;

/*

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

    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.print(array1[i] + " ");//aaa bbb ccc
        }

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

        System.out.println("");
        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.print(array3[i] + " ");//XXX YYY ZZZ 
        }
    }

}

String练习题

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

代码实现

package demo02;

import java.util.Scanner;

public class StringCharCount {

    /*


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

    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关键字修饰的成员变量。

定义格式：

 例如：

static int age;

静态方法

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

定义格式：

举例：类中定义静态方法 

public static void showNum() { 
    System.out.println("num:" + numberOfStudent); 
}

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。 

格式：

注意事项：

• 静态不能直接访问非静态。静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。 原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容
• 静态方法当中不能用this。原因：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;

public class Test {
    /*
    一旦使用static修饰成员，那成员不属于对象，而是属于类的。
    如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
    如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

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

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

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

    }

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

}

代码执行后 的结果

静态原理图解 

static 修饰的内容：

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

静态代码块

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

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

格式：

特点：

• 当第一次用到本类时，静态代码块执行唯一的一次。静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：

• 用来一次性地对静态成员变量进行赋值。

代码演示

package demo03;

import java.util.ArrayList;

public class Demo01 {
    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 Demo01 {
    public static void main(String[] args) {
        // 定义int 数组 
        int[] arr = {2, 34, 35, 4, 657, 8, 69, 9};
        // 打印数组名称,输出地址值
        System.out.println(arr); // [I@50cbc42f
        // 数组内容转为字符串
        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 Demo02 {
    public static void main(String[] args) {
        // 定义int 数组
        int[] arr = {241, 7, 35, 48, 4, 4644, 35, 11, 6, 2};
        System.out.println("排序前:" + Arrays.toString(arr)); // 排序前:[241, 7, 35, 48, 4, 4644, 35, 11, 6, 2]
        // 升序排序
        Arrays.sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));// 排序后:[2, 4, 6, 7, 11, 35, 35, 48, 241, 4644]
    }
}

练习

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

代码实现

package demo04;

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        // 定义随机的字符串
        String line = "ysKUr问问额eaytWTRHsgFdSAoidq";
        // 转换为字符数组
        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 
        }
    }
}

Math类

概述：java.lang.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)：四舍五入。

 　　　// 获取绝对值
        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

练习

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

package cn.itcast.day08.demo04;

/*
题目：
计算在-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 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
    }

}