API
1 API介绍
API: application Programming Interfaces 应用程序接口
https://docs.oracle.com/en/java/javase/17/docs/api/index.html
https://doc.qzxdp.cn/jdk/17/zh/api/index.html
2 Object
package cn.javasm.demo;
/**
* @className: TestDemo
* @author: gfs
* @date: 2025/9/1 9:34
* @version: 0.1
* @since: jdk17
* @description:
*/
public class TestDemo implements Cloneable{
int i;
public static void main(String[] args) throws Throwable {
TestDemo testDemo1 = new TestDemo();
testDemo1.i = 20;
// CloneNotSupportedException:任何一个对象想要被克隆，那么这个对象对应的类需要实现Cloneable接口
// alt + 回车
TestDemo obj = (TestDemo) testDemo1.clone();
System.out.println(testDemo1.i);
System.out.println(obj.i);
// 获取对象真正的运行时的类型
Object obj1 = "abc";
Class<?> aClass = obj1.getClass();
System.out.println(aClass);
Object obj2 = new Object();
// 获取对象的哈希码值
// 哈希码是根据哈希散列算法计算出来的一个值
// 根据哈希散列算法，哈希码会随机散落在将近43亿个值上
// 人为的认为同一个类的不同对象的哈希码是唯一的
// 往往会根据哈希码来决定对象的内存存储
System.out.println(obj2.hashCode());
String string = obj2.toString();
System.out.println(string);// java.lang.Object@4eec7777
System.out.println(obj2);
Person person = new Person("丁真",23,"理塘");
System.out.println(person);
}
}
重写equals
// 重写equals方法
// 如果两个对象的属性值都相同，返回true
@Override
public boolean equals(Object obj) {
// 判断地址是否一致
if (this == obj){
return true;
}
// 判断参数是否是null
if (obj == null){
return false;
}
// 判断类型是否是Person
if (this.getClass() != obj.getClass()){
return false;
}
Person person = (Person) obj;
// 比较属性值是否相同
if (this.id != person.id){
return false;
}
if (this.age != person.age){
return false;
}
if (this.name == null){
if (person.name != null){
return false;
}
}else if (!this.name.equals(person.name)){
return false;
}
if (this.address == null){
if (person.address != null){
return false;
}
}else if (!this.address.equals(person.address)){
return false;
}
return true;
}
-
定义一个类User，提供username和password属性，重写equals方法
public class User {
private String username;
private String password;
public boolean equals(Object obj){
// 比较地址是否相同
if (this == obj) return true;
// 先判断obj是否是null 再判断类型是否一致
if (obj == null || getClass() != obj.getClass()) return false;
// 强制转换类型
User user = (User) obj;
return Objects.equals(this.username,user.username) && Objects.equals(this.password,user.password);
}
}
3 String类
字符串是常量，保存在常量池中。字符串一旦改变，地址会发生改变。本质上的字节数组并没有改变。
-
字符串中的+=
private static void demo2() {
String s1 = "ab";
String s2 = "a" + "b";
String s3 = "a";
s3 += "b";
// StringBuilder sb = new StringBuilder("a");
// sb.append("b");
// String s3 = sb.toString(); 共产生5个对象 sb "a" "b" "ab" toString()中一个
System.out.println(s3);
System.out.println(s1 == s2);// true
System.out.println(s1 == s3);// false
}
-
字符串拼接面试题
// 获取计算机元年到当前时间的毫秒值
long startTime = System.currentTimeMillis();
String str = "";
for (int i = 0; i < 1000000; i++) {
str += "a";
}
// StringBuilder stringBuilder = new StringBuilder();
// for (int i = 0; i < 1000000; i++) {
// stringBuilder.append("a");
// }
// String str = stringBuilder.toString();
long endTime = System.currentTimeMillis();
System.out.println(endTime - startTime);
-
常用方法
String str = "abc";
// StringIndexOutOfBoundsException:字符串越界异常
char c = str.charAt(2);
System.out.println(c);
// 获取字符串的长度
int length = str.length();
System.out.println(length);
// 字符串可以转换成字符数组 ['a','b','c']
char[] charArray = str.toCharArray();
System.out.println(charArray);
char[] chs = {'h','e','l','l','o'};
// 把字符数组转换成字符串
String string = new String(chs);
System.out.println(string);
// 截取一部分组成字符串
// offset 截取开始的索引
// count 截取的长度
String string1 = new String(chs, 2, 3);
System.out.println(string1);
课堂练习:
-
输入一个字符串以及两个数字，按照输入的数字对字符串进行截取
-
grdgdgdsg 3 6 表示从字符串的索引为3的位置截取到索引为6的，但是包头不包尾 [3,6)
-
private static void method01() {
// 输入一个字符串以及两个数字，按照输入的数字对字符串进行截取
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
int begin = scanner.nextInt();
int end = scanner.nextInt();
if (begin < 0 || begin > end || end > str.length()){
return;
}
// 把字符串转换成字符数组
char[] charArray = str.toCharArray();
// 截取数组
String sub = new String(charArray,begin,end - begin);
System.out.println(sub);
}
-
统计字符串中大写小写数字的个数
private static void method02() {
// 统计字符串中大写小写数字的个数
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
// 大写字符
int upperCount = 0;
// 小写字符
int lowerCount = 0;
// 数字字符
int numCount = 0;
for (int i = 0;i < str.length();i++){
// 获取每一个字符
char c = str.charAt(i);
if (c >= 'A' && c <= 'Z'){
upperCount++;
}else if (c >= 'a' && c <= 'z'){
lowerCount++;
}else if (c >= '0' && c <= '9'){
numCount++;
}
}
System.out.println(upperCount);
System.out.println(lowerCount);
System.out.println(numCount);
}
-
输入字符串，提取其中的数字并求和 verg8regerg9regregr0
private static void method03() {
// 输入字符串，提取其中的数字并求和
String str = new Scanner(System.in).next();
// 把字符串转换成字符数组
char[] charArray = str.toCharArray();
// 遍历字符数组并求和
int sum = 0;
for (char c : charArray) {
if (c >= '0' && c <= '9'){
sum += (c - '0');
}
}
System.out.println(sum);
}
-
输入字符串，统计每一个字符出现的次数
-
aaaabbc a 4 b 2 c 1
-
private static void method04() {
// 输入字符串，统计每一个字符出现的次数
String str = new Scanner(System.in).next();
// 定义布尔数组
boolean[] bs = new boolean[str.length()];
for (int i = 0; i < bs.length; i++) {
// 判断是否被标记过
if (bs[i]) continue;
// 获取字符
char c = str.charAt(i);
// 定义出现的次数
int count = 0;
for (int j = i;j < str.length();j++){
if (str.charAt(j) == c){
count++;
bs[j] = true;
}
}
System.out.println(c + ":" + count);
}
}
-
常用方法
// 字符串底层是以字节数组形式存储的
// 在比较两个字节数组的时候，是进行逐位比较的
// 如果对应的位置上两个字符比较之后不相等，立即返回两个字符之差
// 如果相等，则依次比较下一位
// 如果每一位的字符都相等，则返回两个长度之差
// 如果返回一个正数，说明 对象 > 参数
// 如果返回一个负数，说明 对象 < 参数
int i = str.compareTo("abc");
System.out.println(i);
private static void method05() {
// 冒泡排序
String[] arr = {"faker","uzi","ewgfe","frgtr","wef"};
for (int i = 1;i < arr.length;i++){
for (int j = 1;j <= arr.length - i;j++){
if (arr[j - 1].compareTo(arr[j]) > 0){
String temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
instanceof -- 用于判断类和对象的关系
对象 instanceof 类/接口 -- 只要这个对象的实际类型是类的子类，或者自身，或者是接口的实现类，就返回true
interface A{}
class B implements A{}
class C extends B{}
class D extends C{}
C c = new D();
c instanceof A -- true
c instanceof B -- true
c instanceof C -- true
c instanceof D -- true
JDK17特性:模式匹配
Object obj = "abc";
if (obj instanceof String s){
char c = s.charAt(1);
System.out.println(c);
}
String str1 = new String("abc");
// 逐位进行字符串的比较
System.out.println(str1.equals(str));
-
常用方法
public static void main(String[] args) throws UnsupportedEncodingException {
String str1 = "羊肉串";
String str2 = "ABC";
// 忽略大小写比较
int i = str1.compareToIgnoreCase(str2);
System.out.println(i);
// 忽略大小写比较
boolean b = str1.equalsIgnoreCase(str2);
System.out.println(b);
// 转换成大写
System.out.println(str1.toUpperCase());
// 转换成小写
System.out.println(str2.toLowerCase());
// 拼接字符串
String hello = str1.concat("abd");
System.out.println(hello);
// 拼接字符串
String join = String.join("-", "谷丰硕", "30", "河南洛阳", "牛马");
System.out.println(join);
// 判断字符串是否包含某一个子串
boolean contains = str1.contains("bc");
System.out.println(contains);
// 判断是否是以...结尾
boolean endsWith = str1.endsWith(".png");
System.out.println(endsWith);
// 判断是否是以...开头
boolean startsWith = str1.startsWith("https://");
System.out.println(startsWith);
// 将字符串转换成字节数组 默认以当前的项目编码为准
byte[] bytes = str1.getBytes();
System.out.println(bytes.length);// 9
// 按照指定的编码转换成字节数组
byte[] bytes1 = str1.getBytes("gbk");
System.out.println(bytes1.length);// 6
System.out.println(str1.length());// 3
// 把字节数组转换成字符串 默认以当前的项目编码为准
// String string = new String(bytes1);
// 把字节数组转换成字符串并且指定编码格式
// String string = new String(bytes1,"gbk");
// 截取字节数组的一部分转换成字符串，并且指定编码格式
String string = new String(bytes1,2,4,"gbk");
System.out.println(string);
}
课堂练习:输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串(GBK)
public static void main(String[] args) throws UnsupportedEncodingException {
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
int n = scanner.nextInt();
// 先将字符串转换成字节数组
byte[] bytes = str.getBytes("gbk");
if (n < 0 || n > bytes.length){
return;
}
// 按照指定的字节个数进行截取
String sub = new String(bytes,0,n,"gbk");
// 判断是否出现了中文乱码
int index = sub.length() - 1;
if (str.charAt(index) != sub.charAt(index)){
sub = new String(bytes,0,n - 1,"gbk");
}
System.out.println(sub);
}
-
常用方法
// 字符串的哈希码值是固定不变的
String str = " hello world ";
System.out.println(str.hashCode());
// 获取指定元素首次出现的索引 如果找不到，返回-1
System.out.println(str.indexOf('e'));
// 从fromIndex向后找对应子串首次出现的位置
System.out.println(str.indexOf("ca",3));
String str1 = new String("abc");
// intern()方法表示强制返回这个字符串的字面量
System.out.println(str == str1.intern());
// 判断字符串是否为空 判断底层字节数组长度是否为0
if (str.isEmpty()){
System.out.println("底层的字节数组长度是0");
}
// // 判断字符串是否为空 如果字符串中都是空格，也认为是空
System.out.println(str.isBlank());
System.out.println(str.getBytes().length);
// 找指定元素最后一次出现的索引 找不到返回-1
// int lastIndexOf = str.lastIndexOf('a');
// int lastIndexOf = str.lastIndexOf("ab");
// 从fromIndex向前寻找首次出现的索引
int lastIndexOf = str.lastIndexOf("ab",4);
System.out.println(lastIndexOf);
// 重复字符串
String repeat = str.repeat(3);
System.out.println(repeat);
// 用newChar替换oldChar
String replace = str.replace('a', 'w');
System.out.println(replace);
// 从beginIndex截取字符串
String substring = str.substring(1);
System.out.println(substring);
// 从beginIndex截取到endIndex 包头不包尾
String substring1 = str.substring(1, 5);
System.out.println(substring1);
// 获取路径中的文件名
String substring2 = str.substring(str.lastIndexOf("\\") + 1);
System.out.println(substring2);
// 去除字符串两端的空格
String trim = str.trim();
System.out.println(trim);
// 把不同的类型转换成字符串
String string = String.valueOf(new Object());
String string1 = String.valueOf(10);
System.out.println(string1);
4 正则表达式
4.1 基本用法
package cn.javasm.demo;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @className: TestDemo4
* @author: gfs
* @date: 2025/9/2 15:02
* @version: 0.1
* @since: jdk17
* @description:
*/
public class TestDemo4 {
public static void main(String[] args) {
String str = "a";
// // 判断一个字符串是否是abc
Pattern pattern = Pattern.compile("abc");
// // 将规则和要判断的字符串进行关联
// Matcher matcher = pattern.matcher(str);
// // 进行判断
// System.out.println(matcher.matches());
// 匹配一个字符串
// 第一个字符: a/b/c
// 第二个字符: q/w/e/r
// 第三个字符: 6/7/8
// Pattern pattern = Pattern.compile("[abc][qwer][678]");
// Matcher matcher = pattern.matcher(str);
// System.out.println(matcher.matches());
// 用字符串直接匹配 []中的顺序无所谓
boolean matches = str.matches("[abc][qwer][678]");
System.out.println(matches);
// 判断由一个小写字母组成的字符串
// 只要字符是连续的区间，可以使用- a-n m-x
System.out.println(str.matches("[a-z]"));
// 匹配由一个字母组成的字符串
System.out.println(str.matches("[a-zA-Z]"));
// 匹配由一个数字组成的字符串
System.out.println(str.matches("[0-9]"));
// 匹配由一个字符组成的字符串，这个字符不是a/b/c
System.out.println(str.matches("[^abc]"));
// . 通配符，可以匹配任意字符
// 匹配由3个字符组成的字符串
// 开头是数字，结尾是字母
System.out.println(str.matches("\\d.[a-zA-Z]"));
// 匹配 .
System.out.println(str.matches("\\."));
// 匹配 \
System.out.println(str.matches("\\\\"));
}
}
4.2 数量词
package cn.javasm.demo;
import java.util.Scanner;
/**
* @className: TestDemo5
* @author: gfs
* @date: 2025/9/2 15:43
* @version: 0.1
* @since: jdk17
* @description:
*/
public class TestDemo5 {
public static void main(String[] args) {
String str = "6";
// ab abb abbb abbbb abbbb...
// + 表示之前的字符至少出现1次 >=1
System.out.println(str.matches("ab+"));
// 匹配由字母开头后续是数字的字符串
System.out.println(str.matches("[a-zA-Z]\\d+"));
// 由数字作为开头和结尾的字符串
// * 表示之前的字符可有可无 >=0
System.out.println(str.matches("\\d.*\\d"));
// 匹配一个不超过两位的数字组成的字符串
// ? 表示之前的字符最多出现一次 <=1
System.out.println(str.matches("\\d\\d?"));
// 匹配由5个数字组成的字符串
// {n} : 表示这个字符出现恰好是n次 == n
System.out.println(str.matches("\\d{5}"));
// 匹配由至少5个数字组成的字符串
// {n,}: 表示这个字符至少出现n次 >= n
System.out.println(str.matches("\\d{5,}"));
// 匹配由5-8个数字组成的字符串
// {n,m}: 表示这个字符要出现至少n次，但不超过m次 >= n <= m
System.out.println(str.matches("\\d{5,8}"));
System.out.println(checkPassword("JKLgrg5645"));
// 判断一个字符串中是否连续出现3个及以上的数字
System.out.println(str.matches(".*\\d{3}.*"));
// 判断字符串中是否出现了2个及以上的数字
System.out.println(str.matches(".*\\d.*\\d.*"));
}
// 输入一个字符串作为密码，要求6-12位。其中大写字母/小写字母/数字/空格至少出现2种
private static boolean checkPassword(String password) {
// 匹配密码长度和内容
if (!password.matches("[a-zA-Z\\d ]{6,12}")){
return false;
}
// 记录字符出现的类型的次数
int count = 0;
// 判断是否出现了小写字母
if (password.matches(".*[a-z].*")){
count++;
}
// 判断是否出现了大写字母
if (password.matches(".*[A-Z].*")){
count++;
}
// 判断是否出现了数字
if (password.matches(".*\\d.*")){
count++;
}
// 判断是否出现了空格
if (password.matches(".* .*")){
count++;
}
return count >= 2;
}
// 输入一个字符串，判断这个字符串是否是一个小数
// 1.0是 1.000 是 00.23 不是 10. 不是 -0.20是
private static void method() {
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
System.out.println(str.matches("-?0\\.\\d+") | str.matches("-?[1-9]\\d*\\.\\d+"));
}
}
4.3 捕获组
package cn.javasm.demo;
import java.util.Arrays;
import java.util.Scanner;
/**
* @className: TestDemo6
* @author: gfs
* @date: 2025/9/2 16:45
* @version: 0.1
* @since: jdk17
* @description:
*/
public class TestDemo6 {
public static void main(String[] args) {
String str = "few8grgr9gr:::**##g7rfef6efef5fe";
// 匹配一个字符串是否含有2个及以上的"tyhyrgbrtjt"
System.out.println(str.matches(".*tyhyrgbrtjt.*tyhyrgbrtjt.*"));
// () 在正则中表示一个捕获组
// 捕获组可以看作一个字符进行操作
System.out.println(str.matches(".*(tyhyrgbrtjt).*\\1.*"));
// 正则表达式会对捕获组进行自动编号
// \\n 表示引用编号为n的捕捉组
// 编号是从1开始计算的
// 捕获组的编号是从(出现的位置开始计算的
// (A((BC)D(E))F)(G)
// \\1 A((BC)D(E))F
// \\2 (BC)D(E)
// \\3 BC
// \\4 E
// \\5 G
// 判断叠字
System.out.println(str.matches("(.)\\1+"));
// AABB
System.out.println(str.matches("(.)\\1(.)\\2"));
// ABAB
System.out.println(str.matches("(..)\\1"));
// 把字符串中所有的数字替换成 -
System.out.println(str.replaceAll("\\d","-"));
// 提取字符串中所有的数字
System.out.println(str.replaceAll("\\D",""));
// 替换字符串中所有的非字母
System.out.println(str.replaceAll("[^a-zA-Z]",""));
String str1 = "小龙女 杨过 欧阳锋 洪七公";
// 交换字符串的内容
System.out.println(str1.replaceAll("(.*)(杨过)(.*)(洪七公)","$1$4$3$2"));
// 把字符串中的叠字替换成单字
String str2 = "我我我我我爱爱爱爱爱爱学学学学学学习习习习习习习习";
System.out.println(str2.replaceAll("(.)\\1+","$1"));
// method2();
String str3 = "grg#gfdg#ggg#grg";
// 通过指定的元素分割字符串
String[] split = str3.split("#");
for (String string : split) {
System.out.println(string);
}
String str4 = "regrg8gregeg9regergerg7grgrg";
String[] split1 = str4.split("\\d");
for (String string : split1) {
System.out.println(string);
}
}
// 输入一个字符串，然后统计每一个字符出现的次数 aaabbca
private static void method2() {
String str = new Scanner(System.in).next();
// 如果字符串有内容，那么就继续替换
while (str.length() != 0){
// 获取替换之前字符串的长度
int len = str.length();
// 获取字符串中的第一个字符
char c = str.charAt(0);
// 把字符替换成""
str = str.replaceAll(c + "","");
System.out.println("字符" + c + "出现的个数为" + (len - str.length()));
}
}
// 输入一个字符串，提取其中的数字并排序
public static void method(){
String str = new Scanner(System.in).next();
// 提取数字
str = str.replaceAll("\\D","");
// 将字符串转换成字符数组进行排序
char[] charArray = str.toCharArray();
Arrays.sort(charArray);
System.out.println(charArray);
}
}
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
