面向对象编程之常用类总结

Object类

概述

类层次结构的根类，所有类都直接或者间接的继承自该类

构造方法

public Object() 子类的构造方法默认访问的是父类的无参构造方法

成员方法

public int hashCode() 返回对象的哈希码值

支持这种方法是为了散列表（数据结构中），如HashMap提供的那样。
注意：这里的哈希码值是根据哈希算法计算出来的一个值。这个值和地址有关系，但是这里返回的地址值并不是实际的地址值，现在可以简单理解为地址值的另外一种表现形式。

public final Class getClass() 返回的是该对象的类对象

（被final修饰的方法不能被重写，可以被继承，被使用）
返回此Object的运行时类，返回的类对象是被表示类的static synchronized方法锁定的对象
Class类：返回由类对象表示的实体的名称（类，接口，数组类，原始类型或void），作为String

public String toString() 返回对象的字符串表示形式。

一般来说， toString方法返回一个“textually代表”这个对象的字符串。
结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。
该toString类方法Object返回一个由其中的对象是一个实例，该符号字符`的类的名称的字符串@ ”和对象的哈希码的无符号的十六进制表示。 换句话说，这个方法返回一个等于下列值的字符串：

getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

Integer类：
public static String toHexString(int i)
返回整数参数的字符串表示形式，作为16位中的无符号整数。 将哈希值转化一个地址值。
注：看源码：光标放在方法名上，按住ctrl，左击鼠标

我们虽然掌握了toString()的方法使用，但是呢打印的一个结果是一个我们看不懂的地址值，换句话我们拿到这个结果没有意义，返回对象的字符串表示形式，实际上我们更想去看的是该对象中各个成员变量的值。恰好toString()方法是被public修饰的，也恰好它的返回值是String类型的，所以我们可以在其他类中对它做重写，今后无特殊情况不需要自己手写，自动生成即可。

一个标准类的4.0版本

成员变量：使用private关键字修饰
构造方法：一个无参。一个带所有参数的方法。
成员方法：setXxx(…)/getXxx()
toString()：自动生成即可，替代掉我们之前show方法。

public boolean equals(Object obj) 指示一些其他对象是否等于此。

通过观察源码发现：Object类中的equals方法实现底层依旧是==
public boolean equals(Object obj) {
return (this == obj);
}
而==比较引用数据类型的时候，比较是地址值，当地址值不一样的时候，返回的是false

protected void finalize() 用于垃圾回收的，什么时候回收，不确定

protected Object clone() 创建并返回此对象的副本。

执行特定的克隆工作。
其他包中的子类要想使用被protected修饰的方法，使用super关键字调用。
clone的方法Object执行特定的克隆操作。
首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。
一个类要想使用clone()，就必须实现Cloneable接口

通过观察API发现，Cloneable接口中没有常量，也没有抽象方法
类似于Cloneable一样，里面什么都没有的接口，我们称之为标记接口

补充

==与equals的区别：

==： 基本数据类型的时候：比较的是两个值是否一样
引用数据类型的时候：比较的是两个对象的地址值是否一样

equals: 只能比较的引用数据类型
实际开发的时候，调用equals方法更希望它比较的是成员变量的值是否一样
所以我们应该在子类中进行重写
不需要我们自己动手，自动生成即可

子类若是没有重写equals方法，使用的是父类Object类中的方法，比较的是地址值。
子类要是重写了equals方法，比较的是成员变量值是否相同

import jdk.nashorn.internal.parser.JSONParser;
public class StudentTest3 {
    public static void main(String[] args) {
        Student3 s1 = new Student3("周", 18);
        Student3 s2 = new Student3("周", 18);
        System.out.println(s1==s2); // false  因为地址值不同
        Student3 s3 = s1;
        System.out.println(s1==s3); // true    因为地址值相同
        System.out.println("==========================");
        System.out.println(s1.equals(s2)); // false //重写后true
        System.out.println(s1.equals(s3)); // true
        System.out.println(s1.equals(s1)); // true

        //虽然我们搞清楚了equals的比较方式，但是我们观察现实生活中，姓名一样，年龄一样，就说明是同一个人，应该返回的是true
        Student3 s4 = new Student3("王", 19);
        System.out.println(s1.equals(s4));
    }
}

浅拷贝和深拷贝

浅拷贝：
clone()属于浅拷贝
浅拷贝是指我们拷贝出来的对象的内部引用类型变量和原来的对象内部引用类型变量的地址值是一样的（指向的是同一个对象）

//拷贝前的demo与拷贝后demo的地址值做比较
//发现demo地址值是一样的
System.out.println(s1.getDemo().hashCode());
Student4 s4 = (Student4)obj;//向下转型
System.out.println(s4.getDemo().hashCode());
但是整个拷贝出来的对象和新对象不是同一个地址值。
System.out.println(s1.hashCode()); //1956725890
System.out.println(obj.hashCode()); //356573597

深拷贝：
全部拷贝对象的内容，包括内存的引用类型也进行拷贝，拷贝的时候，重新创建一个对象，成员变量值和原来被拷贝的一样。
但是后续再对拷贝后的引用数据类型变量做修改，不会影响到原来被拷贝的。

Scanner类

概述

用于键盘录入数据，在程序中使用

构造方法

public Scanner(InputStream source) 构造一个新的Scanner ，产生从指定的输入流扫描的值。流中的字节将使用底层平台的default charset转换为字符 。
java默认使用的编码是Unicode 万国码。
参数：InputStream source （InputStream指的是字节流类型）简单理解为键盘录入的数据
由于该类实在java.util包下，所以将来使用的时候，需要导包。

成员方法

1、获取键盘上的int类型的数据

nextInt()

2、获取字符串数据

next(): 不会接收到特殊字符
nextLine(): 会接收到特殊字符，如换行符\r\n \n \t

String类

概述

字符串是由多个字符组成的一串数据(字符序列),字符串可以看成是字符数组
通过观察API发现：
1、String代表的是字符串。属于java.lang包下，所以在使用的时候不需要导包
2、String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。(对象)
3、字符串不变; 它们的值在创建后不能被更改。字符串是常量，一旦被赋值，字符串本身不能被修改。

构造方法：

    public String()		String类中重写toString()方法
    public String(byte[] bytes)		根据一个字节数组创建出一个字符串对象
    public String(byte[] bytes,int offset,int length)		将字节数组中的一部分转化成字符串
    public String(char[] value)		将字符数组转成一个字符串
    public String(char[] value,int offset,int count)		将字符数组的一部分转成字符串
    public String(String original)	初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

注意：字符串是常量，它的值在创建后不能被改变

String s = “hello”; s += “world”; 请问s的值是什么？

String s = new String(“hello”)和String s = “hello”;的区别?

注意事项：
1、==比较引用数据类型的时候，比较的时候地址值
2、String类中使用equals方法比较的是字符串的值，因为String类中重写了equals方法

String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2)); //true

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);  // false
System.out.println(s1.equals(s2)); // true

String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3==s4);// false
System.out.println(s3.equals(s4)); // true

String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6); // true
System.out.println(s5.equals(s6)); // true

字符串相加：

1、字符串如果是变量相加，是先在常量池中开辟空间，然后再做拼接。
2、字符串如果是常量相加，是先相加，然后再去常量池中去找，如果找到了，就返回，如果没有找到就开辟新的空间，存储拼接后的值。

        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        String s4 = "hello"+"world";
        System.out.println(s3==s4); // true
        String s5 = s1+s2;//s1、s2看作变量
        System.out.println(s3==s5); // false
        System.out.println(s3==(s1+s2)); // false
        System.out.println(s3.equals(s1+s2)); // true

成员方法

判断功能：
>         boolean equals(Object obj)	比较字符串中的内容是否相同,区分大小写比较的
>         boolean equalsIgnoreCase(String str)	比较字符串中的内容是否相同,忽略大小写
>         boolean contains(String str)	判断大的字符串中是否包含小的字符串，如果包含，返回true，反之返回false，区分大小写
>         boolean startsWith(String str)		测试此字符串是否以指定字符串开头，区分大小写
>         boolean endsWith(String str)		测试此字符串是否以指定字符串结尾，区分大小写
>         boolean isEmpty()		判断字符串是否为空

注意：
今后在做字符串比较内容的时候，很容易出现NullPointerException空指针异常
前面调用方法的变量有可能是null值，所以今后，为了避免出现这样的问题，如果是变量1.equals(变量2)的时候，在做equals之前判断一下变量1是不是null
如果是一个变量1与字符串常量1做equals比较的时候，把字符串常量1放在前面调用方法，因为我们说过单独一个字符串也是一个String对象

        //需求：比较s6的值是否和s7的值一样
        String s6 = null;
        String s7 = "hello";
        if(s6!=null){
            if(s6.equals(s7)){
                System.out.println("是一样的");
            }
        }else {
            System.out.println("s6是null值");
        }

        //需求2：判断s6的值是否是hello
//        if(s6.equals("hello")){
//            System.out.println("是一样的");
//        }
        if("hello".equals(s6)){
            System.out.println("是一样的");
        }else {
            System.out.println("s6的值不是hello");
        }

> 获取功能：
    int length()	获取字符串的长度
    char charAt(int index)	返回指定索引处的字符【0<=index<=length()-1】
    int indexOf(int ch)	返回指定字符第一次出现的字符串内的索引
    int indexOf(String str)	返回指定子字符串第一次出现的字符串内的索引
    int indexOf(int ch,int fromIndex)	返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索
    int indexOf(String str,int fromIndex)	返回指定子字符串第一次出现的字符串内的索引，以指定的索引开始搜索
    String substring(int start)	从指定位置处截取字符串，包括开始截取的位置，截取到末尾
    String substring(int start,int end)	截取字符串的一部分出来，截取的串从start位置开始截取，截取到end-1的位置结束，左闭右开 [,)  含头不含尾

> 转换功能：
        byte[] getBytes()	将字符串转成字节数组
        char[] toCharArray()	将字符串转成字符数组
        static String.valueOf(char[] chs)	将字符数组转成字符串
        static String.valueOf(int i)	将int类型的数据转成字符串
        String toLowerCase()	将字符串中的内容全部转小写
        String toUpperCase()	将字符串中的内容全部转大写
        String concat(String str)	将小括号中str的字符串拼接到大字符串的后面
        public String[] split(String regex)	截取，例如求出字符串中的每一个单词

>         替换功能
            String replace(char old,char new)
            String replace(String old,String new)
        去除字符串两边空格
            String trim()
        按字典顺序比较两个字符串
            int compareTo(String str)
            int compareToIgnoreCase(String str)

String类中CompareTo的源码分析

String s6 = "hello"; // h的ASCII码值是 104
String s9 = "qwe";   // q的ASCII码值是 113
System.out.println(s6.compareTo(s9)); // -9

public int compareTo(String anotherString) {
    /*
        this -- s6 -- "hello"
        anotherString -- s9 -- "qwe"
    */
    int len1 = value.length; // 5
    int len2 = anotherString.value.length; // 3
    int lim = Math.min(len1, len2); // 3
    char v1[] = value; // "hello" --> char[]
    char v2[] = anotherString.value; // "qwe" --> char[]

    int k = 0;
    while (k < lim) { // 3
        char c1 = v1[k]; // h
        char c2 = v2[k]; // q
        if (c1 != c2) {
            return c1 - c2; // 104 - 113 = -9
        }
        k++;
    }
    return len1 - len2;
}
=================================================================================
String s6 = "hello";
String s10 = "hel";
System.out.println(s6.compareTo(s10));

public int compareTo(String anotherString) {
    /*
        this -- s6 -- "hello"
        anotherString -- s10 -- "hel"
    */
    int len1 = value.length; // 5
    int len2 = anotherString.value.length; // 3
    int lim = Math.min(len1, len2); // 3
    char v1[] = value; // "hello" --> char[]
    char v2[] = anotherString.value; // "hel" --> char[]

    int k = 0;
    while (k < lim) { // k的值：0,1,2,3
        char c1 = v1[k]; // h,e,l
        char c2 = v2[k]; // h,e,l
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2; // 5 - 3 = 2
}

练习

/*
       1：遍历获取字符串中的每一个字符
       2：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 */
public class StringTest1 {
    public static void main(String[] args) {
        String s = "javaMySqlHadoopHive12138";
        //遍历获取字符串中的每一个字符
        //将字符串转成字符数组
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        System.out.println("=================================================");
        //统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
        //1、定义三个变量统计三个结果
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //2、遍历字符数组得到每一个字符，判断每一个字符是属于哪一类
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (c >= 'A' && c <= 'Z') {
                bigCount++;
            } else if (c >= 'a' && c <= 'z') {
                smallCount++;
            } else if (c >= '0' && c <= '9') {
                numberCount++;
            }
        }
        System.out.println("大写字符的个数为：" + bigCount);
        System.out.println("小写字符的个数为：" + smallCount);
        System.out.println("数字字符的个数为：" + numberCount);
    }
}

import java.util.Locale;
/*
        把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
        举例："hADoopJava" --> "Hadoopjava"
            1、全部转小写
            2、获取第一个字符转大写
 */
public class StringTest2 {
    public static void main(String[] args) {
        String s = "hADoopJava";
        System.out.println("转换之前：" + s);

        //将字符串中的所有字符全部转小写
        String s1 = s.toLowerCase();
        //获取第一个字符
//        char s2 = s1.charAt(0);//基本数据类型不能调用方法
        String s2 = s1.substring(0, 1);
        //将第一个字符转大写
        String s3 = s2.toUpperCase();
        //获取除第一个字符以外的其他字符
        String s4 = s1.substring(1);
        //将转大写的字符与其余的字符做拼接
        String result = s3.concat(s4);
        System.out.println("转换之后：" + result);

        System.out.println("==================用链式编程转换==================");
        String result2 = s.substring(0, 1)
                .toUpperCase()
                .concat(s.substring(1).toLowerCase());
        System.out.println("转换之后：" + result2);
    }
}

/*
        把数组中的数据按照指定个格式拼接成一个字符串
        举例：int[] arr = {1,2,3};    输出结果：[1, 2, 3]

 */
public class StringTest3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String s = "";
        for(int i=0;i<arr.length;i++){
            String s1 = String.valueOf(arr[i]);
            if(i==0){
                System.out.print(s.concat("[").concat(s1).concat(","));
            }else if(i==arr.length-1){
                System.out.print(s.concat(s1).concat("]"));
            }else {
                System.out.print(s.concat(s1).concat(","));
            }
        }
        System.out.println(s);
    }
}

/*
        字符串反转
            举例：键盘录入”abc”      输出结果：”cba”
        分析：
            1、导包并创建键盘录入对象
            2、创建一个空的字符串
            3、将字符串转成字符数组
            4、倒着遍历，得到每一个字符
            5、将每次获取到的字符进行拼接
            6、输出
 */
import java.util.Scanner;
public class StringTest4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.next();
        //创建一个空的字符串
        String s1 = "";
        //将字符串转成字符数组
        char[] chars = s.toCharArray();
        //倒着遍历，得到每一个字符
        for (int i = chars.length - 1; i >= 0; i--) {
            //将每个字符转成字符串
            String s2 = String.valueOf(chars[i]);
//            System.out.println(s2);
            //将每次获取到的字符进行拼接
            s1 = s1.concat(s2);
        }
        System.out.println("倒序后的字符串为：" + s1);
    }
}

/*
        统计大串中小串出现的次数
        举例：在字符串” woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundasdqwdeqwdwdasvgwrefasjavajavajijijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunda”
        中java出现了5次

 */
public class StringTest5 {
    public static void main(String[] args) {
        //创建一个字符串
        String bigString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundasdqwdeqwdwdasvgwrefasjavajavajijijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunda";

        //定义要查找的小串：java
        String minString = "java";

        //定义一个变量统计小串出现的次数
        int count = 0;

        //在大串中找到小串第一次出现的位置
        int index = bigString.indexOf(minString);

        //也有可能第一次找的时候就没有找到
        if (index == -1) {
            System.out.println("该大串中没有小串" + minString);
        } else {
            while (index != -1) {
                count++;
                //截取字符串
                int startIndex = index + minString.length();
                bigString = bigString.substring(startIndex);
                //继续去找小串出现的位置索引
                index = bigString.indexOf(minString);
                System.out.println("找到了小串，截取后的大串为："+bigString);
            }
        }
        System.out.println("======================================================");

        System.out.println(minString + "在大串" + bigString + "中出现的次数为：" + count);
    }
}

StringBuffer类

概述

1、线程安全的（ 不安全，就是存在同步操作同一数据的行为，效率高。安全的时候，没有同步操作，效率低。在实际开发中，效率和安全着两个问题一直都是很难平衡的问题。）
生活中的例子：
线程安全的例子：银行的一些业务，电影院卖票，医院取号。
线程不安全的例子：视频会员，博客评论
2、线程安全的，StringBuffer是一个可变序列
3、StringBuffer又称之为字符串缓冲区，就把它当作一个字符串去操作，只不过它与String相比是可以修改内容的
4、在任何时间点，它包含着一些特定的字符序列，但是可以通过某些方法修改这字符序列的长度和内容
简单记忆：StringBuffer是一个线程安全的可变序列。

StringBuffer与String区别(面试题)：

1、StringBuffer的长度和内容都可以发生改变，String却不行
2、String每创建一个新的字符串都会开辟一个新的常量池区域
StringBuffer会提前给出容量，可以进行字符串的拼接，而不会重新弄开辟空间

StringBuffer的构造方法：

>public StringBuffer()  构造一个没有字符的字符串缓冲区，初始容量为16个字符。
>public StringBuffer(int capacity)  构造一个没有字符的字符串缓冲区和指定的初始容量。
>public StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。

> 添加功能
                public StringBuffer append(String str)
                    通过观察API发现，不光可以追加字符串，还可以是任意数据类型的追加到StringBuffer中
                public StringBuffer insert(int index,String str)
                	将字符串插入到此字符序列中

> 删除功能
            public StringBuffer deleteCharAt(int index)  删除指定索引处的字符,该序列缩短了一个char
            public StringBuffer delete(int start,int end)删除此序列的子字符串中的字符，子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。如果start等于end ，则不作任何更改。
			如果 index为负数或大于或等于length() ，index的值最大可以取到实际存储字符串的长度-1

常见的删除还有：remove,move,delete,drop,truncate

> 替换功能
                public StringBuffer replace(int start,int end,String str)
                用指定的String中的字符替换此序列的子字符串中的String 。左闭右开
                子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。
                第一子串中的字符被去除，然后指定String被插入在start 

> 反转功能
            public StringBuffer reverse()该字符序列被序列的相反代替。
            如果序列中包含任何替代对，则将它们视为单个字符进行反向操作

public class StringBufferDemo5 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("我爱你中国");
        System.out.println("反转之前：" + sb);

        System.out.println("反转之后：");
        StringBuffer sb2 = sb.reverse(); // 操作的是同一个StringBuffer对象
        System.out.println(sb);
        System.out.println(sb2);
    }
}

> 截取功能
>             public String substring(int start)
>             返回一个新的String ，不会改变原来StringBuffer中的数据,其中包含此字符序列中当前包含的字符的子序列。
>             public String substring(int start,int end)
>             返回一个新的String ，其中包含此序列中当前包含的字符的子序列。 子串起始于指定的start ，并扩展到索引号为end - 1 。含头不含尾 [start,end)

String与StringBuffer之间的转换

为什么要进行相互转换？
A–>B,将A转换成B,是为了使用B中的特有功能
B–>A,再将B转换成A,可能是引用最终的结果需要的是A类型的数据，所以还得转换回来
String --> StringBuffer

方式1：通过构造方法转换

String s="qwertyui";
StringBuffer sb1 = new StringBuffer(s);
System.out.println(sb1);

方式2：通过append()

StringBuffer sb2 = new StringBuffer();
sb2.append(s);
System.out.println(sb2);

StringBuffer --> String

方式1：toString()方法

StringBuffer sb3 = new StringBuffer("bigdata");
String s4 = sb3.toString();
System.out.println(s4);

方式2：subString

String s5 = sb3.substring(0);
System.out.println(s5);

方式3：String类的构造方法：String(StringBuffer buffer)
分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。

String s6 = new String(sb3);
System.out.println(s6);

面试题：String,StringBuffer,StringBuilder之间的区别

1、StringBuffer是线程同步安全的，数据安全，效率低。
StringBuilder不是线程同步安全的，数据不安全，效率高。
2、String的内容是不可改变的，StringBuffer和StringBuilder是可变序列。
3、StringBuffer中方法上有synchronized关键字。

面试题2：StringBuffer和数组的区别？

它们都可以被看作是一个容器，装一些数据。但是，StringBuffer里面的数据都是一个一个字符。
数组可以存放不同数据类型的数据，但是同一个数组只能存放同一种数据类型的数据。

探究String作为参数传递与StringBuffer作为参数传递的区别

 public class StringBufferDemo8 {
    public static void main(String[] args) {
//        //创建一个StringBuffer的对象
//        StringBuffer stringBuffer = new StringBuffer();
//        //创建一个StringBuilder的对象
//        StringBuilder stringBuilder = new StringBuilder();
        String s1 = "hello";
        String s2 = "world";
        System.out.println("s1: " + s1 + ",s2: " + s2);//s1: hello,s2: world
        change(s1, s2);//s1:world,s2:worldworld  注意对外面的值没有影响， 因为方法调用完就自动消失了，String的内容是不可更改的
        System.out.println("s1: " + s1 + ",s2: " + s2);//s1: hello,s2: world

        System.out.println("========================================");
        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println("sb1: " + sb1 + ",sb2: " + sb2); // hello world
        change(sb1, sb2);//sb1: worldworld,sb2: worldworld    方法调用完就自动消失了
        System.out.println("sb1: " + sb1 + ",sb2: " + sb2); // sb1: hello,sb2: worldworld
        //当多个StringBuffer作为参数传参的时候，谁发生了操作，谁就会受到影响‘
    }
    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;
        sb2.append(sb1);
        System.out.println("sb1: " + sb1 + ",sb2: " + sb2);
        //sb1: worldworld,sb2: worldworld
    }
    public static void change(String s1, String s2) {
        s1 = s2;//传递的是地址值
        s2 = s1 + s2;//变量相加先开辟空间
        System.out.println("s1: " + s1 + ",s2: " + s2);//s1:world,s2:worldworld
    }
}

//把数组拼接成一个字符串(用StringBuffer实现)
public class StringBufferTest1 {
    public static void main(String[] args) {
        //定义一个字符数组
        char[]chars={'a','b','n','x'};
        //创建一个空StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //遍历数组
        for(int i=0;i<chars.length;i++){
            sb.append(chars[i]);
        }
        //将字符缓冲区转换成字符串输出
        String s = sb.toString();
        System.out.println(s);
    }
}

package com.shujia.rx.day15;
//把字符串反转 (键盘录入字符串)例如："qwerdf"  --> "fdrewq"
import java.util.Scanner;
public class StringBufferTest2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String s = sc.next();

        //方法1：
        //把字符串转成字符缓冲区类型直接调用方法反转
        StringBuffer sb = new StringBuffer(s);
        StringBuffer sb2 = sb.reverse();

        //把字符缓冲区转成字符串类型并输出
        String s1 = sb2.toString();
        System.out.println("反转后的字符串为："+s1);

        //方法2
        //创建一个空字符串
        String s2="";
        //将输入的字符串转成字符数组
        char[]chars=s.toCharArray();
        //倒着遍历这个数组
        for(int i=chars.length-1;i>=0;i--){
            s2=s2+chars[i];
        }
        System.out.println("方法二反转后的字符串为："+s2);
    }
}

package com.shujia.rx.day15;
/*
判断一个字符串是否是对称字符串
        例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
        分析：
            1、第1个字符与最后一个字符去比较
            2、第2个字符与倒数第2个字符去比较
            3、第3个字符与倒数第3个字符去比较
            4、...
            比较的次数： length()/2
 */
public class StringBufferTest3 {
    public static void main(String[] args) {
        //定义一个字符串
        String s="erre";

        //方法一：一个一个遍历比较
        //把字符串转为字符数组
        char[]chars=s.toCharArray();
        //定义一个标记
        boolean flag=true;
        //比较
        for(int start=0,end=chars.length-1;start<=end;start++,end--){
            if(chars[start]!=chars[end]){
                System.out.println("该字符串不是对称字符串");
                flag=false;
                break;
            }
        }
        if(flag){
            System.out.println("该字符串是对称字符串");
        }

        //方法二：转换成字符缓冲去利用反转比较
        StringBuffer sb = new StringBuffer(s);
        StringBuffer sb2 = sb.reverse();
        String s2 = sb2.toString();
        if(s2!=null){
            if(s2.equals(s)){
                System.out.println("该字符串是对称字符串");
            }else{
                System.out.println("该字符串不是对称字符串");
            }
        }else{
            System.out.println("该字符串为空");
        }
    }
}

Arrays类

针对于数组做操作的类，该类包含用于操作数组的各种方法（如排序和搜索）

public static String toString(int[] a)将数组转换成一个字符串
public static void sort(int[] a)排序
public static int binarySearch(int[] a,int key)二分查找，前提是数组本身是排过序的

Arrays类中binarySearch源码分析

arr:[1, 4, 16, 21, 32, 44, 89]
key:100
public static int binarySearch(int[] a, int key) {
/*
a -- arr -- [1, 4, 16, 21, 32, 44, 89]
key -- 100
a.length -- 7
*/
return binarySearch0(a, 0, a.length, key);
}
// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
/*
a -- arr -- [1, 4, 16, 21, 32, 44, 89]
fromIndex -- 0
toIndex -- 7
key -- 100
*/
int low = fromIndex;      // 0
int high = toIndex - 1;   // 6

while (low <= high) {
    int mid = (low + high) >>> 1; // 3  5  6
    int midVal = a[mid]; // 21 44 89

    if (midVal < key)
        low = mid + 1; // 4 6 7
    else if (midVal > key)
        high = mid - 1;
    else
        return mid; // key found
}
return -(low + 1);  // key not found.    -(7+1) -->  -8
}

Math类

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数

public static int abs(int a)绝对值
public static double ceil(double a)向上取整
public static double floor(double a)向下取整
public static int max(int a,int b) min 取两个数中的最大值最小值
public static double pow(double a,double b)将第一个参数的值返回到第二个参数的幂，a的b的幂
public static double random() 返回一个double值为正号，大于等于0.0 ，小于1.0
public static int round(float a)返回参数中最接近的long ，其中long四舍五入为正无穷大
public static double sqrt(double a)返回double值正确舍入的正平方根

Random类

java中专门生成随机数的类

public Random() 创建一个新的随机数生成器。
public Random(long seed)使用单个long种子创建新的随机数生成器。 种子是通过方法next(int)维护的伪随机数发生器的内部状态的初始值。范围在种子范围内

int i = random.nextInt();//无界
int i = random.nextInt(10); // 0-9

Date日期类、SimpleDateFormat类

Date() 分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。
日期格式化：SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date); //Fri Jan 21 16:47:23 CST 2022 系统时间
        //由于我们经常看到时间不是这样的，应该是年，月，日，时分秒
        //日期的格式化
        //SimpleDateFormat(String pattern)
        //使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

        /**
         *      yyyy：年
         *      MM：月
         *      dd：日
         *      HH：24小时制度
         *      hh：12小时制度
         *      mm：表示分钟
         *      ss：表示秒
         */
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd EEE a hh:mm:ss ");
        String s = simpleDateFormat.format(date);
        System.out.println(s);
    }
}

包装类

Java就针对每一个基本数据类型都提供了一个对应的类类型。 我们称之为为包装类类型

包装类类型：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

public static String toBinaryString(int i)求出int类型数据的二进制
static String toHexString(int i)返回整数参数的字符串表示形式，作为16位中的无符号整数
static int MAX_VALUE 最大值
static int MIN_VALUE 最小值

import javax.swing.*;

public class PackageClassDemo1 {
    public static void main(String[] args) {
        //Integer: Integer类包装一个对象中的原始类型int的值。
        //public static String toBinaryString(int i)在基数2中返回整数参数的字符串表示形式为无符号整数。
        //求出int类型数据的二进制
        String s = Integer.toBinaryString(100);
        System.out.println("100的二进制为：" + s);

        //static String toHexString(int i)
        //返回整数参数的字符串表示形式，作为16位中的无符号整数。
        String s1 = Integer.toHexString(100);
        System.out.println("100的十六进制为:" + s1);

        //static String toOctalString(int i)
        //在基数8中返回整数参数的字符串表示形式为无符号整数。
        String s2 = Integer.toOctalString(100);
        System.out.println("100的八进制为：" + s2);

        //如何使用代码求出int类型数据范围
        //static int MAX_VALUE
        //一个持有最大值一个 int可以有2 31 -1。
        int maxValue = Integer.MAX_VALUE;

        //static int MIN_VALUE
        //的常量保持的最小值的 int可以具有，-2 31。
        int minValue = Integer.MIN_VALUE;

        System.out.println("int类型数据的最大值为：" + maxValue);
        System.out.println("int类型数据的最小值为：" + minValue);
    }
}

包装类一般是用于基本数据类型与字符串之间做转换

int类型的数据与String类型做互相转换

int – String
static String valueOf(int i) 返回 int参数的字符串 int形式。
String – Integer – int
public static int parseInt(String s)将字符串参数解析为带符号的十进制整数。