API

概念

API（Application Programming Interface，应用程序接口）是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.
API是一种通用功能集,有时公司会将API作为其公共开放系统,也就是公司制定自己的系统接口标准,当需要进行系统整合,自定义和程序应用等操作时,公司所有成员都可以通过该接口标准调用源代码.

  1. Java.util包是java中的工具包,包含各种实用工具类/集合类/日期时间工具等各种常用工具包
    import java.util.Scanner;
    import java.util.Arrays;
  2. java.lang包是java的核心,包含了java基础类
    包括基本Object类/Class类/String类/基本数学类等最基本的类,这个包无需导入,默认会自动导入
    import java.lang.Object;
    import java.lang.String;
    import java.lang.StringBuilder/StringBuffer;
    正则表达式
    包装类等等

Object

概念

Object类是所有Java类的祖先,也就是说我们所说的”顶级父类”
它存在于java.lang.Object,这个包不需要我们手动导包
需要注意的是:每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.
在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.

常用方法

toString()

用于返回对应对象的字符串表示

重写前为地址值

重写后为对象属性与属性值

hashCode()

用于返回对应对象的哈希码值

返回该对象的哈希码值，用来区分不同的对象，不同对象生成的哈希码值不同，但是有时候也存在不同对象哈希码值相同的特殊情况,称之为”哈希碰撞”现象。

equals()

用于指示其他某个对象是否与当前对象“相等”

重写前比较两个对象地址值是否相等，底层使用==判断

重写后比较的四两个对象的：类型、属性、属性值

示例代码

  1. package cn.tedu.api;
  3. import java.util.Objects;
  5. /**
  6.  * 用于测试顶级父类Object
  7.  */
  9. public class TestObject {
  10.     public static void main(String[] args) {
  11.         Student student = new Student();
  12.         Student student1 = new Student("桂宏宇",28);
  13.         Student student2 = new Student("桂宏宇",28);
  14.         /*
  15.         重写前输出地址值
  16.         重写后输出对象属性与属性值
  17.          */
  18.         System.out.println(student);
  19.         System.out.println(student1);
  21.         /*
  22.         使用equals测试重写前两个对象地址值是否相等，底层使用==判断
  23.         重写后比较是的两个对象的类型+属性+属性值
  24.          */
  25.         System.out.println(student1 == student2);//false
  26.         System.out.println(student1.equals(student2));//true
  27.         System.out.println(student1 == student2);//false
  29.         /*
  30.         测试hashcode方法
  31.         返回该对象的哈希码值，用来区分不同的对象，不同对象生成的哈希码值不同
  32.          */
  33.         System.out.println(student.hashCode());
  34.         System.out.println(student1.hashCode());
  35.     }
  36. }
  38. class Student {
  39.     String name;
  40.     int age;
  42.     public Student(String name, int age) {
  43.         this.name = name;
  44.         this.age = age;
  45.     }
  47.     public Student() {
  49.     }
  51.     @Override
  52.     public String toString() {
  53.         return "Student{" +
  54.                 "name='" + name + '\'' +
  55.                 ", age=" + age +
  56.                 '}';
  57.     }
  59.     @Override
  60.     public boolean equals(Object o) {
  61.         if (this == o) return true;
  62.         if (o == null || getClass() != o.getClass()) return false;
  63.         Student student = (Student) o;
  64.         return age == student.age && Objects.equals(name, student.name);
  65.     }
  67.     @Override
  68.     public int hashCode() {
  69.         return Objects.hash(name, age);
  70.     }
  71. }

String

概念

String是一个封装char[]数组的对象,字符串不可变
通过下图中的底层实现可以看出:被final修饰,是常量
String str = “abc”; 等效于：char data[] = {‘a’, ‘b’, ‘c’};
image-20210714143916674.png

创建String对象的方式

方式一:
String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
方式二: String str = “abc”;

  1. 如果是第一次使用字符串，java会在字符串堆中常量池创建一个对象。
  2. 再次使用相同的内容时，会直接访问堆中常量池中存在的对象。

image-20210714144107015.png

示例代码

  1. package cn.tedu.api;
  3. public class TestString {
  4.     public static void main(String[] args) {
  5.         /*
  6.         字符串底层维护的是char[]数组，存放在堆中
  7.          */
  8.         char[] value = {'a','b','c'};
  9.         String s1 = new String(value);//触发含参构造来创建String对象
  10.         String s11 = new String(value);//触发含参构造来创建String对象
  12.         /*
  13.         底层也会new String()，存放在堆中的常量池中，效率高
  14.          */
  15.         String s2 = "abc";
  16.         String s22 = "abc";
  17.         String s3 = "aaa";
  19.         /*
  20.         "=="比较的时两个对象的地址值
  21.         equals()默认实现比较也是地址值，但String类重写了此方法，
  22.         不再比较地址值，而是比较内容，无论任何创建方式，只要串内容一致，equals()就会返回true
  23.          */
  24.         System.out.println(s1 == s2);//false
  25.         System.out.println(s1 == s11);//false
  26.         System.out.println(s2 == s22);//true
  27.         System.out.println(s2 == s3);//false
  28.         System.out.println(s1.equals(s2));//true
  29.         System.out.println(s1.equals(s11));//true
  30.         System.out.println(s2.equals(s3));//false
  31.     }
  32. }

常见方法

  1. int hashCode() 返回此字符串的哈希码。
  2. boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容
  3. String toString() 返回此对象本身（它已经是一个字符串！）
  4. length()-查看字符串的长度
  5. charAt()—获取指定下标处位置上的字符
  6. indexOf()返回指定字符在此字符串中第一次出现的索引
  7. lastIndexOf()-某个字符最后一次出现的位置
  8. concat()将指定字符串连接\拼接达到此字符串的结尾，不会改变原串
  9. substring(int beginIndex, int endIndex)-截取子串,返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标[1,5)
  10. substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标
  11. equals()-判断两个串是否相等,注意String重写了Object的此方法,所以内容相同就返回true
  12. startsWith()-判断是不是以指定元素开头
  13. endsWith()–判断是不是以指定元素数结尾
  14. split()—以指定字符分割
  15. trim()-去掉首尾两端的空格
  16. getBytes()-把串转换成数组
  17. toUpperCase()-变成全大写
  18. toLowerCase()-变成全小写
  19. String.valueOf(10)-把int类型的10转换成String类型

示例代码

  1. package cn.tedu.api;
  3. import java.util.Arrays;
  4. import java.util.Locale;
  6. /**
  7.  * 测试String常用方法
  8.  */
  10. public class TestString2 {
  11.     public static void main(String[] args) {
  12.         String s = "abc";
  14.         char[] value = {'a','b','c','d'};
  15.         String ss = new String(value);
  17.         /*
  18.         测试常用方法
  19.          */
  20.         System.out.println(s.charAt(0));//a,获取指定下标处的字符
  22.         String s2 = s.concat("桂宏宇");//用于拼接字符串，但不会改变原字符串
  23.         System.out.println(s);//abc,不会改变原串
  24.         System.out.println(s2);//abc桂宏宇,打印的是拼接后s2指向的串abc桂宏宇
  26.         System.out.println(s.concat("桂宏宇"));//abc桂宏宇
  27.         System.out.println(s.endsWith("宇"));//false，判断是否以指定元素结尾
  28.         System.out.println(s.startsWith("a"));//true，判断是否以指定元素开头
  30.         System.out.println(s.length());//3，获取字符串长度与数组的length不同，数组的length为属性
  32.         System.out.println(s == ss);//false,比较地址值
  33.         System.out.println(s.equals(ss));//true,比较内容
  35.         System.out.println(s.indexOf("b"));//1，获取指定元素首次出现的下标值
  36.         ss = "abcbb";
  37.         System.out.println(ss.lastIndexOf("b"));//获取指定元素最后一次出现的下标值
  39.         //根据指定规则分割字符串，返回值类型为数组String[]，需要使用数组工具类打印
  40.         String s3 = "a b c d e";
  41.         System.out.println(s3.split(" "));//[Ljava.lang.String;@1b6d3586
  42.         System.out.println(Arrays.toString(s3.split(" ")));
  44.         /*
  45.         根据下标截取子串，如果只有一个下标，从指定位置处开始截取，包含指定下标位置的元素
  46.         若有两给下表，截取这两个下标之间的字串，含头不含尾
  47.          */
  48.         System.out.println(s3.substring(3));// c d e
  49.         System.out.println(s3.substring(1,5));// b c
  51.         System.out.println(s3.toUpperCase());//A B C D E,把指定字符串转换为全大写
  52.         System.out.println(s3.toLowerCase());//a b c d e，把指定字符串转换为全小写
  54.         s3 = "     abcde     ";
  55.         System.out.println(s3.trim());//abcde，去除指定字符串的首尾空格
  57.         System.out.println(String.valueOf(10));//10，转换为字符串10
  58.         System.out.println("20" + 10);//2010，字符串拼接
  59.         System.out.println(String.valueOf(20) + 21);//2021
  60.     }
  61. }

StringBuilder/StringBuffer

特点

封装了char[]数组
是可变的字符序列
提供了一组可以对字符内容修改的方法
常用append()来代替字符串做字符串连接”+”
内部字符数组默认初始容量是16：super(str.length() + 16);
如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全

方法

append()

示例代码

  1. package cn.tedu.api;
  3. /**
  4.  * 联系字符串拼接
  5.  */
  7. public class TestString3 {
  8.     public static void main(String[] args) {
  9.         //需求，拼接打印26个小写字母1w次
  11.         String str = "abcdefghijklmnopqrstuvwxyz";
  12.         //method(str);//普通字符串拼接
  13.         method2(str);//高效字符串拼接
  14.     }
  16.     private static void method2(String str) {
  17.         StringBuilder sb = new StringBuilder();
  18.         StringBuffer sb2 = new StringBuffer();
  19.         System.out.println(sb);
  21.         long t1 = System.currentTimeMillis();
  22.         for (int i = 0;i < 10000;i++){
  23.             //sb.append(str);
  24.             sb2.append(str);
  25.         }
  26.         long t2 = System.currentTimeMillis();
  27.         System.out.println("拼接结果为" + sb2);
  28.         System.out.println(t1);
  29.         System.out.println(t2);
  30.         System.out.println("花费时间为" + (t2-t1));
  31.     }
  33.     private static void method(String str) {
  35.         String str2 = "";
  36.         long t1 = System.currentTimeMillis();
  37.         for (int i = 0;i < 10000;i++){
  38.             str2 += str;
  39.         }
  40.         long t2 = System.currentTimeMillis();
  41.         System.out.println("拼接结果为" + str2);
  42.         System.out.println(t1);
  43.         System.out.println(t2);
  44.         System.out.println("花费时间为" + (t2-t1));
  45.     }
  46. }