【常用类】StringBuffer类、Math类、Arrays类、Random类、八大包装类、 Date:日期类

常用类

1.StringBuffer类

（1） StringBuffer的特点：

1、线程安全的
不安全：就是存在同步操作同一数据的行为，效率高。
安全的时候，没有同步操作，效率低。

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

面试题：StringBuffer与String区别：

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

（2） StringBuffer的构造方法：

• public StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符。

   public class StringBufferDemo1 {
    public static void main(String[] args) {
    
        //public StringBuffer()  
      //  构造一个没有字符的字符串缓冲区，初始容量为16个字符。
       StringBuffer s=new StringBuffer();
  System.out.println(s);//StringBuffer重写了toString方法
        
        //如何获取StringBuffer的容量
        //public int capacity()返回当前容量。
        System.out.println(s.capacity());//容量为16
        System.out.println(s.length());//长度为0

• public StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。

  StringBuffer s1=new StringBuffer(10);
    System.out.println(s1.capacity());//指定容量为10
    System.out.println(s1.length());//长度依然为0

• public StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。

       StringBuffer s2=new StringBuffer("马鞍山学院");
        System.out.println(s2);//马鞍山学院
        System.out.println(s2.capacity());
        //21此时的容量是在16的基础上加上字符串的长度
        //StringBuffer重写了toString方法
        System.out.println(s2.length());//5

    }
}

(3)StringBuffer的添加功能

• public StringBuffer append(String str)
  通过观察API发现，不光可以追加字符串，还可以是任意数据类型的追加到StringBuffer中
  返回的StingBuffer是什么呢？

  public class StringBufferDemo2 {
public static void main(String[] args) {
    StringBuffer stringBuffer=new StringBuffer();
    StringBuffer s=stringBuffer.append("hello");
    System.out.println(stringBuffer==s);//true
    System.out.println(stringBuffer);//hello
    System.out.println(s);//hello
    // 这说明stringBuffer和s指的是同一个字符串,操作的是同一个StringBuffer对象

    //无论追加的数据是什么类型，一旦进入到StringBuffer中就是成
    //了字符串
 s.append(100).append('c').append("Lilly").append(2.0);
    System.out.println(s);//hello100cLilly2.0

• public StringBuffer insert(int index,String str):
  将字符串插入到此字符序列中。返回的是字符串缓冲区本身
  String参数的String按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符， 并将该序列的长度增加到参数的长度。

 StringBuffer s3=new StringBuffer("hello");
        s3.insert(2,"你好");
    System.out.println("插入后的字符串为"+s3);//he你好llo
        System.out.println(s3.length());//长度为7

//注意： 如果str是null ，则四个字符"null"被插入到该序列中。
//null不能直接插入需要一个Object类型的变量接收

   Object obj=null;
        s3.insert(3,obj);
        System.out.println("插入null后的字符串为："+s3);//he你null好llo
    }
}

结果：

（3） StringBuffer的删除功能

remove,move,delete,drop,truncate
StringBuffer的删除功能：

• public StringBuffer deleteCharAt(int index) 删除指定索引处的字符。该序列缩短了一个char

public StringBuffer deleteCharAt(int index) 删除指定索引处的字符。该序列缩短了一个char
如果 index为负数或大于或等于length() 。index的值最大可以取到实际存储字符串的长度-1

public class StringBufferDemo3 {
    public static void main(String[] args) {
    
        StringBuffer s=new StringBuffer("goodmmorning");
        s.deleteCharAt(4);
        System.out.println(s);//goodmorning
      //  s.deleteCharAt(-1);
       // System.out.println(s);
       //StringIndexOutOfBoundsException

• public StringBuffer delete(int start,int end) 删除指定索引处的字符串。该序列缩短了一个String

//删除此序列的子字符串中的字符。
// 子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。
// 如果start等于end ，则不作任何更改。
// start<=index<end,左闭右开

  StringBuffer s1=new StringBuffer("hi how arebsa you");
        s1.delete(10,13);
        System.out.println(s1);//hi how are you

        //注意开始位置一定是已经存在的索引，否则报错
      //  s1.delete(25,30);
        //System.out.println(s1);//StringIndexOutOfBoundsException

        //需求：删除StringBuffer中的所有字符
        s1.delete(0,s1.length());
        System.out.println(s1);//此时结果为空删除了字符串中
        //所有的内容
    }
}

结果：

（4） StringBuffer替换功能（左闭右开）

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

public class StringBufferDemo4 {
    public static void main(String[] args) {
        StringBuffer s=new StringBuffer("java").append("数据库").append("软件工程").append(100).append("hive");
        System.out.println(s);
        System.out.println( s.charAt(12));
        s.replace(11,18,"hadoop!");
        System.out.println(s);//java数据库软件工程hadoop!

    }
}

结果：

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

public class StringBufferDemo5 {
    public static void main(String[] args) {
        StringBuffer s=new StringBuffer("上海自来水来自海上,");
        s.reverse();
        System.out.println(s);//,上海自来水来自海上
        // 操作的是同一个StringBuffer对象
    }
}

（6） StringBuffer的截取功能

• public String substring(int start)

返回一个新的String ，其中包含此字符序列中当前包含的字符的子序列。
// public String substring(int start)注意截取前后两者值得不是一个StringBuffer对象
//不会改变原来StringBuffer中的数据
> //返回值是一个String类型的数据

StringBuffer s1=new StringBuffer("java").append("Mysql")
.append("hadoop").append("spark").append("===");

  String s2=s1.substring(4);//**返回值是一个String类型的数据**
        System.out.println("截取的字符串为："+s2);
        //Mysqlhadoopspark===

 System.out.println("原字符为："+s1);//javaMysqlhadoopspark===

• public String substring(int start,int end) 含头不含尾 [start,end)

   String s3=s1.substring(0,9);
System.out.println("指定截取的字符串为："+s3);//javaMysql
System.out.println("原字符串为："+s1);//javaMysqlhadoopspark===

    }
}

结果：

（6） String与StringBuffer之间的转换。

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

• //String–>StringBuffer

  //方法1:通过构造方法
    String s="helloworld";
    StringBuffer s1=new StringBuffer(s);
    System.out.println(s);//helloworld
    System.out.println(s1);//helloworld
    //方法2：通过append方法
    StringBuffer s2=new StringBuffer().append(s);
    System.out.println(s2);//helloworld
    System.out.println(s);//helloworld

- StringBuffer–>String

 //方法一：利用toString
        StringBuffer s3=new StringBuffer("goodmoring");
        String s4=s3.toString();
        System.out.println(s3);//goodmoring
        System.out.println(s4);//goodmoring



        //方法二：利用subString（）方法
        String s5=s3.substring(0);
        System.out.println(s5);//goodmoring
        System.out.println(s3);//goodmoring

    }
}

（7）面试题

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

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

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

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

（8） 探究String作为参数传递与StringBuffer作为参数传递的区别。

• String作为形式参数传递时

 public class StringBufferDemo8 {
    public static void main(String[] args) {
//1.String类型作为参数传递时
        String s="hello";
        String s1="world";
        System.out.println("s:"+s+",s1:"+s1);//s:hello s1:world
        change(s,s1);
        System.out.println("s:"+s+",s1:"+s1);}
        //s:hello s1:world

 public static void  change(String s,String s1){
        s=s1;
        s1=s1.concat(s);
        System.out.println("s:"+s+",s1:"+s1);//s:world s1；worldworld

    }

• StringBuffer类型作为参数传递

 public class StringBufferDemo8 {
    public static void main(String[] args) {
     StringBuffer s2=new StringBuffer("hello");
        StringBuffer s3=new StringBuffer("world");
        System.out.println("s2:"+s2);//hello
        System.out.println("s3:"+s3);//world
        change1(s2,s3);
/*change1方法调用完后会自动消除，但是再调用方法时s3所指的常量池
中的字符串已经开辟了一个新的空间指向新的字符串worldworld，而
s2所指的字符串一直没有改变过，因此还是原来的字符串*/
        System.out.println("s2:"+s2);//hello
        System.out.println("s3:"+s3);//worldworld
        }

public  static  void change1(StringBuffer s2,StringBuffer s3){
        s2=s3;
        s3=s3.append(s2);
        System.out.println("s2:"+s2);/*s2与s3一直指向的是
 同一个StringBuffer对象，当s3改变时s2也就会改变因此结果为
 worldworld*/
        System.out.println("s3:"+s3);
        //worldworld
    }

图解：

（9） 把字符串反转 (键盘录入字符串)

例如： “qwerdf” --> “fdrewq”

import java.util.Scanner;
public class StringBufferDemo10 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        //第一种方法利用数组遍历到这输出
        String s="";
        String s1=sc.next();
        char[] chars = s1.toCharArray();
        for (int i= chars.length-1;i>=0;i--){
            s+=chars[i];

        }
        System.out.println(s);

        //第二种方法将字符串转换为StringBuffer利用他的方法去
        //逆序，然后再转回字符串在输出
   String s2= new StringBuffer(s1).reverse().toString();
   System.out.println(s2);



    }

}

(10).例题

把数组拼接成一个字符串(用StringBuffer实现)

 public class StringBufferTestDemo9 {
    public static void main(String[] args) {
        char[] chars={'我','爱','你','中','国'};
        StringBuffer s=new StringBuffer();
        for (int i=0;i< chars.length;i++){
            s.append(chars[i]);

        }

   String s1= s.toString();//这里需要接收一下,再转为字符串

        System.out.println(s1);

    }
}

2.Math类

Math:Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。
public static int abs(int a)
public static double ceil(double a)
public static double floor(double a)
public static int max(int a,int b) min自学
public static double pow(double a,double b)
public static double random()
public static int round(float a) 参数为double的自学
public static double sqrt(double a)

public class MathDemo {
    public static void main(String[] args) {
        //public static int abs(int a) 绝对值
        System.out.println(Math.abs(-9));//9
        
       // public static double ceil(double a) 向上取整
        System.out.println(Math.ceil(2.01));//3.0
      
        //public static double floor(double a)向下取整
        System.out.println(Math.floor(2.98));//2.0
     
       // public static int max(int a,int b)求最大值
        System.out.println(Math.max(60,70));//70
      
       // public static double pow(double a,double b)
       //求a的b次方
        System.out.println(Math.pow(2.0,1.0));//2.0
        
       // public static double random()
        System.out.println(Math.random());
        
        //public static int round(float a) 参数为double的自学
     System.out.println(Math.round(2.4));//2 四舍五入取整
        System.out.println(Math.round(2.4565));//2
        
     // public static double sqrt(double a) 开根号
        System.out.println(Math.sqrt(9.01));//3.0
    }
}

3.Arrays类

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

public static String toString(int[] a) //将数组转换成一个字符串
public static void sort(int[] a)//将数组排序
public static int binarySearch(int[] a,int key)//利用二分查找查找数组中的元素

public class ArrayDemo {
    public static void main(String[] args) {
        int[] c={2,3,8,1,63,20,14,32};
        //将数组转换成一个字符串
        String s=Arrays.toString(c);
        System.out.println(s);
        System.out.println("排过序的数组为：");
        Arrays.sort(c);
        for (int i=0;i< c.length;i++)
        System.out.print(c[i]+",");
        System.out.println();
        System.out.println("关键字的索引为："
        +Arrays.binarySearch(c,63));
        //二分查找的前提是数组本身是排过序的
        System.out.println("关键字的索引为："
        +Arrays.binarySearch(c,100));
        //如果没找到就会返回   -（c.length+1）

    }
}

结果：

4.Random类

java中专门生成随机数的类：Random
public Random()
public Random(long seed)

 public class RandomDemo {
    public static void main(String[] args) {
        //public Random()
        Random random=new Random();
        System.out.println(random.nextInt());//811300048
        System.out.println(random.nextInt(10));
        //生成0-9之间的随机数如果想要0-10就直接加1
        int num=random.nextInt(10)+1;
        System.out.println(num);


        //public Random(long seed)
        Random random1=new Random(10000000000000l);
 System.out.println(random1);//java.util.Random@74a14482
    System.out.println(random1.nextInt());//1688287525
    }
}

结果：

5.包装类

包装类：
需求1：有100这个数据，计算处它的二进制，八进制，十六进制
需求2：如何使用代码求出int类型数据范围

通过观察需求后发现，我们得出原本的基本数据类型无法调用任何方法和属
性，怎么办呢？
为了对基本数据类型进行更多的操作，更方便的操作，Java就针对每一个
基本数据类型都提供了一个对应的类类型。
 我们称之为为包装类类型。
        
        包装类类型：
            byte            Byte
            short           Short
            int             Integer
            long            Long
            float           Float
            double          Double
            char            Character
            boolean         Boolean

1.以Integer为例：

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

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


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


        //  如何使用代码求出int类型数据范围
System.out.println("int类型的最大取值范围："+Integer.MAX_VALUE);
//int类型的最大取值范围：2147483647
System.out.println("int类型的最小取值范围："+Integer.MIN_VALUE);
//int类型的最小取值范围：-2147483648



    }
}
          

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

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

• int – >String
  static String valueOf(int i) 返回 int参数的字符串 int形式。

public class PackageClassDemo2 {
    public static void main(String[] args) {
        //int===>String
        //1.利用valueOf（）方法
        int num=100;
        String s=String.valueOf(num);
        System.out.println(s);//100

        //方式2：int -- Integer -- String
//        String string = new String(num);
        //Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。

        Integer integer=new Integer(num);
        System.out.println(integer);//100说明Integer重写了toString方法
        String s1=integer.toString();
        System.out.println(s1);//100


        //方式3：字符串拼接
        String s2=""+num;
        System.out.println(s2);//100



        //方式4：public static String toString(int i)
        String s3=Integer.toString(100000);
        System.out.println(s3);//100000

• String – Integer – int
  public static int parseInt(String s)将字符串参数解析为
  带符号的十进制整数。

    //String-->int
        //  方式1：String--Integer--int
        //  Integer(String s)
        //  构造一个新分配 Integer对象，表示 int由指示值 
        //String参数。
        String s4="58888";
        Integer integer1=new Integer(s4);
        //public int intValue()将 Integer的值作为 int
        int num1=integer1.intValue();
        System.out.println(num1);
        int i = integer1; //在包装类中称之为自动拆箱
        Integer i2 = 300; //在包装类中称之为自动装箱


    }
}
  

6. Date:日期类

构造方法：
Date() 分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。

日期格式化：SimpleDateFormat

public class DataDemo {
    public static void main(String[] args) {
      Date date=new Date();
        System.out.println(date);//Sat Jan 22 09:40:27 CST 2022

        //由于我们经常看到时间不是这样的，应该是年，月，日，时分秒
        //日期的格式化
        //SimpleDateFormat(String pattern)
        //使用给定模式 SimpleDateFormat并使用默认的 
        //FORMAT语言环境的默认日期格式符号。
        /**
         *      yyyy：年
         *      MM：月
         *      dd：日
         *      HH：24小时制度
         *      hh：12小时制度
         *      mm：表示分钟
         *      ss：表示秒
         *      EEE:星期
         */
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("YYYY-MM-dd EEE HH:mm:ss");
String s=simpleDateFormat.format(date);
        System.out.println(s);
        //2022-01-22 星期六 09:43:33
    }
}