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高级特性第2节 java中常用的实用类(1)
一.Java API Java API即Java应用程序编程接口,他是运行库的集合,预先定义了一些接口和类,程序员可以直接调用:此外也特指API的说明文档,也称帮助文档. Java中常用的包: jav ...
java 中常用的类
java 中常用的类 Math Math 类,包含用于执行基本数学运算的方法常用API 取整 l static double abs(double a) 获取double 的绝对值 l sta ...
Java之常用API
API概述什么是API API (Application Programming Interface) :应用程序编程接口 java中的API 指的就是 JDK 中提供的各种功能的 Java类,这些 ...
java中常用的工具类（二）
下面继续分享java中常用的一些工具类,希望给大家带来帮助! 1.FtpUtil Java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ...
java中常用的工具类（三）
继续分享java中常用的一些工具类.前两篇的文章中有人评论使用Apache 的lang包和IO包,或者Google的Guava库.后续的我会加上的!谢谢支持IT江湖一.连接数据库的综合类 ...
java中常用的工具类（一）
我们java程序员在开发项目的是常常会用到一些工具类.今天我汇总了一下java中常用的工具方法.大家可以在项目中使用.可以收藏!加入IT江湖官方群:383126909 我们一起成长一.String工 ...
java中常用的字符串的截取方法
java中常用的字符串的截取方法 1.length() 字符串的长度例:char chars[]={'a','b'.'c'}; String s=new String(chars); int l ...
java中常用的包、类、以及包中常用的类、方法、属性----sql和text\swing
java中常用的包.类.以及包中常用的类.方法.属性常用的包 java.io.*; java.util.*; java.lang.*; java.sql.*; java.text.*; java.a ...
动图+源码，演示 Java 中常用数据结构执行过程及原理
阅读本文大概需要 3.7 分钟. 作者:大道方圆 cnblogs.com/xdecode/p/9321848.html 最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想 ...

随机推荐

微信小程序云开发-数据库-获取用户添加的数据到数据库
一.列表页面新增[添加商品]按钮在列表页增加[添加商品]按钮,按钮绑定事件toAdd(),用户点击该按钮跳转到添加商品页面. 在js文件中写toAdd()函数,作用是点击[添加商品]按钮,跳转到[添 ...
如何使用Scala的ClassTag
Scala官方文档中对于ClassTag的定义如下: ClassTag[T]保存着在运行时被JVM擦除的类型T的信息.当我们在运行时想获得被实例化的Array的类型信息的时候,这个特性会比较有用. 下 ...
ASM入网小助手卸载
目录 ASM小助手卸载写在前的卸载解除U盘禁用写在后的 ASM小助手卸载写在前的有些公司内网的上网认证是用的ASM小助手,不过有时候用自己电脑接入公司内网可能会主动下载到ASM入网小助手的 ...
Pb代理工具之mitmproxy
mitmproxy 一 . mitmproxy介绍 mitmproxy 就是用于 MITM 的 proxy,MITM 即中间人攻击(Man-in-the-middle attack). 不同于 fid ...
document.all("div).style.display = "none"与等于""的区别
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
【阿菜用工具】利用 Web3.js 在 ganache 上部署以及调用智能合约
合约部署要部署的合约 pragma solidity ^0.4.23; contract test { uint256 value; function setValue(uint256 _value ...
solr（CVE-2019-17558）远程命令执行
影响版本 Apache Solr 5.x到8.2.0版本测试 https://github.com/jas502n/CVE-2019-0193
LeetCode通关：求次数有妙招，位运算三连
分门别类刷算法,坚持,进步! 刷题路线参考: https://github.com/chefyuan/algorithm-base 大家好,我是刷题困难户老三,这一节我们来刷几道很有意思的求次数问题, ...
2020年最新阿里、字节、腾讯、京东等一线大厂高频面试（Android岗）真题合集，面试轻松无压力
本文涵盖了阿里巴巴.腾讯.字节跳动.京东.华为等大厂的Android面试真题,不管你是要面试大厂还是普通的互联网公司,这些面试题对你肯定是有帮助的,毕竟大厂一定是行发展的标杆,很多公司的面试官同样会研 ...
对抗防御之对抗样本检测（一）：Feature Squeezing
引言在之前的文章中,我们介绍了对抗样本和对抗攻击的方法.在该系列文章中,我们介绍一种对抗样本防御的策略--对抗样本检测,可以通过检测对抗样本来强化DNN模型.本篇文章论述其中一种方法:feature ...

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

Java 中 常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类的更多相关文章

随机推荐

热门专题

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

Java 中常用API概述之 Math, Object, String，StringBuffer类，Arrays，Integer类的更多相关文章