Java Day11

已于 2023-10-12 00:20:44 修改
阅读量42 收藏
点赞数 1
分类专栏： Java 文章标签： java 开发语言
于 2023-08-18 19:11:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51944132/article/details/132367663
版权

Java

day11——2023.8.18

BigInteger

大整数的运算

/*
BigInteger类
 */
public class Demo08 {
    public static void main(String[] args) {
        //Integer i = 1234567;
        //i = i * 54321;
        //System.out.println(i);
        //System.out.println(Integer.MAX_VALUE);
        Integer i1 = new Integer("2147483647");
        System.out.println(i1);
        //Integer i2 = new Integer("2147483648");
        //System.out.println(i2);
        BigInteger bi = new BigInteger("2147483648");
        System.out.println(bi);
        //System.out.println(bi + 100);  //不能直接使用加号

        BigInteger bi2 = new BigInteger("100");
        //BigInteger add(BigInteger val)
        //返回值为 (this + val)
        System.out.println(bi.add(bi2));
        //BigInteger divide(BigInteger val)
        //返回值为 (this / val) 。
        System.out.println(bi.divide(bi2));
        //BigInteger multiply(BigInteger val)
        //返回值为 (this * val) 。
        System.out.println(bi.multiply(bi2));

        //BigInteger subtract(BigInteger val)
        //返回值为 (this - val) 。
        System.out.println(bi.subtract(bi2));
        //int intValue()
        //将此BigInteger转换为 int  
        //如果bigInteger超过了范围,转为int之后,值会发生改变
        int i = bi.intValue();
        System.out.println(i);
    }
}

BigDecimal

主要用来做浮点数的运算，防止精度丢失

构造方法

BigDecimal(String val) 将BigDecimal的字符串表示 BigDecimal转换为 BigDecimal 。

BigDecimal(int val) 将 int成 BigDecimal 。

BigDecimal(double val) 将 double转换为 BigDecimal ，这是 double的二进制浮点值的精确十进制表示。

public class Demo09 {
    public static void main(String[] args) {

       // new BigDecimal();
        System.out.println(1-0.01);
        System.out.println(0.09 + 0.01);
        System.out.println(1.015 * 100);

        //创建BigDecimal对象
        BigDecimal b1 = new BigDecimal("0.09");
        BigDecimal b2 = new BigDecimal("0.01");

        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        System.out.println(b1.divide(b2));
    }
}

String类

String类用来表示字符串，所有的字符串都可以看做是String类的实例(对象)

String类的字符串，其实底层就是char类型的数组

String类声明的字符串是不可变的，它们的值在创建后不能被更改，如果字符串值被改变，那么其实是字符串变量对应的引用改变

构造方法

String() 初始化新创建的 String对象，使其表示空字符序列。

String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String

String(char[] value) 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。

String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

String(StringBuffer buffer) 分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。

String(StringBuilder builder) 分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列。

普通方法

char charAt(int index) 返回 char指定索引处的值。

String concat(String str) 将指定的字符串连接到该字符串的末尾。

boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。

boolean equals(Object anObject) 将此字符串与指定对象进行比较。

boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略大小写

int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。

int indexOf(String str, int fromIndex) 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。

boolean isEmpty() 返回 true如果，且仅当 length()为 0 。

int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。

int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。

int length() 返回此字符串的长度。

String replace(char oldChar, char newChar)

返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。

String replaceAll(String regex, String replacement)

用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

String replaceFirst(String regex, String replacement)

用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。

String[] split(String regex)

将此字符串分割为给定的 regular expression的匹配。

String substring(int beginIndex)

返回一个字符串，该字符串是此字符串的子字符串。

String substring(int beginIndex, int endIndex)

返回一个字符串，该字符串是此字符串的子字符串。

char[] toCharArray()

将此字符串转换为新的字符数组。

String toLowerCase()

将所有在此字符 String使用默认语言环境的规则，以小写。

String toUpperCase()

将所有在此字符 String使用默认语言环境的规则大写。

String trim()

返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。

public class StringDemo01 {
    public static void main(String[] args) {
        String s = "abcdefabcd";
        //char charAt(int index) 	返回 char指定索引处的值。
        System.out.println(s.charAt(3)); // d

        //String concat(String str) 	将指定的字符串连接到该字符串的末尾。
        String s1 = s.concat("test");
        System.out.println(s1);

        //boolean contains(CharSequence s) 	当且仅当此字符串包含指定的char值序列时才返回true。
        System.out.println(s.contains(s1));


        //boolean equals(Object anObject) 	将此字符串与指定对象进行比较。
        System.out.println("abcd".equals(s));

        //boolean equalsIgnoreCase(String anotherString) 	将此 String与其他 String比较，忽略大小写
        System.out.println("abCdEfAbcd".equalsIgnoreCase(s));


        //int indexOf(String str) 	返回指定子字符串第一次出现的字符串内的索引。
        System.out.println(s.indexOf("d"));
        //int indexOf(String str, int fromIndex) 	返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
        System.out.println(s.indexOf("d",4));

        //boolean isEmpty() 	返回 true如果，且仅当 length()为 0 。
        System.out.println(s.isEmpty());

        //int lastIndexOf(String str) 	返回指定子字符串最后一次出现的字符串中的索引。
        System.out.println(s.lastIndexOf("d"));
        //int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。
        System.out.println(s.lastIndexOf("d",2));

        //int length() 	返回此字符串的长度。
        //数组有没有length()方法，字符串有没有length属性

        System.out.println(s.length());
        //String replace(char oldChar, char newChar)
        //将旧字符串替换为新的
        //"abcdefabcd"
        String s2 = s.replace("abc", "ABC");
        System.out.println(s2);

        //String replaceAll(String regex, String replacement)
        //用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

        //String replaceFirst(String regex, String replacement)
        //用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
        String s3 = s.replaceFirst("abc", "ABC");
        System.out.println(s3);

        //String[] split(String regex)
        //将此字符串分割为给定的 regular expression的匹配。
        String[] s4 = s.split("");
        System.out.println(Arrays.toString(s4));
        String[] s5 = s.split("b");
        System.out.println(Arrays.toString(s5));

        //String substring(int beginIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。
        //String substring(int beginIndex, int endIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。

        System.out.println(s.substring(3));
        System.out.println(s.substring(3,6));

        //char[] toCharArray()
        //将此字符串转换为新的字符数组。

        //String toLowerCase()
        //将所有在此字符 String使用默认语言环境的规则，以小写。
        //String toUpperCase()
        //将所有在此字符 String使用默认语言环境的规则大写。

        System.out.println(s.toUpperCase());
        //String trim()
        //返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
        String s6 = "    adsag           ";
        System.out.println(s6);
        System.out.println(s6.trim());
    }
}

使用String中的方法，
求 ： 一串大的字符串"adagjavagawegjavafwnaljavafwjavaafjava"中小字符串"java" 出现的次数。

public class StringDemo02 {
    public static void main(String[] args) {
        //求 ： 一串大的字符串"adagjavagawegjavafwnaljavafwjavaafjava"
        // 中小字符串"java" 出现的次数。

        //将小字符的长度，带入大字符串中去截取，替换原来的大字符串，如此循环

        String str1 = "adagjavagawegjavafwnaljavafwjavaafjava";
        String str2 = "java";
        //先去找java在大字符串中，第一次出现的位置 ,如果能找到，index ！= -1
        int index = str1.indexOf(str2);
        int count = 0;
        while (index != -1){
            count ++; //统计变量自增
            //将大字符串截取后，替换原来的大字符串
            str1 = str1.substring(index + str2.length());
            index = str1.indexOf(str2);
        }
        System.out.println(count);
    }
}

把字符串 "abcdefg"做翻转后输出

public class StringDemo03 {
    public static void main(String[] args) {
        //把字符串 "abcdefg"做翻转后输出
        //先转数组
        //从后向前遍历,做拼接
        String s = "abcdefg";
        char[] chars = s.toCharArray();
        String s1 = "";
        for (int i = chars.length-1; i >=0 ; i--) {
            s1 += chars[i];
        }
        System.out.println(s1);
    }
}

StringBuffer类

StringBuffer是一个字符串缓冲区类

String类型声明的字符串，不可变，所以每次拼接字符串的时候，都会产生新的引用，所以，使用String来完成字符串拼接，比较消耗资源

所以，Java中提供了这个StringBuffer类，让我们可以用来完成字符串拼接等其他的操作

构造方法

StringBuffer()

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

StringBuffer(CharSequence seq)

构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。

StringBuffer(int capacity)

构造一个没有字符的字符串缓冲区和指定的初始容量。

StringBuffer(String str)

构造一个初始化为指定字符串内容的字符串缓冲区。

普通方法

StringBuffer append(CharSequence s) 追加指定的 CharSequence到这个序列。

int capacity() 返回当前容量。

StringBuffer delete(int start, int end) 删除此序列的子字符串中的字符。

StringBuffer insert(int offset, String str) 将字符串插入到此字符序列中。

StringBuffer reverse() 导致该字符序列被序列的相反代替。

String toString() 返回表示此顺序中的数据的字符串。

public class StringBufferDemo {
    public static void main(String[] args) {
        //创建缓冲区对象
        StringBuffer sb1 = new StringBuffer("abcd");

        System.out.println(sb1);

        StringBuffer sb2 = sb1.append("abcdefgh");
        System.out.println(sb2);
        System.out.println(sb1);
        //sb1 == sb2  返回true，说明新的内容是直接添加在原来的内容中的
        //也就是堆中的区域并没有改变，地址也没有变化
        System.out.println(sb1 == sb2);  //true
        //空间大小受构建对象时候传入的参数个数影响
        System.out.println(sb1.capacity());

        //删除也是在原对象基础上删除
        StringBuffer sb3 = sb1.delete(4, 6); //删除4,5
        System.out.println(sb3);
        System.out.println(sb1);

        //insert插入,指定位置插入
        sb1.insert(2,"hello");
        System.out.println(sb1);

        //翻转
        sb1.reverse();
        System.out.println(sb1);
    }
}

StringBuffer和String拼接字符串效率对比

public class StringBufferDemo01 {
    public static void main(String[] args) {
       //给String  拼接 10000次字符串
        long start = System.currentTimeMillis();
        String s = "hello";
        for (int i = 0; i < 10000; i++) {
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        //给StringBuffer拼接10000次字符串
        long start1 = System.currentTimeMillis();
        StringBuffer sb1 = new StringBuffer("hello");
        for (int i = 0; i < 100000; i++) {
            sb1.append(i);
        }
        long end1 = System.currentTimeMillis();
        System.out.println(end1 - start1);


        long start2 = System.currentTimeMillis();
        StringBuilder sb2 = new StringBuilder("hello");
        for (int i = 0; i < 100000; i++) {
            sb2.append(i);
        }
        long end2 = System.currentTimeMillis();
        System.out.println(end2 - start2);
    }
}

String、StringBuffer、StringBuilder的区别

String声明的字符不可变，可以看做是字符串常量，String的内容一旦改变，引用就改变了，可以看成是一个新的引用，所以，String类型做字符串拼接，比较耗时

StringBuffer称为字符串缓冲区，提供了一些方法，可以改变该缓冲区中的数据，但是对应的引用没有改变，相对来说StringBuffer效率更快

StringBuffer和StringBuilder ，他们都是字符串缓冲区，只不过StringBuffer的方法多了一个 synchronized关键字，它是线程安全的。多线程情况下，用StringBuffer，单线程就用StringBuilder

String 和 StringBuffer的转换

String类型转换为StringBuffer一般是为了使用StringBuffer类型的方法

将来程序中需要的还是String，所以还得转回来

public class StringBufferDemo02 {
    public static void main(String[] args) {
        //string ->stringbuffer
        String s = "hello";
        //直接赋值，强制转换都不行
        //StringBuffer sb1 = (StringBuffer) s;

        //1,通过构造方法
        StringBuffer sb1 = new StringBuffer(s);

        //2,通过append方法
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);


        //StringBuffer -> String
        //1,通过String类的构造方法
        String s1 = new String(sb1);
        
        //2,通过toStrig()方法
        String s2 = sb1.toString();
    }
}
丨陈墨瞳丨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值