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

阅读原文时间：2023年07月08日阅读：4

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()方法</code></pre></li>


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):  
    引用类型：默认情况下，比较的是地址值  
    不过，根据情况重写，可以自己重写，也可以自动生成</code></pre>

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

    }  

}

手机扫一扫
移动阅读更方便

你可能感兴趣的文章

意译：《JVM Internals》

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

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