【 String类、static、Arrays类、Math类 】

String类

• java.lang.String

• Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
  翻译成为人话：程序里面直接双引号写上的字符串，就是String类的对象。

  字符串的三个特点：
  1. 【重要】字符串是常量，内容不可改变。（每当你觉得好像是变了的时候，必然是创建了一个新的字符串。）
  2. 正是因为字符串的内容不可改变，所以能够达到一个共享的效果。
  3. 效果上类似于char[ ]，很多个字符连起来；但是底层原理是byte[ ]字节数组。

  创建字符串的常见3+1种方式：

  三种构造方法：
  public String()：创建一个空白的字符串，什么东西都没有。
  public String(char[] array)：根据字符数组的内容，创建一个字符串。
  public String(byte[] array)：根据字节数组的内容，创建一个字符串。
  一种直接创建：
  String str = “abc”;

  备注： 字符串在打印的时候显示的是内容，而不是地址值，这是因为println方法对String有特殊处理。

  字符串的常量池，作为：多处出现了内容相同的字符串，那么我只创建一个，多处共享使用。
  凡是双引号直接写的字符串，默认就在常量池当中。
  凡是自己new的字符串，默认就不在常量池当中。
  ==运算符的含义：
  对于基本类型来说，==是进行数据值的判断。
  对于引用类型来说，==是进行【地址值】的判断。
  

字符串当中与内容比较相关的方法有：

public boolean equals(Object obj)：将字符串与参数对象进行内容比较，返回是否相同，返回的是一个boolean值（true || false）
备注：参数Object代表什么类型的参数全都可以，但是只有参数是String字符串的时候，才有可能相等。
注意：equals方法具有对称性。a.equals(b)效果和b.equals(a)一样。
但是，如果有一个常量和一个变量进行比较，强烈推荐将常量放在前面。

public boolean equalsIgnoreCase(String str)：将字符串与参数字符串进行大小比较，而且忽略大小写。

字符串当中与获取相关的方法：

public int length()：获取字符串的长度（也就是字符的个数）
public String concat(String str)：让字符串的后面继续拼接另一个字符串，
得到新字符串。
public char charAt(int index)：获取字符串当中指定索引位置的单个字符。
public int indexOf(String str)：在字符串当中查找参数所出现的第一个位置，
如果没有，返回-1值。

代码示意：

String str1 = "aisduycvbqfivervtuyctvyctveyjreqrtv";
System.out.println(str1.length()); // 35

System.out.println("中国".length()); // 2

String str2 = "Hello";
String str3 = str2.concat("World");
System.out.println(str2); // Hello
System.out.println(str3); // HelloWorld

String str4 = "Java";
char ch = str4.charAt(2);
System.out.println(ch); // v
// System.out.println(str4.charAt(100)); // StringIndexOutOfBoundsException

String str5 = "HelloWorldJavaWorldHelloJava";
int index = str5.indexOf("Java");
System.out.println(index); // 10
System.out.println(str5.indexOf("abc")); // 查找不到 结果是：-1

字符串的截取方法：

public String substring(int begin)：从指定索引位置一直到末尾，截取得到小字符串。
public String substring(int begin, int end)：从指定的第一个索引，一直到第二个
索引，截取得到中间的小字符串。
备注：左闭右开区间。

示例：

String str1 = "HelloWorld";
String str2 = str1.substring(5);
System.out.println(str1); // HelloWorld
System.out.println(str2); // World
System.out.println("=============");

String str3 = str1.substring(4, 7);
System.out.println(str3); // oWo  
// 从0开始遍历str1 = HelloWorld   （4，7）也就是4，5，6三个值

字符串当中与转换相关的方法：

public char[] toCharArray()：将字符串转换成为对应的字符数组。
public byte[] getBytes()：将字符串转换成为对应的字节数组。
public String replace(CharSequence target, CharSequence replacement)：
字符串内容替换，得到替换之后的新字符串。
第一个参数target代表：你想找谁？
第二个参数replacement代表：你想替换成为谁？
CharSequence是字符串的父接口，今天我们认为就是字符串。

示例：

 String str1 = "Hello";
 char[] chars = str1.toCharArray();
 System.out.println(chars.length); // 5
 for (int i = 0; i < chars.length; i++) {
      System.out.println(chars[i]);  
 }

 String str2 = "abc";
 byte[] bytes = str2.getBytes();
 System.out.println(bytes.length); // 3
 for (int i = 0; i < bytes.length; i++) {
     System.out.println(bytes[i]); // 97 98 99   ABC对应的ASCII码的编号
 }

 String str3 = "How do you do?";
 String str4 = str3.replace("o", "*");
 System.out.println(str3); // How do you do?  没有换，因为打印的还是原来的字符串
 System.out.println(str4); // H*w d* y*u d*?  改变，调用了改变后的数组的参数

字符串的分割方法：
public String[] split(String regex)：根据参数作为标准，将字符串切割成为若干个部分。
参数字符串其实是一个“正则表达式”（Regular Expression, RegEx），这是一种专门用来描述规则的特殊写法。
今天需要记住的是：英文句点切割，必须写成字符串”\\.“才行。
示例：

String str3 = "XXX.OOO.XXX.OOO";
String[] array3 = str3.split("\\."); // 括号里面是选择切割的点
System.out.println(array3.length); 
for (int i = 0; i < array3.length; i++) {
    System.out.println(array3[i]); // 切割后：XXX 000 XXX 000
}

题目：键盘输入一个字符串，分别统计其中的大写字母、小写字母、数字、其他分别出现了多少次。

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.println("请输入字符串：");
    String str = sc.next();

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

    char[] chars = str.toCharArray();  // 将输入的字符串转换成字符数组
    for (int i = 0; i < chars.length; i++) {
        char ch = chars[i];        // 遍历字符数组，把值传递给ch
        if (ch >= 'A' && ch <= 'Z') {
            countUpper++;
        } else if (ch >= 'a' && ch <= 'z') {
            countLower++;
        } else if (ch >= '0' && ch <= '9') {
            countNumber++;
        } else {
            countOther++;
        }
    }

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

Static

• static关键字代表静态，有典型三种用法：
  
  1. 用来修饰成员变量
  2. 用来修饰成员方法
  3. 静态代码块

一旦有成员变量使用了static进行修饰，那么这个成员变量不再属于对象，而属于对应的类，多个对象共用同一份。
所以推荐的写法是：类名称.静态变量
示例：System.out.println("两人共同的教室：" + Student.room);

静态内存图：

成员方法也可以使用static修饰。

一旦方法用了static，那么这个方法就和对象无关了，只和类有关。

注意事项：
静态不能直接访问非静态。
内存当中是先有的静态内容，后有的非静态内容。

静态方法当中不可以使用this关键字。
this关键字代表当前对象，通过谁调用的方法，谁就是this。

对于普通的成员变量和方法来说，格式：

    对象名.成员变量名
    对象名.成员方法名(参数)

对于静态的成员变量和方法来说，格式：

    类名.成员变量名
    类名.成员方法名(参数)

静态代码块的格式：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

静态代码块的特点【重点】：
当第一次用到这个类的时候执行唯一一次。

PS：今后学习JDBC的时候，驱动程序的加载应该只运行一次，这时候就可以使用static静态代码块。
示例：

int num = 10; // 非静态
static int numStatic = 20; // 静态

public void method() {
    System.out.println("非静态成员方法");
    System.out.println(num); // 正确
    System.out.println(numStatic); // 正确
    System.out.println(this.num);
}

public static void methodStatic() {
    System.out.println("静态方法");
    System.out.println(numStatic); // 正确
//  System.out.println(num); // 错误
//  System.out.println(this.num); // 错误
}

Arrays类

java.util.Arrays类是与数组相关的工具类：

常用的方法有：
public static String toString(数组)：将数组变成对应的字符串，格式如：[1, 2, 3, 4]
public static void sort(数组)：将数组元素进行自然排序（升序）。

TODO: 如果数组当中存放的是自定义的类型，那么sort操作需要后面Comparable/Comparator接口才行
示例：

// 需要先进行正排序
char[] chars = before.toCharArray();
Arrays.sort(chars); // 从小到大
// 我需要从大到小
String after = "";
for (int i = chars.length - 1; i >= 0; i--) {
    after += chars[i];
}

Math类

java.lang.Math提供了大量的方法，用来支持常用的数学计算。

public static double abs(double num)：求绝对值，整数和0不变，负数取反。
public static double ceil(double num)：向上取整。火车装箱子。
public static double floor(double num)：向下取整。超市抹零。
public static long round(double num：四舍五入。

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

public static void main(String[] args) {
   int count = 0; // 计数器

   double min = -10.8;
   double max = 5.9;

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