1.String类

1.1 String类概述

概述
java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实 例。

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。
特点

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

	String s1 = "abc";
	s1 += "d";
	System.out.println(s1); // "abcd"
	// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2. 正是因为字符串不可改变，所以字符串是可以共享使用的。

	String s1 = "abc";
	String s2 = "abc"; 
	// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3. “abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。

例如： 
String str = "abc"; 

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

1.2 使用步骤

查看类

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

查看构造方法

• public String() ：初始化新创建的 String对象，以使其表示空字符序列。

• public String(char[] value) ：通过当前参数中的字符数组来构造新的String。

• public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。

构造举例，代码如下：

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

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

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

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

1.3 常用方法

判断功能的方法

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

方法演示，代码如下：

package com.itmei.day08.demo02;

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

public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
注意事项：
1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐："abc".equals(str)    不推荐：str.equals("abc")
因为如果变量值为null时，会报空指针异常NullPointerException

public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。
 */
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):比较字符串的内容是否相同
        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
        System.out.println("=================");

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐：false
//        System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException
        System.out.println("=================");
        
		//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写

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

}

Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中

获取功能的方法

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

方法演示，代码如下
前面4个获取的相关方法：

package com.itmei.day08.demo02;

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

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

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

// String concat (String str):将将指定的字符串连接到该字符串的末尾.
        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，新的字符串
        System.out.println("==============");
        
// char charAt(int index):获取指定索引处的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);
        System.out.println("==============");

 // int indexOf(String str): 查找参数字符串在本来字符串当中出现的第一次索引位置（从1开始的）
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是：" + index); // 2

        System.out.println("HelloWorld".indexOf("abc")); // -1
    }

}

后面2个截取方法

package com.itmei.day08.demo02;

/*
字符串的截取方法：

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，新字符串
        System.out.println("================");
        
// String substring(int start,int end):从start到end截取字符串。含start，不含end。
        String str3 = str1.substring(4, 7);
        System.out.println(str3); // oWo
        System.out.println("================");

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

}

转换功能的方法

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

方法演示，代码如下：

package com.itmei.day08.demo02;

/*
String当中与转换相关的常用方法有：

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。
 */
public class Demo04StringConvert {

    public static void main(String[] args) {
        //char[] toCharArray(): 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        System.out.println("==============");

        // byte[] getBytes (): 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==============");

        //public String replace： 字符串的内容替换
        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*?
        System.out.println("==============");

        String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！
    }

}

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

分割功能的方法

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

方法演示，代码如下：

package com.itmei.day08.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]);
        }
        System.out.println("===============");

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        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.println(array3[i]);
        }
        System.out.println("===============");


        String str4="&user=15&age=25";
        String[] array4=str4.split("&");
        for (int i = 0; i < array4.length; i++) {
            System.out.println(array4[i]);
        }
    }

}

1.4 String类的练习

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

package com.itmei.day08.demo02;

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

分析：
1. 首先准备一个int[]数组，内容是：1、2、3
2. 定义一个方法，用来将数组变成字符串
三要素
返回值类型：String
方法名称：fromArrayToString
参数列表：int[]
3. 格式：[word1#word2#word3]
用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
4. 调用方法，得到返回值，并打印结果字符串
 */
public class Demo06StringPractise {

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};

        String result = fromArrayToString(array);
        System.out.println(result);//[word1@word2@word3@word4]
    }

    public static String fromArrayToString(int[] array) {
      String str="[";
        for (int i = 0; i < array.length; i++) {
            if (i==array.length-1){
                //最后一个元素
                str+="word"+array[i]+"]";
            }else{
                str+="word"+array[i]+"@";
            }
        }
        return str;
    }

}

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

package com.itmei.day08.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);
    }

}

运行结果：

2. static关键字

2.1 概述

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

2.2 定义和使用格式

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

• 类变量：使用 static关键字修饰的成员变量。

定义格式：

static 数据类型  变量名;

举例：

static int numberID;

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

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

public class StuDemo { 
	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 返回值类型 方法名 (参数列表){ 
		// 执行语句
	 }

举例：在Student类中定义静态方法

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

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

• 静态方法可以直接访问类变量和静态方法。

• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。

• 静态方法中，不能使用this关键字。原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

提示：静态方法只能访问静态成员。
代码举例

package com.itmei.day08.demo03;

public class MyClass {

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

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

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

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

}

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

// 访问类变量
 类名.类变量名； 
 // 调用静态方法 
 类名.静态方法名(参数)；

调用演示，代码如下：

public class StuDemo2 { 
	public static void main(String[] args) { 
		// 访问类变量 
		System.out.println(Student.numberOfStudent); //访问Student的学生人数变量
		// 调用静态方法 
		Student.showNum(); 
	} 
}

2.3 静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。

• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

• 它优先于对象存在，所以，可以被所有对象共享。

2.4 静态代码块

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

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

格式：

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

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

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类

3.1 概述

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

3.2 操作数组的方法

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

package com.itmei.day08.demo04;

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        int[] num={10,20,30};
        // 打印数组,输出地址值
        System.out.println(num); // [I@1b6d3586
        
        //将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(num);
        System.out.println(intStr);//[10, 20, 30]
    }
}

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

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

3.3 练习

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

package com.itmei.day08.demo04;

import java.util.Arrays;

/*
题目：
请使用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.print(chars[i]+" "); //w v v v s s q j h g f f f d d a a a 7 6 
        }
    }

}

4.Math类

4.1 概述

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

4.2 基本运算的方法

• 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

4.3 练习

请使用 Math 相关的API，计算在 -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. 一旦发现了一个数字，需要让计数器++进行统计。

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
    }

}