文章目录
字符串
字符串的特点
- 字符串的内容永不可变。【重点】
- 正是因为字符串不可改变，所以字符串是可以共享使用的。【节省内存】
- 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组。
字符串的常见3+1种方式
三种构造方法：
public String():创建一个空白字符串，不含有任何内容。
public String(char[] array):根据字符数组的内容，来创建对应的字符串。
public String(byte[] array):根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = “Hello”;
【注意】直接写上双引号，就是字符串对象。
public class Demo01String {
public static void main(String[] args) {
//使用空参构造
String str1 = new String();
System.out.println("第一个字符串：" + str1);
//根据字符数组创建字符串
char[] chararray = {'a', 'b', 'c'};
String str2 = new String(chararray);
System.out.println("第二个字符串：" + str2);
//根据字节数组来创建字符串
byte[] bytearray = {97, 98, 99, 100};
String str3 = new String(bytearray);
System.out.println("第三个字符串：" + str3);
//直接创建
String str4 = "Hello";
System.out.println("第四个字符串：" + str4);
}
}字符串的常量池
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中
对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
内存图
字符串常用方法
字符串之间的比较
==是进行对象的地址比较，如果确实需要字符串的内容比较，可以使用两个方法：
public boolean equals(Object obj):参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false
注意事项：
- 任何对象都能用Object进行接收
- equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一页
- 如果比较双方一个常量一个变量，推荐把常量字符串写在前面
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);
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(str3)); //true 这个更推荐！
String str4 = null;
System.out.println("abc".equals(str4));//false
// System.out.println(str4.equals("abc"));//报错：空指针异常
String strA = "Java";
String strB = "java";
System.out.println(strA.equals(strB)); //false
System.out.println(strA.equalsIgnoreCase(strB)); //true
}
}字符串的获取相关方法
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 = "dasfgjkshgfa".length();
System.out.println("字符串长度：" + length);
//拼接字符串
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
//获取指定索引的单个字符
char ch = "Hello".charAt(1);
System.out.println("在1号索引位置的字符："+ch);
String original = "HelloWorldHelloWorld";
int ind = original.indexOf("llo");
System.out.println(ind);
}
}
字符串的截取方法
有两种重载形式
public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end):截取从begin开始，一直到end结束，中间的字符串，包含左边，不包含右边
public class Demo03StringCut {
public static void main(String[] args) {
String str1 = "HelloWorld";
String str2 = str1.substring(5);
System.out.println(str2);
String str3 = str1.substring(5,8);
System.out.println(str3);
}
}字符串的转换相关方法
public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes()：获取当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString):
将所有出现的老字符串替换成新字符串，返回替换之后的结果新字符串
public class Demo04StringConvert {
public static void main(String[] args) {
//字符串拆分成字符数组
char[] chars = "Hello".toCharArray();
System.out.println(chars[2]);
//转换为字节数组
byte[] bytes = "abc".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);
}
//字符串的内容替换
String str1 = "How do you do?";
String str2 = str1.replace("o","*");
System.out.println(str1);
System.out.println(str2);
}
}字符串的分割方法
public String[] split(String regex)：按照参数的规则，将字符串切分成若干部分
注意事项：
split方法的参数其实是一个正则表达式
如果按照英文句点.划分，应该写成\.
public class Demo05StringSplit {
public static void main(String[] args) {
String str1 = "aaa,bbb,ccc";
String[] array = str1.split(",");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");//切不出来
for (int i = 0; i < array3.length; i++) {
System.out.println(array3[i]);
}
}
}static关键字——数据共享
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据
举个例子说明使用用途：
static关键字修饰成员
代码实现:
public class Student {
private int id;
private String name;
private int age;
static String room;
private static int idCounter = 0;//学号计数器，每当new了一个新对象的时候，计数器++
public Student() {
idCounter++; //新建一个对象，就会调用构造方法，计数器+1
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;//新建一个对象，就会调用构造方法，计数器+1
}
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 Demo01StaticField {
public static void main(String[] args) {
Student one = new Student("郭靖",19);
one.room = "101教室"; //多个对象共享同一个数据
Student two = new Student("黄蓉",16);
System.out.println("姓名："+one.getName()+" 年龄："+one.getAge()+" 教室："+one.room);
System.out.println("姓名："+two.getName()+" 年龄："+two.getAge()+" 教室："+one.room);
}
}static关键字修饰成员方法
一旦使用static修饰成员方法，那么就成了静态方法，静态方法不属于对象，而是属于类的
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它
无论是成员变量，还是成员方法，如果有了static，都推荐用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
【注意事项】
- 静态不能直接访问非静态
原因：因为在内存当中是【先】有静态内容，【后】有非静态内容 - 静态方法当中不能用this
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象
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);//错误
}
}public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass();
obj.method();
//对于静态方法来说，可以通过对象名进行调用，也可以通过类名称来调用
obj.methodStatic();//正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
MyClass.methodStatic();//正确，推荐
// 对于本类当中的静态方法，可以省略类名称
myMethod();
Demo02StaticMethod.myMethod();//完全等效
}
public static void myMethod(){
System.out.println("自己的方法");
}
}静态static的内存图
静态代码块
静态代码块的格式：
public class 类名称{
static{
//静态代码块的内容
}
}
特点：
当第一次用到本类时，静态代码块执行唯一的一次
原因：静态内容总是优先于非静态，所以静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性的对静态成员变量进行赋值。
public class Person {
static{
System.out.println("静态代码块执行！");
}
public Person(){
System.out.println("静态方法执行！");
}
}public class Demo04Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}结果
数组工具类Arrays
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3，…]）（感觉一般都是为了便于打印）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序
备注：
- 如果是数值，sort默认按升序从小到大
- 如果是字符串，sort默认按照字母升序
- 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。
public class Demo01Arrays {
public static void main(String[] args) {
int[] intArray = {10, 20, 30};
String intStr = Arrays.toString(intArray);
System.out.println(intStr);
int[] array1 = {2,4,1,4,2,3};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
String[] array2 = {"bbb","aaa","ccc"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));
}
}数学工具类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):四舍五入
Math.PI代表近似圆周率
public class Demo03Math {
public static void main(String[] args) {
System.out.println(Math.abs(-2.3));
System.out.println(Math.round(2.3));
System.out.println(Math.ceil(2.3));
System.out.println(Math.floor(2.3));
System.out.println(Math.PI);
}
}