第八天：String类、static关键字、Arrays类、Math类
String类、static关键字、Arrays类、Math类
1.String类
- java.lang.string 代表字符串
- API当中说，java程序中的所有字符串字面值（如“abc”）都可以被看作是实现此类的实
例 - 字符串的特点
- 字符串的内容永不可变。【重点】
- 正是因为字符串不可改变，所有字符串是可以共享使用的
- 字符串效果上相当于是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); // 第二个字符串：ABC
// 根据字节数组创建字符串
byte[] byteArray = {65,97,99};
String str3 = new String(byteArray);
System.out.println("第三个字符串：" + str3); // 第三个字符串：Aac
// 直接创建
String str4 = "Hello";
System.out.println("第四个字符串：" + str4); // 第四个字符串：Hello
}
}
注意事项
- 字符串常量池，程序当中直接写上双引号的字符串，就在字符串常量池中
- new 的不在常量池中
- 对于基本数据类型来说，==是进行述职的比较
- 对于引用数据类型来说，==是进行【地址值】的比较
实例
public class Demo02StringPool {
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(str1 == str2); // true
System.out.println(str1 == str3); // false
System.out.println(str2 == str3); // false
}
}
- “==”是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法
- public boolean equals(Object obj); 参数可以是任何对象
- 只有参数是一个字符串并且内容相同才会返回true，否则返回false
- 注意事项：
- 任何对象都能用equals方法进行比较
- equals方法具有对称性，也就是 a.equals(b) 和 b.equals效果一样
- 如果比较双方一个常量一个变量，推荐把常量字符串写在前面
- 推荐："abc.equals(str)"
- public boolean equalsIgnoreCase(string str); 忽略大小写进行比较
- public boolean equals(Object obj); 参数可以是任何对象
实例
public class Demo01StringEquala {
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(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("==================");
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
}
}
- 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) {
String str = "hsdfkahsdlkfsfl";
System.out.println("字符串的长度是" + str.length()); // 字符串的长度是15
// 拼接字符串
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 ch = "Hello".charAt(1);
System.out.println("在1号索引位置的字符串是：" + ch); // 在1号索引位置的字符串是：e
System.out.println("=========");
// 查找参数字符串在本来字符串当中出现的第一次索引位置
// 如果根本没有，返回-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 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 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
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
}
}
- String当中与转换相关的常用方法
- public char[] toCharArray; 将当前字符串拆分成为字符串数组作为返回值
- public byte[] getByte(); 获得当前字符串的字节数组
- public String replace(CharSequence oldString,CharSequence newString); 将所有出现的老字符串替换为新的字符串，返回替换之后的结果新字符串
- 备注：CharSequence 意思就是说可以接受字符串类型
实例
public class Demo04StringConvert {
public static void main(String[] args) {
char[] chars = "Hello".toCharArray();
System.out.println(chars[0]); // H
System.out.println(chars.length); // 5
System.out.println("===============");
// 转换为字节数组
byte[] bytes = "abc".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]); // 97 98 99
}
System.out.println("===============");
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); // 会不会玩儿呀！****！****！****！
}
}
- 分隔字符串的方法
- 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);
for (int i = 0; i < array3.length; i++) {
System.out.println(array3[i]);
}
}
/*
结果：
aaa
bbb
ccc
===========
aaa
bbb
ccc
===========
3
xxx
yyy
zzz
* */
}
- 题目：定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。 格式参照如下: [word1 #word2#word3]。|
/*
* 分析
* 1、首先准备一个int[] 数组，内容是：1,2,3
* 2、定义一个方法，用来将数组文字变成字符串
* 三要素
* 返回值类型：String
* 方法名称：fromArrayToString
* 参数列表：int[]
* 3、格式：[world1#world2#world3]
* 用到，for循环、字符串凭借、每个数组元素之前都有一个world字样、分隔使用的是#，区分一下是不是最后一个
* 4、调用方法，得到返回值，并且打印结果字样
* */
public class Demo06StringPractise {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4};
String str = fromArrayToString(a);
System.out.println(str); // [world1#world2#world3#world4]
}
public static String fromArrayToString(int[] array) {
String str = "[";
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
str = str.concat("world" + array[i] + "]");
} else {
str = str.concat("world" + array[i] + "#");
}
}
return str;
}
}
2.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() {
this.id = ++idCounter;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
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教室";
System.out.println("姓名" + one.getName() + ",年龄" + one.getAge()
+ "，教室" + one.room + "，学号" + one.getId());
// 姓名郭靖,年龄19，教室101教室，学号1
Student two = new Student("黄蓉",16);
System.out.println("姓名" + two.getName() + ",年龄" + two.getAge()
+ "，教室" + two.room + "，学号" + two.getId());
// 姓名黄蓉,年龄16，教室101教室，学号2
}
}
- 一旦使用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);
// 静态方法当中不能用this关键字
// System.out.println(this); // 错误写法
}
}
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass();
// 然后才能使用没有static关键字的内容
obj.method();
// 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名来调用
obj.methodStatic(); // 正确，不推荐
MyClass.methodStatic(); // 正确 推荐
// 对于本来当中的静态方法，可以省略类名称
myMehtod();
Demo02StaticMethod.myMehtod(); // 完全等效
}
public static void myMehtod() {
System.out.println("自己的方法！");
}
/*
结果：
这是一个成员方法
0
0
这是一个静态方法
0
这是一个静态方法
0
自己的方法！
自己的方法！
* */
}
public class Student {
private int id; // 学号
private String name; // 姓名
private int age; // 年龄
static String room;
private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++
public Student() {
this.id = ++idCounter;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
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 Demo03StaticStudent {
public static void main(String[] args) {
// 首先创建一下教室，这是静态的东西，应该通过类名称进行调用
Student.room = "101教室";
Student one = new Student("郭靖",20);
System.out.println("one的姓名：" + one.getName()); // one的姓名：郭靖
System.out.println("one的年龄：" + one.getAge()); // one的年龄：20
System.out.println("one的教室：" + Student.room); // one的教室：101教室
System.out.println("==========");
Student two = new Student("黄蓉",18);
System.out.println("two的姓名：" + two.getName()); // two的姓名：黄蓉
System.out.println("two的年龄：" + two.getAge()); // two的年龄：18
System.out.println("two的教室：" + Student.room); // two的教室：101教室
}
}
-
静态代码块
-
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();
}
/*
结果;
静态代码块！
构造方法执行！
构造方法执行！
* */
}
3.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};
// 将int[] 数组按照默认格式变成字符串
String intstr = Arrays.toString(intArray);
System.out.println(intstr); // [10, 20, 30]
int[] array1 = {2,1,3,10,6};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
String[] array2 = {"ccc","aaa","bbb"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
}
}
- 题目：请使用Arrays相关的API,将一个随机字符串中的所有字符升序排列，并倒序打印。
import java.util.Arrays;
public class Demo02ArraysPractise {
public static void main(String[] args) {
String str = "hfsakdjfhkBJJdb";
// 如何进行升序排列
// 必须是一个数组，才能用Arrays.sort方法
// String --> 数组，用toChartArray
char[] chars = str.toCharArray();
System.out.println(chars);
Arrays.sort(chars);
// 需要倒序遍历
for (int i = chars.length - 1; i >= 0; i--) {
System.out.print(chars[i]); // skkjhhffddbaJJB
}
}
}
4.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(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(3.9)); // 3.0
System.out.println(Math.floor(3.1)); // 3.0
System.out.println(Math.floor(3.0)); // 3.0
System.out.println("=============");
// 向上取整
System.out.println(Math.round(3.9)); // 4
System.out.println(Math.round(3.1)); // 3
System.out.println(Math.round(3.0)); // 3
System.out.println(Math.PI); // 3.141592653589793
}
}
- 题目：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个
public class Demo04MathPractise {
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++) {
if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
count++;
}
}
System.out.println("一共有：" + count); // 一共有：9
}
}
浙公网安备 33010602011771号