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);
    }
}

posted @ 2021-08-06 20:08 钟心意阅读(83) 评论(0) 收藏举报

刷新页面返回顶部

钟心意

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

公告

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