javase（2023/11/20）

longbow_nice

已于 2023-11-24 11:40:11 修改

阅读量70

点赞数

分类专栏： javase 文章标签： php 开发语言

于 2023-11-20 23:20:59 首次发布

本文链接：https://blog.csdn.net/longbow_nice/article/details/134502201

版权

javase 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1、String类

（

Java序列化是将Java对象转换为一组字节序列，以便在网络上传输或将其存储到磁盘上。Java序列化通过ObjectOutputStream写入流和ObjectInputStream读入流来完成。Java序列化需要将对象实现Serializable接口，以表示该对象可以被序列化
串行化是用于定义数据结构和存储格式的一种技术。它将数据结构和数据存储格式表示为一个字节序列,可以在不同的计算机上进行传输和解释，从而实现数据交换的目的。Java串行化包括XML、JSON等多种形式。
总的来说，Java序列化和串行化是两个截然不同的概念。Java序列化是将Java对象转换为字节序列以便在网络上传输和存储，而Java串行化是用于定义数据结构和存储格式的技术。

）

String对象用于保存字符串，也就是一组字符序列
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。

构造器

package zhh.chapter13.string;

/**
 * @author longbownice
 * @version 1.0
 */
public class String01 {
    public static void main(String[] args) {
        //1. String 类有很多构造器，构造器的重载
        // 常用的有
        String s1 = new String();
        String s2 = new String("abc");
        char[] a={'a','b','c','d','e'};
        String s3 = new String(a);
        //offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度
        String s4 = new String(a,0,2);//ab
        System.out.println(s4);
        byte [] b={97,98,101,102,104};//要解码为字符的字节
        String s5 = new String(b);
        System.out.println(s5);//abefh

        //2. String 是 final 类，不能被其他的类继承
        //3. String 有属性 private final char value[]; 用于存放字符串内容
        //4. 一定要注意：value 是一个 final 类型， 不可以修改(地址)：
        // 即 value 不能指向新的地址，但是单个字符内容是可以变化
        String name = "jack";
        name = "tom";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';//单个字符内容变
        //value = v2; 不可以修改 value 对象
    }
}

String创建对象的两种方式的区别

直接赋值String s ="hsp";
调用构造器 String s2 = new String("hsp");

方式一:先从常量池查看是否有"hsp”数据空间，如果有，直接指向;如果没有则重新创建,然后指向。S最终指向的是常量池的空间地址
方式二:先在堆中创建空间,里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp",重新创建,如果有，直接通过value指向。最终指向的是堆中的空间地址。

字符串的特性

String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的.

package zhh.chapter13.string;

/**
 * @author longbownice
 * @version 1.0
 *
 * 字符串的特性
 */
public class String02 {
    public static void main(String[] args) {
        //1、创建了两个对象，都在常量池中
        String str1 = "hello";
        System.out.println(str1.hashCode());//99162322
        str1="zbc";
        System.out.println(str1.hashCode());//120379

        //2、只创建了一个对象，
        //编译器会优化，相当于String s = "hellozbc"
        String s = "hello" + "abc";
        System.out.println(s.hashCode());//-792668592

        //3、创建了3个对象
        //底层是StringBuilder sb = new StringBuilder();
        // sb.append(a);sb.append(b);
        // sb是在堆中，并且append是在原来字符串的基础上追加的.
        // 重要规则，
        // String c1 = "ab" + "cd";常量相加，看的是池。
        // String c1 = a+b;变量相加,是在堆中
        String hello = "hello";
        String abc = "abc";
        String s1 = hello + abc;
        System.out.println(hello.hashCode());//99162322
        System.out.println(abc.hashCode());//96354
        System.out.println(s1.hashCode());// -792668592

        


    }
}

String常用方法

package zhh.chapter13.string;

/**
 * @author longbownice
 * @version 1.0
 *
 * String常用方法
 */
public class StringMethod {
    public static void main(String[] args) {

        // 1.equalsIgnoreCase 忽略大小写的判断内容是否相等
        //打印Success!
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }

        // 2.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());//3

        // 3.indexOf 获取字符或子串在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0

        // 4.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4

        // 5.substring 截取指定范围的子串
        String name1 = "hello,张三";
        //下面 name.substring(6) 从索引 6 开始截取后面所有的内容
        System.out.println(name1.substring(6));//张三
        //name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
        //substring(int beginIndex, int endIndex)
        //2和5分别是开始下标和结束下标
        System.out.println(name1.substring(2,5));//llo

        // 6.大小写转换
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        System.out.println(s.toLowerCase());//hello

        // 3.concat 拼接字符串
        String s2 = "宝玉";
        s1 = s2.concat("林黛玉").concat("薛宝钗").concat("together");
        System.out.println(s1);//宝玉林黛玉薛宝钗together

        // 4.replace 替换字符串中的字符
        //在 s1 中，将 所有的 林黛玉 替换成薛宝钗
        // s1.replace() 方法执行后，返回的结果才是替换过的.
        // 注意对 s1 没有任何影响
        s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
        String s11 = s1.replace("宝玉", "jack");
        System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
        System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉

        // 5.split 分割字符串, 返回一个数组
        // 以 , 为标准对 poem 进行分割 ,
        // 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        String[] split = poem.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
//        锄禾日当午
//        汗滴禾下土
//        谁知盘中餐
//        粒粒皆辛苦
//        ==分割后内容===
//        E:
//        aaa
//        bbb

        // 6.toCharArray 转换成字符数组
        //和c++不一样
        s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.print(chs[i]+" ");
        }
        //h a p p y 2

        // 7.compareTo 比较两个字符串的大小，
        // 如果前者大，则返回正数，后者大，则返回负数，如果相等，返回 0
        // (1) 如果长度相同，并且每个字符也相同，就返回 0,否则返回第一对不同字符的差值
        // (2) 如果长度不相同，先看前几位相同长度的内容，
        //      如果相同，就返回 str1.len - str2.len
        //      如果不同，返回第一对不同字符的差值，和（1）一样
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值
        b="jcck100";
        System.out.println(a.compareTo(b)); //a.length()-b.length()=4-7=-3
        b="jack000";
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值

        // 8.format 格式字符串
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型
         * %s , %d , %.2f %c 称为占位符
         * 这些占位符由后面变量来替换
         *
         * %s 表示后面由字符串来替换
         * %d 是整数来替换
         * %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
         * %c 使用 char 类型来替换
         */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';

        //将所有的信息都拼接在一个字符串.
        String info = "我的姓名是" + name + ",年龄是" + age + ",成绩是" + score
                + ",性别是" + gender;
        System.out.println(info);
        String formatStr = "我的姓名是%s,年龄是%d,成绩是%.2f,性别是%c";
        String info2 = String.format(formatStr, name, age, score, gender);
        System.out.println(info2);
//        我的姓名是john,年龄是10,成绩是56.857,性别是男
//        我的姓名是john,年龄是10,成绩是56.86,性别是男
        
        //9 intern
        //如果池已经包含一个等于此 String 对象的字符串(用equals(Object)方法确定)，则返回池中的字符串。
        // 否则，将此String 对象添加到池中，并返回此 String对象的引用
        //b.intern()方法最终返回的是常量池的地址（对象)
        String fnflagnege = new String("fnflagnege");
        String str="fnflagnege";
        System.out.println(str==fnflagnege);//false
        System.out.println(str==fnflagnege.intern());//true

    }
}

2、StringBuffer

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是可变长度的。
StrinaBuffer是一个容器。
StringBuffer 的直接父类是 AbstractStringBuilder
StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化
在父类中 AbstractStringBuilder 有属性 char[] value,不是 final,该value 数组存放字符串内容,存放在堆中
StringBuffer 是一个 final 类，不能被继承因为 StringBuffer 字符内容是存在 char[] value, 所有的变化(增加/删除)不用每次都更换地址(即不是每次创建新对象，但value存满后，还是得扩容换个地址迁移)，所以效率高于 String

String和StringBuffer转换

//String——>StringBuffer
String str = "hello tom";
//方式 1 使用构造器，注意： 返回的才是 StringBuffer 对象，对 str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式 2 使用的是 append 方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);


//看看 StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式 1 使用 StringBuffer 提供的 toString 方法
String s = stringBuffer3.toString();
//方式 2: 使用构造器来搞定
String s1 = new String(stringBuffer3）

StringBuffer常用方法

package zhh.chapter13.stringbuffer;

/**
 * @author longbownice
 * @version 1.0
 *
 * StringBuffer常用方法
 */
public class StringBufferMethod {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");

        //增，
        s.append(',');// "hello,"
        s.append("张三丰");//"hello,张三丰"
        s.append("赵敏").append(100).append(true).append(10.5);
        System.out.println(s);//"hello,张三丰赵敏100true10.5"

        //删
        /*
         * 删除索引为>=start && <end 处的字符
         * 解读: 删除 11~14 的字符 [11, 14)
         */
        s.delete(11, 14);
        System.out.println(s);//"hello,张三丰赵敏true10.5"

        //改
        //使用 周芷若 替换 索引 9-11 的字符 [9,11)
        s.replace(9, 11, "周芷若");
        System.out.println(s);//"hello,张三丰周芷若 true10.5"
        //查找
        // 指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6

        //插
        //在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
        s.insert(9, "赵敏");
        System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"

        //长度
        System.out.println(s.length());//22
        System.out.println(s);

        //对于append的进一步理解
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);//底层调用的是 AbstractStringBuilder 的 appendNull
        /*
        private AbstractStringBuilder appendNull() {
            int c = count;
            ensureCapacityInternal(c + 4);
            final char[] value = this.value;
            value[c++] = 'n';
            value[c++] = 'u';
            value[c++] = 'l';
            value[c++] = 'l';
            count = c;
            return this; //返回一个char型{'n','u','l','l'}
        }
         */


        System.out.println(sb.length());//4
        System.out.println(sb);//null

        //构造器的理解StringBuffer(String)
        //下面的构造器，会抛出 NullpointerException
        //底层是
        /*
        public StringBuffer(String str) {
            //相当于null.length(),空指针异常，
            //同时也可以看出，若str不空，value的容量是16+str的长度
            super(str.length() + 16);
            append(str);
        }
         */

        try {
            StringBuffer sb1 = new StringBuffer(str);
            System.out.println(sb1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3、StringBuilder

一个可变的字符序列。此类提供一个与 StringBuffer兼容的APl，该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，优先采用该类.因为在大多数实现中，它比 StringBuffer 要快
.StringBuilder 的方法，没有做互斥的处理,即没有 synchronized 关键字,因此在单线程的情况下使用
StringBuilder的方法使用和StringBuffer一样

String、StringBuffer和 StringBuilder 的比较

StringBuilder和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
String:不可变字符序列,效率低,但是复用率高。
StringBuffer:可变字符序列、效率较高(增删)、线程安全
StringBuilder:可变字符序列、效率最高、线程不安全
效率StringBuilder>StringBuffer>String
String使用注意说明:

string s="a";//创建了一个字符串
s += "b";//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b”(也就是"ab")
如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论:如果我们对String做大量修改,不要使用String

String、StringBuffer和 StringBuilder的选择使用的原则,结论:

如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情况,使用 StringBuilder
如果字符串存在大量的修改操作，并在多线程的情况,使用 StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String, 比如配置信息等

4、Math

package zhh.chapter13.math;

/**
 * @author longbownice
 * @version 1.0
 *
 * Math类常用方法，大部分都是静态
 */
public class Math_ {
    public static void main(String[] args) {

        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9

        //2.pow 求幂
        double pow = Math.pow(2, 4);//2 的 4 次方
        System.out.println(pow);//16

        //3.ceil 向上取整,返回>=该参数的最小整数(转成 double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0

        //4.floor 向下取整，返回<=该参数的最大整数(转成 double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0

        //5.round 四舍五入 Math.floor(该参数+0.5)
        long round = Math.round(5.51);
        System.out.println(round);//6

        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0

        //7、max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);

        //7.random 求随机数
        // random 返回的是 0 <= x < 1 之间的一个随机小数
        System.out.println(Math.random());
        //返回一个在范围在[11,60]的整数
        //公式就是 (int)(a + Math.random() * (b-a +1) ),
        //Math.random() * (b-a +1)就是[0,b-a+1)
        //(int)([a,b+1))
        //[a,b]
        for(int i = 0; i < 10; i++) {
            System.out.print((int)(11 + Math.random() * (60 - 11 + 1))+" ");
        }
        //26 48 16 56 21 35 40 26 42 22 

    }
}