Java中String、StringBuffer 等常用类

最新推荐文章于 2023-06-28 18:48:46 发布

张昂之.

最新推荐文章于 2023-06-28 18:48:46 发布

阅读量435

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_46484093/article/details/105798864

版权

笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

String

1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。

2、在java中随便使用双引号括起来的都是String对象。例如：“abc”，“def”，“hello world!”，这是3个String对象。

3、java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"

4、在JDK当中双引号括起来的字符串，例如：“abc” "def"都是直接存储在“方法区”的“字符串常量池”当中的。
为什么SUN公司把字符串存储在一个“字符串常量池”当中呢。因为字符串在实际的开发中使用太频繁。为了执行效率，所以把字符串放到了方法区的字符串常量池当中。

 public static void main(String[] args) {
        String s1 = "hello";
        // "hello"是存储在方法区的字符串常量池当中
        // 所以这个"hello"不会新建。（因为这个对象已经存在了！）
        String s2 = "hello";
        // 分析结果是true还是false？
        // == 双等号比较的是不是变量中保存的内存地址？是的。
        System.out.println(s1 == s2); // true

        String x = new String("xyz");
        String y = new String("xyz");
        // 分析结果是true还是false？
        // == 双等号比较的是不是变量中保存的内存地址？是的。
        System.out.println(x == y); //false

        // 通过这个案例的学习，我们知道了，字符串对象之间的比较不能使用“==”
        // "=="不保险。应该调用String类的equals方法。
        // String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。
        System.out.println(x.equals(y)); // true

        String k = new String("testString");
        //String k = null;
        // "testString"这个字符串可以后面加"."呢？
        // 因为"testString"是一个String字符串对象。只要是对象都能调用方法。
        System.out.println("testString".equals(k)); // 建议使用这种方式，因为这个可以避免空指针异常。
        System.out.println(k.equals("testString")); // 存在空指针异常的风险。不建议这样写。
    }
}

关于String类中的构造方法

String s = new String("");

//创建一个字符串对象,不常用
String s=new String("abc");

String s = " ";

//常用方法
String s="abc"

String s = new String(char数组);

//创建一个char数组
 char[] chars = {'张','小','小','是','猪'};
//将char数组装换成字符串
String s4 = new String(chars);//张小小是猪

String s = new String(char数组,起始下标,长度);

//创建一个char数组
 char[] chars = {'张','小','小','是','猪'};
//将char数组装换成字符串
String s4 = new String(chars, 0, 3);//张小小

String s = new String(byte数组);

//创建一个byte数组
//97是a,98是b,99是c
byte[] bytes = {97, 98, 99};
//调用方法把byte数组装换成字符串
 String s2 = new String(bytes);//abc

String s = new String(byte数组,起始下标,长度)

//创建一个byte数组
//97是a,98是b,99是c
byte[] bytes = {97, 98, 99};
//调用方法把byte数组装换成字符串
 String s2 = new String(bytes，1,2);//bc

关于String类中的常用方法

.charAt(int index)

//"中国人"是一个字符串String对象。只要是对象就能调方法
 char c = "中国人".charAt(1); 
   System.out.println(c); // 国

.compareTo(String anotherString)

 // 字符串之间比较大小不能直接使用 > < ，需要使用compareTo方法。
   int result = "abc".compareTo("abc");
   System.out.println(result); //0（等于0） 前后一致  10 - 10 = 0

   int result2 = "abcd".compareTo("abce");
   System.out.println(result2); //-1（小于0） 前小后大 8 - 9 = -1

   int result3 = "abce".compareTo("abcd");
   System.out.println(result3); // 1（大于0） 前大后小 9 - 8 = 1
  // 拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。
  System.out.println("xyz".compareTo("yxz")); // -1

.contains(CharSequence s)

 // 判断前面的字符串中是否包含后面的子字符串。
    System.out.println("HelloWorld.java".contains(".java")); // true
    System.out.println("http://www.baidu.com".contains("https://")); // false

.startsWith(String prefix)

 // 判断某个字符串是否以某个子字符串开始。
   System.out.println("http://www.baidu.com".startsWith("http")); // true
   System.out.println("http://www.baidu.com".startsWith("https")); // false

.endsWith(String suffix)

  // 判断当前字符串是否以某个子字符串结尾。
    System.out.println("test.txt".endsWith(".java")); // false
    System.out.println("test.txt".endsWith(".txt")); // true
    System.out.println("fdsajklfhdkjlsahfjkdsahjklfdss".endsWith("ss")); // true

.equals(Object obj)

   // 比较两个字符串必须使用equals方法，不能使用“==”
   System.out.println("abc".equals("abc")); // true

.equalsIgnoreCase(String anotherString)

  // 判断两个字符串是否相等，并且同时忽略大小写。
    System.out.println("ABc".equalsIgnoreCase("abC")); // true

.getBytes()

 // 将字符串对象转换成字节数组
    byte[] bytes = "abcdef".getBytes();
      for(int i = 0; i < bytes.length; i++){
            System.out.println(bytes[i]);
        }
//97,98,99...

.indexOf(String str);

  // 判断某个子字符串在当前字符串中第一次出现处的索引（下标）。
   System.out.println("oraclejavac++.".indexOf("java")); // 6

.isEmpty();

 // 判断某个字符串是否为“空字符串”。底层源代码调用的应该是字符串的length()方法。
        //String s = "";
        String s = "a";
        System.out.println(s.isEmpty());

.length()

 // 判断数组长度和判断字符串长度不一样
 // 判断数组长度是length属性，判断字符串长度是length()方法。
  System.out.println("abc".length()); // 3
  System.out.println("".length()); // 0

.lastIndexOf(String str)

 // 判断某个子字符串在当前字符串中最后一次出现的索引（下标）
  System.out.println("oraclejavac++".lastIndexOf("java")); //22

.replace(CharSequence target, CharSequence replacement);

 // 替换。
 // String的父接口就是：CharSequence
   String str= "http://www.baidu.com".replace("http://", "https://");
        System.out.println(str); //https://www.baidu.com
        // 把以下字符串中的“=”替换成“:”
        String str2 = "name=zhangsan&password=123&age=20".replace("=", ":");
        System.out.println(str2); //name:zhangsan&password:123&age:20

.split(String regex);

   // 拆分字符串
    String[] str = "1980-10-11".split("-"); //"1980-10-11"以"-"分隔符进行拆分。
        for(int i = 0; i < str.length; i++){
            System.out.println(str[i]);
        }
        String param = "name=zhangsan&password=123&age=20";
        String[] params = param.split("&");
        for(int i = 0; i <params.length; i++){
            System.out.println(params[i]);
            // 可以继续向下拆分，可以通过“=”拆分。
        }

.toLowerCase();

 // 转换为小写。
   System.out.println("ABCDefKXyz".toLowerCase());
//abcdefkxyz

.trim();

 // 去除字符串前后空白
   System.out.println("  hello   world  ".trim());
   //hello   world

.valueOf();

//静态的，不需要new对象
// 作用：将“非字符串”转换成“字符串”
    String s1 = String.valueOf(true);
    String s1 = String.valueOf(100);
    String s1 = String.valueOf(3);

StringBuffer

思考：我们在实际的开发中，如果需要进行字符串的频繁拼接，会有什么问题？

因为java中的字符串是不可变的，每一次拼接都会产生新字符串。这样会占用大量的方法区内存。造成内存空间的浪费。
String s = “abc”;
s += “hello”;
就以上两行代码，就导致在方法区字符串常量池当中创建了3个对象： “abc”, “hello”, “abchello”

所以如果以后需要进行大量字符串的拼接操作，建议使用JDK中自带的：
java.lang.StringBuffer

public static void main(String[] args) {

 // 创建一个初始化容量为16个byte[] 数组。（字符串缓冲区对象）
   StringBuffer stringBuffer = new StringBuffer();
 // 拼接字符串，以后拼接字符串统一调用 append()方法。
 // append是追加的意思。
   stringBuffer.append("a");
   stringBuffer.append("b");
   stringBuffer.append("d");
   stringBuffer.append(3.14);
   stringBuffer.append(true);
 // append方法底层在进行追加的时候，如果byte数组满了，会自动扩容。
   stringBuffer.append(100L);
   System.out.println(stringBuffer.toString());

 // 指定初始化容量的StringBuffer对象（字符串缓冲区对象）
    StringBuffer sb = new StringBuffer(100);
     sb.append("hello");
     sb.append("world");
      System.out.println(sb)；//helloworld
    }
}

扩展
1、面试题：String为什么是不可变的？
我看过源代码，String类中有一个byte[]数组，这个byte[]数组采用了final修饰，因为数组一旦创建长度不可变。并且被final修饰的引用一旦指向某个对象之后，不可再指向其它对象，所以String是不可变的！
“abc” 无法变成 “abcd”

2、StringBuilder/StringBuffer为什么是可变的呢？
我看过源代码，StringBuffer/StringBuilder内部实际上是一个byte[]数组，这个byte[]数组没有被final修饰，StringBuffer/StringBuilder的初始化容量我记得应该是16，当存满之后会进行扩容，底层调用了数组拷贝的方法
System.arraycopy()…是这样扩容的。所以StringBuilder/StringBuffer，适合于使用字符串的频繁拼接操作。

 public static void main(String[] args) {
  // 字符串不可变是什么意思？
  // 是说双引号里面的字符串对象一旦创建不可变。
     String s = "abc"; //"abc"放到了字符串常量池当中。"abc"不可变。
  // s变量是可以指向其它对象的。
  // 字符串不可变不是说以上变量s不可变。说的是"abc"这个对象不可变。
    s = "xyz";
    //"xyz"放到了字符串常量池当中。"xyz"不可变

Date

1、获取系统当前时间

 // 直接调用无参数构造方法就行。
	Date d = new Date();

2、日期格式化：Date --> String

  //调用方法格式化日期
	SimpleDateFormat sdf = new SimpleDate("yyyy-MM-dd HH:mm:ss SSS");
	String s = sdf.format(new Date());

3、String --> Date

// 假设现在有一个日期字符串String，怎么转换成Date类型？
   String time = "2008-08-08 08:08:08 888"; //SimpleDateFormat sdf2 = new SimpleDateFormat("格式不能随便写，要和日期字符串格式相同");
// 注意：字符串的日期格式和SimpleDateFormat对象指定的日期格式要一致。不然会出现异常：java.text.ParseException
   SimpleDateFormat sdf2 = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
   Date dateTime = sdf2.parse(time);
   System.out.println(dateTime); //Fri Aug 08 08:08:08 CST 2008

4、获取毫秒数

	long begin = System.currentTimeMillis();
    Date d = new Date(begin - 1000 * 60 * 60 * 24);

Number

1、BigDecimal 属于大数据，精度极高。不属于基本数据类型，属于java对象（引用数据类型）这是SUN提供的一个类。专门用在财务软件当中。

 public static void main(String[] args) {
  // 这个100不是普通的100，是精度极高的100
      BigDecimal v1 = new BigDecimal(100);
      // 精度极高的200
      BigDecimal v2 = new BigDecimal(200);
  // 求和
  // v1 + v2; // 这样不行，v1和v2都是引用，不能直接使用+求和。
      BigDecimal v3 = v1.add(v2); // 调用方法求和。
      System.out.println(v3); //300
      BigDecimal v4 = v2.divide(v1);
      System.out.println(v4); // 2
    }
}

Random

随机数

public static void main(String[] args) {
 // 创建随机数对象
     Random random = new Random();
 // 随机产生一个int类型取值范围内的数字。
     int num1 = random.nextInt();
     System.out.println(num1);
 // 产生[0~100]之间的随机数。不能产生101。
 // nextInt翻译为：下一个int类型的数据是101，表示只能取到100.
     int num2 = random.nextInt(101); //不包括101
     System.out.println(num2);
    }
}

张昂之.

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java中String、StringBuffer 等常用类

String1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。2、在java中随便使用双引号括起来的都是String对象。例如：“abc”，“def”，“hello world!”，这是3个String对象。3、java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"4、在JDK当中双引号括起...
复制链接

扫一扫

专栏目录