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

String类

概述

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

特点

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

举例：

public class Demo {
    public static void main(String[] args) {
        String s1 = "abc";
        /*
        s1 = "abc" + "d"  ---> s1 = "abcd"
        内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。
         */
        s1 += "d";
        System.out.println(s1);  // "abcd"

    }
}

注意字符串是常量

举例：

 　　　　　/*
        下面这种写法，字符串的内容仍然是没有改变的
        下面有两个字符串："Hello"，"Java"
        strA当中保存的是地址值。
        strA改变的是保存的地址值
         */
        String strA = "Hello";
        System.out.println(strA); // Hello
        strA = "Java";
        System.out.println(strA); // Java

因为String对象是不可变的，所以它们可以被共享。字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。通过new 创建的字符串对象不能共享使用

举例：

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

对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
 */
public class StringPool {

    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(str3);//abc
        // 对于引用类型来说，==是进行内存地址值的比较。
        System.out.println(str1 == str2); // true
        System.out.println(str1 == str3); // false
        System.out.println(str2 == str3); // false
    }

}

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

public class Demo {
    public static void main(String[] args) {
        //例如
        String s1 = "abc";
        //相当于
        char data[] = {'a', 'b', 'c'};
        // String底层是靠字符数组实现的
        String s2 = new String(data);

    }
}

使用步骤

查看类

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

查看构造方法

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

构造使用举例，代码如下：

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) ：将此字符串与指定对象进行比较，忽略大小写。

代码举例

public class DemoEquals {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        char[] c = {'H', 'e', 'l', 'l', 'o'};
        String s3 = new String(c);
        
        // boolean equals(Object obj):比较字符串的内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false

        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); // true
        System.out.println(s1.equalsIgnoreCase(s3)); // 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) ：获取指定索引位置的单个字符。
• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引，如果根本没有，返回-1值

代码举例

/*
String当中与获取相关的常用方法有：

public int length()：
public String concat(String str)：将当前字符串和参数字符串拼接成为
public char charAt(int index)：（索引从0开始。）
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。
 */
public class DemoGet {

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

        // 拼接字符串
        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 beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
• public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

代码举例

public class DemoSubString {
    public static void main(String[] args) {

        String s = "123456789abcdefg";
        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));//123456789abcdefg
        System.out.println(s.substring(5));//6789abcdefg

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

    }
}

转换功能相关的方法

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

代码举例

/*

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

备注：CharSequence意思就是说可以接受字符串类型。
 */
public class Demo04StringConvert {

    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
      
        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
   
        // 字符串的内容替换
        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*?
   
    }

}

注意：

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

分割功能的方法

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

注意事项：

• split方法的参数其实是一个“正则表达式”。要注意：如果按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）

举例：

public class Demo {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa，bb，cc";
        String[] strArray = s.split("，"); 
        //遍历数组
        for (int x = 0; x < strArray.length; x++) {
            System.out.print(strArray[x]+" "); // aa bb cc
             }
        }
    }

String类的练习

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

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

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

定义格式

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

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

调用格式

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

格式：

代码演示static关键字的基本使用

定义含有静态的方法和成员变量

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); // 错误写法！
        // System.out.println(this); 错误写法！静态方法中不能使用this关键字

    }

}

定义测试类

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

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

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

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

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

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

        // 对于本类当中的静态方法，可以省略类名称
        myMethod();

    }

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

}

代码执行后的结果

静态原理图解

static 修饰的内容：

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

静态代码块

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

格式

特点：

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

静态代码块的典型用途：

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

代码演示

import java.util.ArrayList;

public class Demo {

    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) ：返回指定数组内容的字符串表示形式

import java.util.ArrayList;
import java.util.Arrays;

public class Demo {

    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接口的支持。

举例：

import java.util.ArrayList;
import java.util.Arrays;

public class Demo {

    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，将一个随机字符串中的所有字符升序排列，并倒序打印。

代码实现

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

基本运算的方法

• public static double abs(double num)：获取绝对值。有多种重载。
• public static double ceil(double num)：向上取整。
• public static double floor(double num)：向下取整。
• public static long round(double num)：四舍五入。

tips：

• 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
    }

}

练习：

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
    }

}