10.String\Builder类

最新推荐文章于 2024-09-16 19:01:17 发布

Stella....

最新推荐文章于 2024-09-16 19:01:17 发布

阅读量153

点赞数

分类专栏： Java学习

本文链接：https://blog.csdn.net/m0_47239364/article/details/109480312

版权

Java学习专栏收录该内容

14 篇文章 1 订阅

订阅专栏

一、math类
1.直接使用，无需导包
2.final修饰，不能被继承
3.构造器私有化，不能创建math类的对象
4math内部所有属性都被static修饰，调用：类名.方法名

        System.out.println(Math.PI);
        System.out.println("随机数"+Math.random());//[0.0.,1.0)
        System.out.println("绝对数"+Math.abs(-12));
        System.out.println("向下取值"+Math.floor(9.9));
        System.out.println("向上取值"+Math.ceil(9.1));
        System.out.println("四舍五入"+Math.round(3.7));
        System.out.println(Math.max(3, 9));
        System.out.println(Math.min(3, 9));


```c
import java.lang.Math.*;
public class Test01 {
    public static void main(String[] args) {
        //常用方法
        System.out.println(Math.PI);
        System.out.println("随机数"+random());//[0.0.,1.0)
        System.out.println("绝对数"+abs(-12));
        System.out.println("向下取值"+floor(9.9));
        System.out.println("向上取值"+ceil(9.1));
        System.out.println("四舍五入"+round(3.7));
        System.out.println(max(3, 9));
        System.out.println(min(3, 9));
    }
    //方法重复，会优先先走重新定义的方法
    public static int random(){
        return 1000;
    }

二、random类

public static void main(String[] args) {

        //有参构造器
        Random R1=new Random(System.currentTimeMillis());
        int i = R1.nextInt();
        System.out.println(i);

        //空参构造器
        Random r2=new Random();//表面无参实际调用有参
        int i1 = r2.nextInt(100);//生成0-100之间的一个随机数
        System.out.println(r2.nextDouble());//生成0.0到1.0之间的一个随机数
        System.out.println(i1);
    }

三、String类
1.直接使用无需导包
在这里插入图片描述
2.不可以继承

3.底层为字符串

4.equals（）方法

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;//当俩个对象的地址相同时，返回true,自己和自己比较的时候，直接返回ture
        }
        if (anObject instanceof String) {//传入String的具体实例化
            String anotherString = (String)anObject;//向下转型为字符串类型
            int n = value.length;
            if (n == anotherString.value.length) {//如果俩个数组长度不一样不进行判断
                char v1[] = value;//将字符赋给数组
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {//数组遍历，按位操作
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

5.compareto（）方法
源码：

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];//若c1,c2在k里相同，则返回俩个字符长度的差值.
            char c2 = v2[k];//若c1,c2在k的限度里字符不相同，则返回相应ASSCII的差值
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

6.常用方法
【1】substring方法

        //substring方法字符串截取
        String s7="qwwretru";
        System.out.println(s7.substring(3));
        System.out.println(s7.substring(3,5));//[3,5)

【2】concat()方法

       //concat()方法字符串的拼接
        System.out.println(s7.concat("ddddd"));

【3】replace（）方法

       //replace方法字符串中的字符的替换
        String s8="adadads";
        System.out.println(s8.replace('a','r'));//out:rdrdrds

【4】split方法

 //spilt 方法  按照指定的字符串进行分裂为数组
        String s9="a-b-c-d";
        String[] split = s9.split("-");
        System.out.println(Arrays.toString(split));

【4】toUpperCase()和toLowerCase()方法

        //转换大小写
        String s10="abc";
        System.out.println(s10.toUpperCase());
        System.out.println(s10.toUpperCase().toLowerCase());

【5】trim（）方法

       //trim()方法 去除首位空格
        String s11=" a b c d ";
        System.out.println(s11.trim());

【6】valueof()方法


        //valueof()方法
        System.out.println(String.valueOf(true));

5.内存分析
【1】字符串拼接创建对象

 public static void main(String[] args) {
        String s1="a"+"b"+"c";
        String s2="ab"+"c";
        String s3="a"+"bc";
        String s4="abc";
        String s5="abc"+"";
    }

上面的字符串会进行编译器优化，直接合并为完整的字符串
常量池：第一次若是没有字符串就放进去，如果有这个字符串就直接从常量池中取出
在这里插入图片描述
【2】new关键字创建对象

       String s6=new String();

开辟了俩个空间（1.字符串常量池中的字符串 2.堆中开辟的空间）
在这里插入图片描述
【3】有变量参与的字符串拼接

public static void main(String[] args) {
        String a="abc";
        String b = a + "def";
        System.out.println(b);
    }

a变量编译的时候不知道a是“abc”字符，不会进行编译的优化，不会直接合成“abcdef”
在这里插入图片描述
字节码分析
六、StringBuilder类
1.字符串分类
不可变字符：String类型
可变字符：StringBuilder,StringBuffer
StringBuilder

 public static void main(String[] args) {
        //AbstractStringBuilder(int capacity) {
        //        value = new char[capacity];
        //    }
        StringBuilder b=new StringBuilder();
        //表面掉空构造器，实际是对value数组进行初始化，长度为16
        StringBuilder c=new StringBuilder(3);
        //表面调用有参构造器，传入int类型的是就是对value数组进行初始化，长度为传入的数字
        StringBuilder d=new StringBuilder("abc");
        d.append("def");

         
    }

2.可变、不可变字符
不可变：在地址不变的情况下，把字符串改变是不可能的
可变：在String这个对象的地址不变的情况下，改变字符串是可以的

        StringBuilder d=new StringBuilder();
        d.append("abc");
        d.append("def");
        System.out.println(d.append("abc")==d.append("def"));

3.stringbuilder常用方法

       StringBuilder a=new StringBuilder();
        System.out.println(a.append(true));
        System.out.println(a.append(2));
        System.out.println(a.append("abc"));
        System.out.println(a.append(12345678l));
        System.out.println(a.append(12.4));
        System.out.println(a.insert(3, "DDD"));

4.String,Stringbuilder,StringBuffer的区别
（1）string类是不可变类，既string 对象被创建后，包含在这个对象中的字符序列是不可以改变的，直至这个对象销毁；
（2）StringBuffer类则代表一个字符序列可变的字符串，可以通过apend,insert,reverse,setChatA,setLength等方法该笔那其内容，一旦生成最终的字符串，调用to.string方法将其转变为String
（3）一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
StringBuilderJDK1.5开始效率高，线程不安全
StringbufferJDK1.0开始，效率低，线程安全