11.JDK_API文档使用、String类、Object类、Math类、Arrays类、System类等常用API

API简介

API : Application Programming Interface 应用程序编程接口 
    别名 : 开发文档,学习编程的词典

JDK_API文档使用方法

 

 

 

键盘录入字符串

Scanner 类中 :

录入整数的方法
    int nextInt()
    
录入字符串的方法
    String nextString()
    
    String next()  -> 能录入字符串但是遇到了空格之后就不录入了
    String nextLine() -> 一次录入一行字符串
    
nextLine的小问题 : 当先录入其他类型的数据再录入字符串数据时,会出现上一次录入的"\r\n"换行符被作为录入的字符串,程序会不让你继续录入字符串;
    解决方案 : 一个Scanner对象只录入一种类型的数据
    
三种操作系统的换行符:
        windows : "\r\n"
        Linux : "\n"
        MacOS : "\r"    

随机数中seed参数的含义

Random(long seed)  : Random带有种子参数的构造方法 
    long seed : 指定了每一次随机数的值,当重复执行同一颗种子的随机数生成,生成随机数序列一致

 String类

String 类 : 字符串 -> 引用数据类型 (Java中最特殊的引用数据类型) 

特点 :
    1. 只要是双引号引起来的内容都是 String 类的对象 -> "hello"
    2. 字符串是Java中唯一一个不需要 new 就可以创建的对象 -> String str = "hello";
    3. 字符串是Java中唯一一个既是常量也是对象的 "东西";
    4. 字符串也是不能变的,如果改变字符串的内容那就一定生成了新的字符串 --> 所以字符串的拼接是非常消耗内存的;        "Java" + "Hello" + "World" -> 解决问题 : StringBuilder/StringBuffer
    5. 字符串可以共用的 (常量可以共用)
    6. 字符串的本质是 一个字符数组; "abc"  -> char[] chs = {'a','b','c'};
    7. 字符串的本本质是 一个字节数组:  "abc"  -> byte[] bys = {97,98,99};
    8. 字符串是Java唯一一个可以做加法运算的对象 -> 加法是做拼接

计算机中最小的存储单元 : byte 字节 B
计算机中最小的信息单元 : bit 比特 b -> 二进制 0 / 1

String类的构造方法

1. 直接赋值 : String str = "任意内容";

2. 创建一个空的(没有任何字符的)字符串对象 : String()  -> 没有意义
3. 传入一个字符串对象,把字符串对象封装成字符串对象 : String(String original) -> 没有意义

char[] --> String 
4. 把传入的字符数组的内容封装成字符串对象 : String(char[] value) 
5. 把传入的字符数组的一部分内容封装成字符串对象 : String(char[] value, int offset, int count) 
        int offset : 起始索引 int count : 转几个
        
byte[] --> String        
6. 把传入的字节数组的内容封装成字符串对象 : String(byte[] bytes)     
7. 把传入的字节数组的一部分内容封装成字符串对象 : String(byte[] bytes, int offset, int length)

public class Demo {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";

        String str3 = new String("Hello");
        String str4 = new String("Hello");

        char[] chs = {'H','e','l','l','o'};
        String str5 = new String(chs);
        String str6 = new String(chs);

        System.out.println(str1 == str2);//true
        System.out.println(str1 == str3);//false
        System.out.println(str1 == str5);//false
        System.out.println(str3 == str4);//false
        System.out.println(str3 == str5);//false
        System.out.println(str5 == str6);//false
    }
}

 

String类的比较功能

//校验用户名和密码
 boolean equals(Object anObject)  : 判断调用方法的字符串对象和传入的字符串对象内容是否相同
 //校验验证码 
 boolean equalsIgnoreCase(String anotherString)  : 判断调用方法的字符串对象和传入的字符串对象内容是否相同   (忽略大小写)  

equals 源码分析

equals 源码分析 : 
	/*
		阅读源码的技巧 :
			1. 大局观
			2. 连蒙带猜
	*/
	public boolean equals(Object anObject) {//Object anObject : 利用了多态
        //第一板块
        if (this == anObject) {
            //this : 调用方法的字符串对象
            //anObject : 形参接收的实参
            // == : 比较2个对象的地址值
            // 比较调用方法对象的地址值和传入方法对象的地址值是否相同!! -> 自己比自己(提高效率)
            return true;//能进这个if 说明2个对象的地址值相同,说明是同一个对象,直接返回true
        }
        //能从第一板块下来说明 : this 和 anObject 不是同一个对象
        //第二板块
        //anObject instanceof String : 判断anObject是否是String类型的对象
        // 1. 提高代码的效率 2. 提高代码的安全性
        if (anObject instanceof String) {
            //向下转型 : 向下转型有风险 -> ClassCastException : 类型转换异常
            //能进第二板块的 if ,说明 anObject 一定是 String 类型
            
            String anotherString = (String)anObject;//把实参转换回String类型
            
            //成员变量 value : 字符串对象的底层字符数组
            int n = /*this.*/value.length; // n : 获取调用方法字符串对象的字符个数
            
            //这个if 判断 : 调用方法字符串的长度和传入方法字符串的长度是否相等 -> 提高效率的
            if (n == anotherString.value.length) {
                //能进if : a. 实参肯定是字符串 b. 实参和调用方法的字符串 长度一致
                
                //把调用方法字符串底层数组复制给 v1 -> 调用方法的字符串对象
                char v1[] = /*this.*/value;
                //把传入方法字符串底层数组复制给 v2 -> 传入方法的字符串对象
                char v2[] = anotherString.value;
               
                //遍历数组 -> 遍历字符串 : 当每一个位置的字符都相等说明 2个字符串内容一致!!
                
                int i = 0;//循环的初始化语句,用来控制循环的
                while (n-- != 0) { //n-- != 0 -> 循环的判断条件语句
                    
                    // 判断 v1数组的i索引字符 和 v2数组的i索引字符是否不相同 -> 反向逻辑
                    if (v1[i] != v2[i]){
                        //只要有一个索引位置的字符内容不相同就返回false
                        return false;
                    }  
                    i++;//i 索引变化
                }
                
                //如果能从循环出来,说明2个字符串对象的每一个字符都相同,equals方法就返回true
                return true;
            }
        }
        //第三板块 : 能执行第三板块说明 调用方法的对象和传入的实参不是同一个对象,且实参对象的类型不是String类型 或者 传入的字符串和调用方法的字符串长度 不相同
        return false;
    }

String类的获取功能

//遍历字符串 : 拿到字符串中的每一个字符
char charAt(int index) : 获取字符串对象指定索引位置的字符 "Hello"
int length() : 获取字符串对象的长度/字符的个数  

 //第一次出现
 int indexOf(int ch) : 获取传入的字符第一次出现在字符串的索引位置,不存在返回-1
     //int ch : 既传入 字符 也可以传入 字符对应的ASCII
 int indexOf(String str) :  获取传入的字符串第一次出现在调用方法字符串的索引位置,不存在返回-1
    
 int indexOf(int ch, int fromIndex)  : 从fromIndex索引开始算第一次出现 ch 的索引位置
 int indexOf(String str, int fromIndex)     
    
 //最后一次出现 : lastIndexOf   
 int lastIndexOf(int ch) 
 int lastIndexOf(String str)   
    
 int lastIndexOf(int ch, int fromIndex)  
 int lastIndexOf(String str, int fromIndex)    

String类的判断功能

boolean contains(CharSequence s) : 判断传入的字符串是否包含于原字符串中
     CharSequence : String , StringBuilder/StringBuffer 父接口
   
boolean startsWith(String prefix)  : 判断字符串是否以prefix开头 -> 判断姓氏
boolean endsWith(String suffix)  : 判断字符串是否以 suffix结尾 -> 判断文件类型
 
boolean isEmpty()  : 判断字符串是否是空字符串 -> "" 

String类的替换功能

String replace(char oldChar, char newChar) : 把原字符串中oldChar字符全部变成newChar,生成新的字符串对象

String replace(CharSequence target, CharSequence replacement)  :把原字符串中target字符串全部变成replacement字符串,并生成新的字符串对象

String类的截取功能

 String substring(int beginIndex)  : 从beginIndex索引开始截取原字符串到原字符串的结尾,生成新的字符串对象 --> [beginIndex,字符串的长度-1]

 String substring(int beginIndex, int endIndex) :    从beginIndex索引开始截取原字符串到 endIndex - 1 索引,生成新的字符串对象 --> [beginIndex,endIndex)

String类的切割功能

String[] split(String regex)  : 按照传入的字符串切割原字符串,得到切割后的字符串数组
    regex : 切割的刀
    第一层含义 : 按什么切就传入什么 -> 百分之90的情况
    第二层含义 : regex -> 正则表达式
        解决办法 : 如果不小心触犯到了正则语法, 解决方案是 转义字符

String类的匹配功能

 boolean matches(String regex) : 判断调用方法的字符串是否符合传入的正则规则

String类的其他功能

String concat(String str) : 把传入的字符串连接到调用方法的字符串上并生成新的字符串 
         -> 为什么不用 + 呢?
String toString() : 把调用方法的字符串对象转换成字符串对象;
     
String trim() : 去除字符串对象两端的空格并生成新的字符串 

static String valueOf(任意类型的数据) : 把任意类型的数据转换成字符串类型 -> 不常用
     1. 任意类型的数据 + ""
     2. 任意类型的对象.toString()

StringBuilder/StringBuffer

StringBuilder/StringBuffer : 字符串缓冲区类  -> "可变字符串"
    在对象的内部开辟缓冲区,对字符串的改变全在缓冲区完成不生成新的字符串
    
StringBuilder 提供一个与 StringBuffer 兼容的 API，但不保证同步.    
    兼容的 API : 代表这2个类的功能一样
    不保证同步 : StringBuilder 效率高,安全性低 / StringBuffer 效率低,安全性高 (前提是 : 在多线程环境下)
        
构造方法 : 

StringBuilder() : 创建一个内容为空的StringBuilder对象
    //String ---> StringBuilder
StringBuilder(String str) : 创建一个内容为str的StringBuilder对象 

    
成员方法 :

int capacity()  : 获取sb对象的容量
int length()  : 获取sb对象的长度
    
StringBuilder append(任意类型的数据) : 把传入的内容拼接到原sb对象上,并返回sb自己
StringBuilder insert(int offset, 任意类型的数据)  : 在sb对象指定位置插入第二个参数数据,并返回sb自己
StringBuilder reverse()  : 把sb对象的内容一键翻转并返回sb自己
    
char charAt(int index)  : 获取指定索引位置上的字符
int indexOf(String str) : 获取str在sb中第一次出现的索引位置
int lastIndexOf(String str) : 获取str在sb中最后一次出现的索引位置  
    
StringBuilder replace(int startIndex, int endIndex, String str)  : 把sb对象中startIndex到endIndex的全部内容替换成str,并返回sb自己 -> [startIndex,endIndex - 1]
    
String substring(int start) : 截取sb对象中的内容 [start,长度-1]
String substring(int start, int end)  : 截取sb对象中的内容 [start,end-1] 

     
转换问题 : 
    //String ---> StringBuilder
    StringBuilder(String str) : 创建一个内容为str的StringBuilder对象 
    
    //StringBuilder --> String
    1. sb对象 + "";
    2. sb对象.toString()

Arrays.toString(任意类型的数组) 的源码分析

Arrays.toString(任意类型的数组) 的源码 :
	public static String toString(int[] a) {
        //第一板块 : 非空校验 保证程序安全性
        if (a == null)
            return "null";
        
        //第二板块 : a数组的最大索引数
        int iMax = a.length - 1;
        
        //第三板块 : 判断a数组是否是空数组
        if (iMax == -1)
            return "[]";

        //第四板块 : 真正漂亮打印的代码
        StringBuilder b = new StringBuilder();
        //拼开头 
        b.append('[');
        //死循环 -> for循环的死循环
        for (int i = 0;/*true*/; i++) {
            //拼接数组元素
            b.append(a[i]);
            //考虑是否是最后一个元素
            if (i == iMax){
                //能进来说明是最后一个元素
                return b.append(']').toString();
            }
            //从上面的if下来了,说明不是最后一个元素
            b.append(", ");
        }
    }

Object类

Object : Java中所有类直接或者间接的父类 -> 超类,基类,根类

构造方法 : Object()
    
成员方法 :

Class<?> getClass()  : 获取对象所在类的字节码对象

int hashCode() : 获取对象的哈希值 (对象10进制的地址值) 

Object类中的toString()方法

String toString() : 把调用方法的对象转换成字符串

toString方法的源码 -> Object
    public String toString() {
        /*
            this: 调用方法的对象
            this.getClass() : 获取调用方法对象的字节码对象
            this.getClass().getName() : 获取调用方法对象的字节码对象的名称 (对象所在类的全类名)
            
            @ : 分隔符
            
            /*this.*/hashCode() : 获取调用方法对象的10进制地址值
            //Integer.toHexString(对象10进制地址值) : 把对象10进制地址值转换成16进制
        
        */
 return /*this.*/getClass().getName() + "@" + Integer.toHexString(/*this.*/hashCode());
    }

注意 :
    1. 直接输出对象名使用是对象.toString()

    2. 需求是 : 输出对象的时候不想看到对象的全类名+地址值,而是想看到对象的属性值

    解决方案 : 重写toString方法,让其返回属性值的拼接内容    

    3. 输出对象就应该看到对象的全类名 + 16进制的地址值,只要不是这个内容,说明这个对象所在的类重写了toString()

Object类中的equals()方法

Object类中的equals()方法 : 比较2个对象
    1. 子类没有重写 : 比较2个对象的地址值
    2. 子类可以重写 : 希望比较对象的时,比较的时对象的属性值而不是地址值
        
equals()方法的源码:

public boolean equals(Object obj) {
        //调用方法的对象 == 传递进方法的实参对象
        return (this == obj);
    }

事物描述类的标准编写步骤

1. 私有所有属性

2. 自动生成无参构造

3. 自动生成全参构造

4. 自动生成getter and setter方法

5. 自动生成equals()方法和hashCode()方法

6. 自动重写toString()方法

Objects类

Objects类 : 工具类 -> 做非空校验的工具类 -> JDK7

静态方法 :

static boolean isNull(Object obj)  : 判断传入的对象是否是 null (是null 返回true,不是null 返回false)
static boolean nonNull(Object obj)  :判断传入的对象是否不是 null (是null 返回false , 不是null 返回true)
    
static boolean equals(Object a, Object b)  : 对a对象进行非空校验,再调用a的equals方法比较b    		源码 : false || (a != null && a.equals(b))
        
static int hashCode(Object o)  : 对o对象做非空校验,再调用o的hashCode方法  
    	源码 : o != null ? o.hashCode() : 0
            
static String toString(Object o) : 对o进行非空校验,再调用o的toString方法(如果o为null返回字符串null)
    	源码 : (o == null) ? "null" : o.toString();

static String toString(Object o, String nullDefault)  :对o进行非空校验,再调用o的toString方法(如果o为null返回字符串nullDefault)
        源码 :(o != null) ? o.toString() : nullDefault

Math类

Math类 : 关于数学运算的工具类型 -> 三角函数,log,随机数,取整...
    
自定义常量 :

public static final double E = 2.7...; -> 自然对数的底数  
public static final double PI = 3.1415926535...; -> 圆周率 

静态成员方法 : 

static int abs(int a) : 求a的绝对值 
static double cbrt(double a)  : 返回 double 值的立方根。
    
static double ceil(double a) : 天花板 -> 向上取整 
static double floor(double a) : 地板 -> 向下取整
static long round(double a) : 四舍五入
    
static int max(int a, int b)  : 求a,b的最大值
static int min(int a, int b)  : 求a,b的最小值
    
static double pow(double a, double b) : 求a的b次幂 
    
static double random()  : 生成一个随机数 [0,1.0)

Arrays类

Arrays类 : 关于数组操作的工具类

静态成员方法 :

static String toString(任意类型的数组) : 漂亮打印数组
static void sort(基本数据类型数组)  : 对数组内容进行排序(默认的自然升序) -> 快速排序
static void sort(引用数据类型数组)  : 对数组内容进行排序 //引用数据类型元素要提供排序规则
    
static int binarySearch(int[] a, int key)  : 使用二分查找法对key元素进行查找,找key在a数组中的索引位置; //注意 : 二分查找法有前提条件 -> 序列有序
    
static int[] copyOf(int[] original, int newLength) : 复制original数组中的所有内容到一个新的长度为newLength的数组中,返回新数组的地址值
    
static int[] copyOfRange(int[] original, int from, int to) : 复制老数组original中from索引到to索引的元素到新数组中,返回新数组的地址值 --> [from,to)
 
static boolean equals(int[] a, int[] a2) : 比较2个数组的内容是否相同;                               
static void fill(int[] a, int val)  : 把val元素填充到a数组中

System类

System类 : 关于系统操作的工具类

自定义常量 :

static PrintStream out : 标准的系统输出流对象 -> 只打印内容到控制台
static InputStream in : 标准的系统输入流对象 -> 只做键盘录入
static PrintStream err  : 标准系统错误输出流对象 -> 只打印内容到控制台 (以红色字体打印,开启一个新的线程进行打印)

静态成员方法 : 

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  : 数组复制
         Object src : 源数组
         int srcPos : 源数组复制的起始索引位置
         Object dest : 目标数组
         int destPos : 目标数组起始接收的索引位置 
         int length : 复制几个元素
    
static void exit(int status) : JVM退出 
         continue : 退出本轮次的循环,从下一轮次的循环步进表达式开始执行
         break : 结束整个循环或者switch
         return : 结束方法
         System.exit(状态码) : 立刻结束JVM //状态码 : 非0即为异常退出
         
static long currentTimeMillis()  :     返回当前时间毫秒值
         当前时间的毫秒值 - 时间原点(0)
        时间原点 : 1970年01月01日 08:00:00  -> 东八区   
        时间原点 : 1970年01月01日 00:00:00  -> 零时区  
            //32位操作系统能表示的时间范围是 +- 68年多