Java 中常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类

Math

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

　　　　与StrictMath类的一些数字方法不同，Math类的StrictMath所有Math都没有定义为返回比特位相同的结果。这种放松允许在不需要严格再现性的情况下执行更好的实现。

　　　　默认情况下，许多Math方法只需调用中的对应方法是StrictMath组织落实。鼓励代码生成器使用平台特定的本机库或微处理器指令（如果可用），以提供Math方法的Math实现。这种更高性能的实现仍然必须符合Math的Math 。

没有构造方法，如何使用类中的成员呢？

　　　　看类的成员是否都是静态的，如果是，通过类名就可以直接调用

代码的应用

package MathDemo;

public class MathDemo1 {

    public static void main(String[] args) {

        //返回参数绝对值

        System.out.println(Math.abs(88));

        System.out.println(Math.abs(-88));

        System.out.println("----------------------");

        //返回大于或者等于参数的最小double值，等于一个参数

        System.out.println(Math.ceil(12.34));

        System.out.println(Math.ceil(13.56));

        System.out.println("-------------------------");

//      返回大于或者等于参数的最小double值，等于一个参数

        System.out.println(Math.floor(12.34));

        System.out.println(Math.floor(13.56));

        System.out.println("------------------------");

        //按照四舍五入返回最接近参数的int

        System.out.println(Math.round(13.56F));

        System.out.println(Math.round(13.56F));

        System.out.println("------------------------");

        System.out.println(Math.max(12,134));

        System.out.println("-----------------------");

        //返回a的b次幂

        System.out.println(Math.pow(2.0,3.0));

        System.out.println("-----------------------");

        //返回为double的正值，[0.0,1.0)

        System.out.println(Math.random());

        //返回[0,100)的int随机数

        System.out.println((int)(Math.random()*100));

    }

}

Object

Object类概述

类层次结构的根类，每个class都有object作为超类。
所有类都直接或者间接的继承自该类
所有对象(包括数组)，都实现了这个类的方法

构造方法
- public Object()
- 回想面向对象中为什么说：
  - 子类的构造方法默认访问的是父类的无参构造方法。
Object类的成员方法
- public int hashCode()
  - 返回对象哈希值，支持这种方法是为了散列表，如HashMap提供的那样。　　
  - 注意：哈希值就是根据哈希算法计算出来的一个值，这个值跟地址有关系，但是不是实际的地址值，你可以简单的理解为就一种地址。

- public final class getClass()
  - 返回此Object的运行时类。返回的类对象是被表示类的static synchronized方法锁定的对象。

public class StudentTest {

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(s1.hashCode());//1163157884

        Student s2 = new Student();

        System.out.println(s2.hashCode());//1956725890

        Student s3 = s1;

        System.out.println(s3.hashCode());

        System.out.println("*****************");

        Student s4 = new Student();

        System.out.println(s4.getClass());

        Class c = s4.getClass();

        System.out.println(c.getName());

        System.out.println("***************");

        //链式编程

        System.out.println(s4.getClass().getName());

    }

}

- public String toString()　
  - 返回对象的字符串表示形式。一般来说，toString方法返回一个对象的字符串
  - Integer类提供了一个静态的方法：
    - public static String toHexString(int i)返回整数参数的字符串表示形式，作为16位中的无符号整数。
    - 但是我们只拿到这样的结果com.shujia.java.day13.Student2@4554617c，是没有任何意义的
      最终方案：类重写toString()方法
    - 总结：直接输出一个对象的名称，其实就是调用该对象的toString()方法

public class StudentTest2 {

    public static void main(String[] args) {

        Student2 s = new Student2();

        System.out.println(s.hashCode());//1163157884

        System.out.println(s.getClass().getName());//com.shujia.java.day13.Student2

        System.out.println("**********************");

        System.out.println(s.toString());//com.shujia.java.day13.Student2@4554617c

        System.out.println("***************");

        //toString()方法的值等价于以下内容

        //s.getClass().getName()+"@"+Integer.toHexString(s.hashCode())

        //this.getClass().getName()+"@"+Integer.toHexString(this.hashCode())

        //com.shujia.java.day13.Student2@4554617c

        //com.shujia.java.day13.Student2@4554617c

        System.out.println(s.getClass().getName()+"@"+Integer.toHexString(s.hashCode()));

        s.setName("xiaohua");

        s.setAge(18);

        System.out.println("重写后的方法："+s.toString());

    }

}

- public boolean equals(Object obj)
  - 指示一些其他对象是否等于此。
    这个放啊，默认情况下，比较的是地址值，但是呢，比较地址值是没有意义的，更多情况下
    我们比较对象中成员变量的值是否一样，所以想到的是重写方法
    - (==):
      基本类型，比较的是值是否相同
      引用类型：比较的是地址值是否相同
      
      (equals):
      引用类型：默认情况下，比较的是地址值
      不过，根据情况重写，可以自己重写，也可以自动生成
- protected void finalize()
  - throws Throwable当垃圾回收器确定不再有对该对象的引用时，
    垃圾回收器在对象上调用该对象。
    一个子类覆盖了处理系统资源或执行其他清理的finalize方法。
    简单来说，它就是用于垃圾回收的，但是呢，什么时候回收不确定
    1、重写该方法
- protected Object clone()
  - throws CloneNotSupportedException创建并返回此对象的副本。
    返回的是这个实例的一个克隆。
    
    public interface Cloneable一个类实现Cloneable接口，
    以指示Object.clone()方法，该方法对于该类的实例进行现场复制是合法的。

public class StudentTest4 {

    public static void main(String[] args) throws CloneNotSupportedException {

        Student4 s = new Student4();

        s.setName("xiaohua");

        s.setAge(18);

        System.out.println(s.toString());

        Object c = s.clone();

        //向下转型

        Student4 sclone = (Student4)c;

        System.out.println(s.getName()+"-------"+s.getAge());

        System.out.println(sclone.getName()+"----------"+sclone.getAge());

        Student4 s1 = s;

        System.out.println(s1.getName()+"-------"+s1.getAge());

        System.out.println("***********************************");

        s1.setName("虎");

        s1.setAge(24);

        System.out.println(s.getName()+"-------"+s.getAge());

        System.out.println(sclone.getName()+"----------"+sclone.getAge());

        System.out.println(s1.getName()+"-------"+s1.getAge());

    }

}

String

字符串：简单理解，就是由多个字符组成的一串数据。同理，所以也能看成一个字符数组
通过查看API，发现，
String类代表字符串。
Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
1、字符串字面值"abc"也可以堪称一个字符串对象
2、字符串是常量，一旦被赋值，就不能被改变
构造方法
- public String()
- 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)
字符串方法
- public int length()返回此字符串的长度。
- 长度等于字符串中的数字Unicode code units。

package StringDemo;

public class StringDemo1 {

    public static void main(String[] args) {

        String s = new String ();

        System.out.println("s"+s);

        System.out.println("s的长度"+s.length());

        System.out.println("*****************************");

        //将字节数组转换成字符串

        byte[] b = {97,99,88,56,23,32};

        String s1 = new String(b);

        System.out.println("S1"+s1);

        System.out.println(s1.length());

        System.out.println("******************************");

        // //public String(byte[] bytes,int offset,int length)

        //将字节数组的一部分截取成字符串

        String s2 = new String(b,2,3);

        System.out.println("s2"+s2);

        System.out.println(s2.length());

        System.out.println("*********************************");

        //public String(char[] value) 将字符数组转化成字符串

        char[] c = {'a','b','c','d','e','我','爱','冯','提','莫'};

        String s3 = new String(c);

        System.out.println("s3"+s3);

        System.out.println(s3.length());

        System.out.println("--------------------------------");

        //public String(char[] value,int offset,int count)

        //将字符数组的一部分转化成字符串

        String s4  = new String(c,3,5);

        System.out.println("s4"+s4);

        System.out.println(s4.length());

        System.out.println("--------------------------------");

        //public String(String original)

        //将字符串常量转化成字符串对象

        String s5 = new String("abcefd");

        System.out.println("s5 "+s5);

        System.out.println(s5.length());

    }

}

String的转换功能：
- String的转换功能：
  - byte[] getBytes()
  - char[] toCharArray()
  - static String valueOf(char[] chs)
  - static String valueOf(int i)
  - String toLowerCase()
  - String toUpperCase()
  - String concat(String str)

public class StringDemo10 {

    public static void main(String[] args) {

        String s = "BigData";

        //byte[] getBytes() 将字符串转换成字节数组

        byte[] bytes = s.getBytes();

//        System.out.println(bytes);

        for (int i = 0; i < bytes.length; i++) {

            System.out.println(bytes[i]);

        }

        System.out.println("**********************");

        //char[] toCharArray() 将字符串转化成字符数组

        char[] c = s.toCharArray();

//        System.out.println(c);

        for (int i = 0; i < c.length; i++) {

            System.out.println(c[i]);

        }

        System.out.println("**********************");

        //static String valueOf(char[] chs) 将字符数组转化成字符串

        String s1 = String.valueOf(c);

        System.out.println(s1);

        System.out.println("**********************");

        //static String valueOf(int i) 将int类型数据转化成字符串

        String s2 = String.valueOf(100);

        System.out.println(s2);

        System.out.println("**********************");

        //String toLowerCase() 将字符串中的字符转成小写

        String s3 = s.toLowerCase();

        System.out.println(s3);

        System.out.println(s);

        System.out.println("**********************");

        // String toUpperCase()

        String s4 = s.toUpperCase();

        System.out.println(s4);

        System.out.println("**********************");

        //String concat(String str) 把字符串拼接

        String s5 = "Hello";

        String s6 = "World";

        String s7 = s5+s6;

        String s8 = s5.concat(s6);

        System.out.println("s5:"+s5); //

        System.out.println("s6:"+s6);

        System.out.println("s7:"+s7);

        System.out.println("s8:"+s8);

    }

}

package StringDemo;

/*

        把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

        举例：helloWOrld ----  结果：Helloworld

        分析：

        第一种方式：

            1、先获取到第一个字符

            2、获取除了第一个其余的字符

            3、把第一步转成大写

            4、把第二部转成小写

            5、把第三步和第四步拼接起来

        第二种方式：

            1、把字符串全部转成小写

            2、取第一个字符

            3、将第二步转成大写

*/

public class StringDemo2 {

    public static void main(String[] args) {

        //定义一个字符串

        String s  = "helloWorld";

        //先获取到第一个字符

        String s1 = s.substring(0,1);

//        System.out.println(s1);

        //获取除了第一个其余的字符

        String s2 = s.substring(1);

//        System.out.println(s2);

//        把第一步转成大写

        String start = s1.toUpperCase();

//        System.out.println(start);

        //把第二部转成小写

        String other = s2.toLowerCase();

//        System.out.println(other);

        //把第三步和第四步拼接起来

        String result  = start.concat(other);

        System.out.println(result);

        System.out.println("-------------链式编程改进----------------");

        String concat = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());

        System.out.println(concat);

    }

}

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

package StringDemo;

/*

        替换功能

                String replace(char old,char new)

                String replace(String old,String new)

        去除字符串两空格

                String trim()

        按字典顺序比较两个字符串

                int compareTo(String str)

                int compareToIgnoreCase(String str)

 */

public class StringDemo3 {

    public static void main(String[] args) {

        String s = "helloworld";

        //将字符串中所有的l替换成k，返回一个新的字符串

        String s1 = s.replace('l','k');

        //将字符串中指定的字符串替换成新的字符串，返回一个新的字符串

        String s2 = s.replace("owo","ww");

        System.out.println(s);

        System.out.println(s1);

        System.out.println(s2);

        //String trim()

        String s3 = " hello world ";

        String s4 = s3.trim();

        System.out.println(s3);

        //去除头尾空格

        System.out.println(s4);

        //按字典顺序比较两个字符串

        //int compareTo(String str)

        String s5 = "hello";  //h的ASCLL码值是104

        String s6 = "hello";

        String s7 = "abc";    //a的ASCLL码值是97

        String s8 = "qwe";    //q的ASCLL码值是113

        System.out.println(s5.compareTo(s6));// 0

        System.out.println(s5.compareTo(s7));// 7

        System.out.println(s5.compareTo(s8));// -9

    }

}

/*

        如果前面几个字符是一样的怎么办？

 */

public class StringDemo13 {

    public static void main(String[] args) {

        String s = "hello";

        String s2 = "hel";

        System.out.println(s.compareTo(s2)); // 2 = s.length - s2.length

    }

}

String类的练习

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

package StringDemo;

/*

        把数组中的数据按照指定个格式拼接成一个字符串

                举例：int[] arr = {1,2,3};

                输出结果：[1, 2, 3]

        分析：

            1、定义一个空字符串对象

            2、先把字符串前面拼接一个"["

            3、遍历int数组，得到每一个元素

            4、判断是否读到最后一个，如果是最后一个，在尾部拼接"]"

            5、输出

 */

public class StringDemo4 {

    public static void main(String[] args) {

        int [] arr ={1,2,3};

        //定义一个空字符串对象

        String s = "";

        //先把字符串前面拼接一个"["

        s += "[";

        //遍历int数组，得到每一个元素

        for (int i = 0; i <arr.length ; i++) {

            //4、判断是否读到最后一个，如果是最后一个，在尾部拼接"]"

            if (i == arr.length-1){

                s+=arr[i];

                s+="]";

            }

            else {

                s += arr[i];

                s += ";";

            }

        }

        System.out.println(s);

    }

}

字符串反转
举例：键盘录入”abc” 输出结果：”cba”

/*

        字符串反转

        举例：键盘录入”abc”

        输出结果：”cba”

        分析：

            1、键盘录入一个字符串

            2、定义一个空字符串

            3、将字符串转成字符数组

            4、倒着遍历字符串，得到每一个字符

            5、用新的字符串拼接得到每一个字符

            6、输出

 */

public class StringDemo5 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("请输入一个字符串：");

        String oldString  = sc.next();

        //定义一个空字符串

        String newString = "";

        //将字符串转成字符数组

        char[] charArrays = oldString.toCharArray();

        //倒着遍历字符串，得到每一个字符

        for (int i = charArrays.length-1; i >=0 ; i--) {

            //用新的字符串拼接得到每一个字符

            newString += charArrays[i];

        }

        //输出

        System.out.println(newString);

    }

}

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

package StringDemo;

import java.util.Scanner;

/*

        统计大串中小串出现的次数

        举例：

        在字符串” woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunefdsrfdsfdsfsdfwfwrfewrefsdfsjavadaddasdasdadadasjvadoiqwopeioandbuiabubjava”

        中java出现了5次

 */

public class StringDemo6 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //定义一个字符串

        //String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunefdsrfdsfdsfsdfwfwrfewrefsdfsjavadaddasdasdadadasjvadoiqwopeioandbuiabubjava";

        //定义一个小串

        //String minString = "java";

        System.out.println("请输入字符串：");

        String maxString = sc.next();

        System.out.println("请输入要查找的字符串：");

        String minString = sc.next();

        int result = findSting(maxString,minString);

        System.out.println("大串中小串出现的次数为："+result);

    }

    public static int findSting(String maxString , String minString){

        //定义一个统计变量

        int count = 0 ;

        //在大串中找到小串第一次出现的位置

        int index = maxString.indexOf(minString);

        if(index == -1 ){

            System.out.println("在大串中没有小串："+ minString);

            return 0;

        }

        while (index != -1){

            count++;

            int startIndex = index + minString.length();

            maxString = maxString.substring(startIndex);

            index = maxString.indexOf(minString);

        }

        return count;

    }

}

StringBuffer类

StringBuffer类的概述及其构造方法
- 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题
- 线程安全的可变字符序列
  - 线程安全，可变的字符序列。字符串缓冲区就像一个String，但可以修改。
    在任何时间点，它包含一些特定的字符序列，
    但可以通过某些方法调用来更改序列的长度和内容
StringBuffer和String的区别?
- 前者长度和内容可以发生改变、后者不可改变
- 前者可以提前给出缓冲区，可以进行字符串拼接不会重新开辟空间
  后者会重新开辟空间，会浪费太多资源
  
  　　
构造方法
- public StringBuffer()
- public StringBuffer(int capacity)
- public StringBuffer(String str)
StringBuffer的方法：
- public int capacity()返回当前容量。
  容量是新插入字符可用的存储量，超过此值将进行分配。
- public int length()返回长度（字符数）

package com.shujia.java.day14;

/*

            1、线程安全的

            2、安全，代表着有同步存在，数据是安全的，效率不高

            3、不安全，不同步，效率高

            4、安全问题和效率问题一直都是一个矛盾点

            5、生活中，哪些案例是安全和效率

            6、安全：售票、医院取号、银行的一些业务

            7、效率：论坛、视频会员...

         StringBuffer:

            线程安全，可变的字符序列。字符串缓冲区就像一个String，但可以修改。

            在任何时间点，它包含一些特定的字符序列，

            但可以通过某些方法调用来更改序列的长度和内容

            简单来说：它就是一个线程安全的可变字符串

        StringBuffer和String的区别?

            1、前者长度和内容可以发生改变、后者不可改变

            2、前者可以提前给出缓冲区，可以进行字符串拼接不会重新开辟空间

                后者会重新开辟空间，会浪费太多资源

        StringBuffer的构造方法：

             public StringBuffer()

             public StringBuffer(int capacity)

             public StringBuffer(String str)

        StringBuffer的方法：

            public int capacity()返回当前容量。

            容量是新插入字符可用的存储量，超过此值将进行分配。

            public int length()返回长度（字符数）。

 */

public class StringBufferDemo1 {

    public static void main(String[] args) {

        //public StringBuffer() 无参构造方法

        StringBuffer sb = new StringBuffer();

        //重写了toSting()方法

        System.out.println("sb:"+sb);

        System.out.println(sb.capacity()); //16

        System.out.println(sb.length());

        //public StringBuffer(int capacity)

        StringBuffer sb2 = new StringBuffer(50);

        System.out.println(sb2);

        System.out.println(sb2.capacity()); //50

        System.out.println(sb2.length()); //0

        //public StringBuffer(String str)

        StringBuffer sb3 = new StringBuffer("hello");

        System.out.println(sb3);

        System.out.println(sb3.capacity()); //21  16 + 5

        System.out.println(sb3.length()); //5

    }

}

添加功能
- public StringBuffer append(String str)
- public StringBuffer insert(int offset,String str)

package StringBufferDemo;

/*

            StringBuffer:

                添加功能

                    public StringBuffer append(String str)

                        可以把任意类型的数据添加到字符串缓冲区里面

                        并且返回的是字符串缓冲区本身

                    public StringBuffer insert(int offset,String str)

                        在指定位置插入数据到字符串缓冲区里面

 */

public class StringBufferDemo1 {

    public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();

        //public StringBuffer append(String str)

        StringBuffer sb2 = sb.append("hello");

        System.out.println(sb2);

        System.out.println(sb);

        System.out.println(sb == sb2);

//        sb.append(true);

//        sb.append(10);

//        sb.append(12.34);

//        System.out.println(sb);

//        System.out.println(sb2);

        //链式编程

        sb.append(true).append(10).append(12.13).append(12313.123);

        System.out.println(sb);

        //public StringBuffer insert(int offset,String str)

        //在指定索引位置上，插入某字符串

        sb.insert(5,"java'");

        System.out.println(sb);

    }

}

删除功能
- public StringBuffer deleteCharAt(int index)
- public StringBuffer delete(int start,int end)

package StringBufferDemo;

/*

        删除功能

            public StringBuffer deleteCharAt(int index)

            public StringBuffer delete(int start,int end)

 */

public class StringBufferDemo2 {

    public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();

        sb.append("hello").append("java").append("bigdata'");

        System.out.println(sb);

        System.out.println("--------------------------------------'");

        //public StringBuffer deleteCharAt(int index)

        //删除指定位置的字符，并返回本身

//        sb.deleteCharAt(5);

//        System.out.println(sb);

//

//        sb.deleteCharAt(0);

//        System.out.println(sb);

        //public StringBuffer delete(int start,int end)

        //左闭右开

        sb.delete(3,5);

        System.out.println(sb);

        System.out.println("-------------------------------------");

        //删除所有字符串

        sb.delete(0,sb.length());

        System.out.println(sb);

    }

}

替换功能
- public StringBuffer replace(int start,int end,String str)

package StringBufferDemo;

/*

        public StringBuffer replace(int start,

                            int end,

                            String str)用指定的String中的字符替换此序列的子字符串中的String 。

                            子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。

                            第一子串中的字符被去除，然后指定String被插入在start 。

                            （如果需要，此序列将被延长以容纳指定的字符串。）

 */

public class StringBufferDemo3 {

    public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();

        sb.append("hello").append("java").append("bigdata");

        System.out.println(sb);

        //public StringBuffer replace(int start,

        //                            int end,

        //                            String str)

        sb.replace(5,9,"数加");

        System.out.println(sb);

    }

}

反转功能
- public StringBuffer reverse()

package StringBufferDemo;

/*

            public StringBuffer reverse()导致该字符序列被序列的相反代替。

             如果序列中包含任何替代对，则将它们视为单个字符进行反向操作。

 */

public class StringBufferDemo4 {

    public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();

        sb.append("我爱你");

        System.out.println(sb);

        sb.reverse();

        System.out.println(sb);

    }

}

截取功能
- public String substring(int start)
- public String substring(int start,int end)

/*

            截取功能:注意此时的返回值类型就不再是StringBuffer类型了

            返回值类型是String类型，本身没有发生改变

                public String substring(int start)

                public String substring(int start,int end)

 */

public class StringBufferDemo6 {

    public static void main(String[] args) {

        //创建字符串缓冲区对象

        StringBuffer sb = new StringBuffer();

        sb.append("hello").append("world").append("bigdata");

        System.out.println(sb);

        //截取功能

        //public String substring(int start)

        String s = sb.substring(5);

        System.out.println(s); //worldbigdata

        System.out.println(sb); //helloworldbigdata

        //public String substring(int start,int end)

        String s2 = sb.substring(5, 10);

        System.out.println(s2);

        System.out.println(sb);

    }

}

截取功能和前面几个功能的不同
- 返回值类型是String类型，本身没有发生改变
StringBuffer类练习

String和StringBuffer的相互转换

package StringBufferDemo;

/*

            String和StringBuffer的相互转换

            A -- B的转换，把A转化成B,为了是使用B的功能

            B -- A，把B转换成A,结果可能就是需要A类型，所以还得转回来

            String和StringBuffer的相互转换

 */

public class StringBufferDemo5 {

    public static void main(String[] args) {

        // String -- StringBuffer

        String s = "hello";

        //注意：不能把字符串String类型赋给StringBuffer类型

//        StringBuffer sb = s;

//        StringBuffer sb = "hello";

        //方式1：通过构造方法

        StringBuffer sb = new StringBuffer(s);

        System.out.println(s);

        //方法2：调用StringBuffer的append方法

        StringBuffer stringBuffer = new StringBuffer();

        stringBuffer.append(s);

        System.out.println(stringBuffer);

        //StringBuffer -- String

        StringBuffer sb2 = new StringBuffer("bigdata");

        //方式1：调用String的构造方法

        String s1 = new String(sb2);

        System.out.println(s1);

        //方式2：调用StringBuffer的toString()方法

        String s2 =sb2.toString();

        System.out.println(s2);

    }

}

把数组拼接成一个字符串

package StringBufferDemo;

/*

        把数组拼接成一个字符串

 */

public class StringBufferDemo6 {

    public static void main(String[] args) {

        //定义一个数组

        int[] arr = {11,2,3,4,56,2,3,45,6};

        //方式1：用String拼接

        String s = "";

        s += "[";

        for (int i = 0; i < arr.length; i++) {

            if(i == arr.length-1){

                s += arr[i];

                s += "]";

            }else {

                s += arr[i];

                s+=",";

            }

        }

        System.out.println(s);

        System.out.println("-----------------------------------");

        //方式2：用StringBuffer拼接

        StringBuffer sb = new StringBuffer();

        sb.append('[');

        for (int i = 0; i <arr.length ; i++) {

            if(i == arr.length-1){

                sb.append(arr[i]).append("]");

            }else {

                sb.append(arr[i]).append(",");

            }

        }

        System.out.println(sb);

    }

}

把字符串反转

package StringBufferDemo;

import java.util.Scanner;

/*

        把字符串反转

 */

public class StringBufferDemo7 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入数据：");

        String stringLine = sc.next();

        //方式1：用String拼接

        String result = "";

        //将输入的字符串转化成字符数组

        char[] charArray = stringLine.toCharArray();

        for (int i = charArray.length - 1; i>= 0 ; i--) {

            result += charArray[i];

        }

        System.out.println(result);

        System.out.println("-------------------------------");

        //方式2：利用StringBuffer的reverse()方法

        StringBuffer stringBuffer = new StringBuffer(stringLine);

        StringBuffer stringBuffer1 = stringBuffer.reverse();

        String  s = stringBuffer1.toString();

        System.out.println(s);

        System.out.println(new StringBuffer(stringLine).reverse().toString());

    }

}

判断一个字符串是否是对称字符串

例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

package StringBufferDemo;

import java.util.Scanner;

/*

            判断一个字符串是否是对称字符串

            例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

            分析：

                1、第一个字符和最后一个字符比较

                2、第二个字符与倒数第二个字符比较

                ...

                比较的次数:长度/2

 */

public class StringBufferDemo8 {

    public static void main(String[] args) {

        //键盘录入

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入想要判断的字符串：");

        String stringLine = sc.next();

        //方式1：一个一个比较

        //将输入的字符串转化成字符数组

//        char[] charArray = stringLine.toCharArray();

//        boolean flag = true;

//

//        for (int start = 0, end = charArray.length - 1; start <= end; start++, end--) {

//            if (charArray[start] != charArray[end]) {

//                System.out.println("该字符串不是对称字符串");

//                flag = false;

//                break;

//            }

//        }

//        if (flag) {

//            System.out.println("字符串是对称字符串");

//        }

        //方式2：利用StringBuffer的反转方法

        //将String转换成StringBuffer

//        StringBuffer sb1 = new StringBuffer(stringLine);

//        StringBuffer stringBuffer = sb1.reverse();

//        //将反转后的StringBuffer转化成String类型

//        String s = stringBuffer.toString();

        String s = new StringBuffer(stringLine).reverse().toString();

        if(s.equals(stringLine)){

            System.out.println("字符串是对称字符串");

        }else {

            System.out.println("该字符串不是对称字符串");

        }

    }

}

StringBuffer类面试题
- 通过查看API了解一下StringBuilder类
- String,StringBuffer,StringBuilder的区别
  - String的内容是不可变的，而StringBuffer和StringBuilder的内容是可以变的
  - StringBuffer是同步线程安全的，数据安全，效率低
  - StringBuilder是不同步的，数据不安全，效率高
- StringBuffer和数组的区别
  - ```
  两个都可以看作是一个容器，装一些数据
  但是，StringBuffer最终存的数据是一个字符串数据
  而数组可以存放多种数据，但是同一个数组里面元素类型一致
```
- 看程序写结果：
  - String作为参数传递
  - StringBuffer作为参数传递

        3、看程序写结果：

                String作为参数传递

                StringBuffer作为参数传递

 */

public class StringBufferDemo9 {

    public static void main(String[] args) {

        String s1 = "hello";

        String s2 = "world";

        System.out.println(s1+"---"+s2); //hello---world

        change(s1,s2);

        System.out.println(s1+"---"+s2); //hello---world

        StringBuffer sb1 = new StringBuffer("hello");

        StringBuffer sb2 = new StringBuffer("world");

        System.out.println(sb1+"---"+sb2); //hello---world

        change2(sb1,sb2);

        System.out.println(sb1+"---"+sb2); //hello---worldworld

    }

    public static void change2(StringBuffer sb1,StringBuffer sb2){

        sb1 = sb2;

        sb2.append(sb1);

    }

    public static void change(String s1,String s2){

        s1 = s2;

        s2 = s1+s2;

    }

}

Arrays

Arrays类的概述和常用方法

Arrays类用包含用于操作数组的各种方法

package Arrays;

import java.util.ArrayList;

import java.util.Arrays;

public class Arraysdemo {

    public static void main(String[] args) {

        //定义一个数组

        int[] arr  = {24,89,21,34,121};

        System.out.println("排序前"+ Arrays.toString(arr));

        //对数组元素进行从小到大排序

        Arrays.sort(arr);

        System.out.println("排序后"+Arrays.toString(arr));

    }

}

工具类的设计思想

构造方法用private修饰
成员用public修饰

Integer类的概述和使用

Integerl：包装一个对象中的原始类型Int的值

代码的实现

package Arrays;

public class integerDemo {

    public static void main(String[] args) {

  /*      //public Integer(int value),根据 int 值创建Integer 对象（过时）

        Integer i1 = new Integer(100);

        System.out.println(i1);

        //public Integer(String s),根据String 值创建Integer对象(过时)

        Integer i2 = new Integer("100");

        System.out.println(i2);

        */

//      public static Integer valueOf(int i),返回表示指定的int值的Integer实例

        Integer i1 = Integer.valueOf(100);

        System.out.println(i1);

//      public static Integer valueOf(String i),返回一个保存指定值的Integer 对象 String

        Integer i2 = Integer.valueOf("100");

        System.out.println(i2);

    }

}

巴特西

Java 中常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类

最新文章

热门文章

巴特西

Java 中 常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类

最新文章

热门文章

Java 中常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类