目录
内容提要
- 掌握String类的构造方法和常用成员方法
- 掌握static关键字的使用方法和静态代码块
- 能够使用Arrays类操作数组
- 能够使用Math类进行简单的数学运算
String
了解一个类最好的方法就是查阅API文档，今后的开发过程中，我们需要学会自己去分析一些类，所以在查看后续内容之前，如果时间富足，最好自己前去查阅API，掌握正确的Java学习方法。
概述
API文档描述
String 类代表字符串。Java 程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。
解析：
字符串一经创建不可修改
String s = "abc";
s += "d";
System.out.println(s); // "abcd"
//内存中有"abc"，"abcd"两个对象，s1从"abc"指向了"abcd"字符串可以被共享
String s1 = "abc";
String s2 = "abc";
//内存中只有一个"abc"对象，s1和s2共享"abc"对象字符串效果相当于char数组，但底层原理是byte字节数组
使用
构造方法
- public String()：初始化新创建的 String对象，以使其表示空字符序列。
- public String(char[] value)：通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes)：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
- String str = "xxx"：直接创建
举例：
// 无参构造
String str1 = new String（）；
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
// 直接构造
String str4 = "abc";字符串常量池
字符串常量池：直接写上的双引号字符串常量池中，通过new产生的字符串不在。
比较运算符==：对于基本类型，“==”是进行数值的比较；对于引用类型，“==”是进行地址值的比较
public class String01String {
public static void main(String[] args) {
//字符串比较
String str5 = "abc";
String str6 = "abc";
char[] array3 = {'a', 'b', 'c'};
String str7 = new String(array3);
System.out.println(str5 == str6);//true
System.out.println(str5 == str7);//false
System.out.println(str6 == str7);//false
/* Principle Analysis:
* Stack:
* String str5 --> addr1
* String str6 --> addr1
* char[] array3 --> addr2
* String str7 --> addr3(char[] array3 --> byte[])
* Heap:
* String constant pool:
* (String object inside)
* addr1: "abc" --> byte[] {97, 98, 99}
* addr2: char[] array3 {'a', 'b', 'c'}
* addr3: (String object, not in pool) String str7 --> byte[] {97, 98, 99}(convert from char[] array3)
* */
}
}常用方法
字符串比较
“==”是进行地址值比较，如果需要进行字符串比较，可以使用两个方法：
public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串且内容相同才返回true
注： a)任何对象都能使用equals方法；
b)equals具有对称性，a.equals(b)与b.equals(a)等效
c)如果比较双方一个常量一个变量，推荐将常量写在前面（"constant".equals(str)），否则可能出现空指针异常
public boolean equalsIgnoreCase(String str)：忽略大小写进行字符串比较
字符串中获取相关方法
public int length()：获取字符串长度
public String concat(String str)：将当前字符串与参数字符串str拼接，返回拼接后的字符串
public char charAt(int index)：返回索引处的单个字符
public int indexOf(String str)：返回参数字符串在当前字符串中首次出现的索引位置，没有则返回-1
字符串截取方法：
public String substring(int index)：截取从index开始到结束的字符串
public String substring(int begin, int end)：截取[begin,end)的字符串，左闭右开
字符串转换方法：
public char[] toCharArray()：将字符串拆分为字符数组并返回
public byte[] getBytes()：获取字符串对应的底层字节数组
public String replace(CharSequence oldString, CharSequence newString)：将字符串中的老字符串替换为新字符串并返回CharSequence表示可以接受字符串类型
字符串分割
public String[] split(String regex)：按参数的规则将字符串分割成若干部分，参数其实是正则表达式，如果是按"."分割，则参数为"\\."。
举例：
public class String02Method {
public static void main(String[] args) {
String str1 = "abc";
char[] array1 = {'a', 'b', 'c'};
String str2 = new String(array1);
String str3 = "ABC";
System.out.println(str1.equals(str2));//true
System.out.println(str1.equalsIgnoreCase(str3));//true
String str4 = str1.concat(str3);//str1,str2均未发生改变
System.out.println(str4);//abcABC
System.out.println(str4.length());//6
System.out.println(str4.charAt(2));//c
System.out.println(str4.indexOf(str3));//3
String str5 = str4.substring(3);
String str6 = str4.substring(2, 5);
System.out.println(str5);//ABC
System.out.println(str6);//cAB
char[] array2 = str4.toCharArray();
byte[] array3 = str4.getBytes();
for (int i = 0; i < array2.length; i++) {
//a b c A B C
//97 98 99 65 66 67
System.out.println(i + ": " + array2[i] + " - " + array3[i]);
}
str4 = str4.concat(str4);
str4 = str4.replace(str1, str3);
System.out.println(str4);//ABCABCABCABC
String[] array4 = str4.split("C");
for (int i = 0; i < array4.length; i++) {
//AB AB AB AB
System.out.println(array4[i]);
}
}
}static关键字
概述
static 关键字可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，可以不靠创建对象来调用，可以使用类直接调用。
使用
类变量
定义：使用static关键字修饰的成员变量。
格式：
static 数据类型 变量名;类方法
定义：使用static关键字修饰的成员方法，习惯称为静态方法。
格式：
修饰符 static 返回值类型 方法名 (参数列表){
// 执行语句
}
注意：
- 静态不能直接访问非静态，内存中先有静态内容，后有非静态内容
- 静态方法中不能用this，this代表当前对象，静态与对象无关
调用
// 访问类变量
类名.类变量名;
// 调用静态方法
类名.静态方法名(参数);举例
Student类，供后面所有代码使用
public class Student {
static String classroom;
private static int idCount = 0;//学号计数器
private int id;//学号
private String name;
private int age;
public Student() {
this.id = idCount++;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCount;
}
public static void staticMethod() {
System.out.println("Static Method!");
}
public void normalMethod() {
System.out.println("Normal Method!");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
类变量、类方法使用举例
public class Static01StaticField {
public static void main(String[] args) {
Student s1 = new Student("Susan", 18);
Student.classroom = "101";
Student s2 = new Student("Tom", 19);
Student s3 = new Student("Jack", 20);
System.out.println("Name: " + s1.getName() + " age: " + s1.getAge() + " ID: " + s1.getId() + " Classroom: " + Student.classroom);
Student.classroom = "102";
System.out.println("Name: " + s2.getName() + " age: " + s2.getAge() + " ID: " + s2.getId() + " Classroom: " + Student.classroom);
System.out.println("Name: " + s3.getName() + " age: " + s3.getAge() + " ID: " + s3.getId() + " Classroom: " + Student.classroom);
//普通方法必须通过对象调用，静态方法可以使用类调用也可以使用对象调用，且最好使用类调用，静态变量同理
//对于本类中的静态方法，则也可以直接调用，而不需要ClassName.StaticMethod()
s1.normalMethod();
Student.staticMethod();
Student.staticMethod();
}
}
原理
结合例子，在代码中展示原理
public class Static02Memory {
public static void main(String[] args) {
Student s1 = new Student("Susan", 18);
Student.classroom = "101";
//根据类名称访问静态变量时，全程与对象无关，只和类有关
/*
* Method Area:
* static area:
* classroom --> "101"
* Student.class {
* private String name;
* private int age;
* static String classroom;
* }
* Stack:
* Student s1 --> addr1
* Student.classroom = "101"(static area: classroom --> "101")
* Heap:
* addr1: new Student()
* name --> "Susan"
* age --> 18
* */
}
}静态代码块
定义在成员位置，使用static修饰的代码块{ }。位于类中方法外，随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
使用格式：
/**
* 第一次用到类时，静态代码块执行唯一的一次，静态内容总是优先于非静态
* 典型用法：用来一次性地对静态成员变量进行赋值。
*/
public class ClassName{
static {
body//静态代码块
}
}Arrays类
概述
java.util.Arrays此类包含用来操作数组的各种方法，比如排序和搜索等，所有方法均为静态方法。
常用方法
public static String toString(Array)：将参数数组转换为默认格式字符串并返回（[element1,element2,...]）
public static void sort(Array)：将参数数组升序排列
注：1.如果是数值，sort默认升序排列
2.如果是字符串，则按字符字母升序（先使用toCharArray变成数组）
3.如果是自定义类型，则必须有Comparable或Comparator接口支持
使用
直接使用类名调用即可
package Array;
import java.util.Arrays;
import java.util.Random;
public class Array05Arrays {
public static void main(String[] args) {
int[] array1 = new int[10];
Random r = new Random();
for (int i = 0; i < array1.length; i++) {
array1[i] = r.nextInt(100);
}
Arrays.sort(array1);
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + " ");
}
String str = "HelloWorldHelloJava";
char[] array2 = str.toCharArray();
Arrays.sort(array2);
for (int i = array2.length - 1; i >= 0; i--) {
System.out.print(array2[i] + " ");
}
}
}
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)：四舍五入
使用
直接使用类名调用即可
public class MathMethod {
public static void main(String[] args) {
System.out.println(Math.abs(-3.14));
System.out.println(Math.ceil(3.14));
System.out.println(Math.floor(3.14));
System.out.println(Math.round(3.14));
}
}
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
