Javase | String字符串 - 1

一只大皮卡丘

已于 2023-09-10 11:32:06 修改

阅读量256

点赞数 5

分类专栏： Java知识点-整合文章标签：开发语言 Java String

于 2023-09-09 23:55:51 首次发布

本文链接：https://blog.csdn.net/m0_70720417/article/details/132783892

版权

Java知识点-整合专栏收录该内容

36 篇文章 1 订阅

订阅专栏

1.字符串 (String)

JDK中内置的一个类： Java.lang.String。
String表示字符串类型，属于引用数据类型，不属于基本数据类型。。
在java中用双引号括起来的的都是String对象，都存储在“字符串常量池”中。例如”abc“ 、”abcde“，这两个都是字符串。
String字符串是不可变的，也就是说”abc“ 自出生到死亡，是不可变的，不能变成”abcd“，也不能变成“ab”
字符串存储“方法区” 中的 “字符串常量池”中。
（把数据放在字符串常量池中的原因：字符串使用很频繁）

例子1如：

  /**
  * s1是对象的引用，s1的内存空间在“栈”的 “main方法栈帧”中，s1存放的是这个对象的“内存地址”
  * 这个“内存地址”指向"方法区"中的"字符串常量池"中的“"abcdef"对象
  * 
  * 同时s1是个局部变量 (该变量在main方法中)
  */
  String s1 = "abcdef";  // 字符串是不可变的

//这里的 "abcdef" 没发生改变，所以没必要新建，直接从字符串常量池中获得 "abcdef"对象即可。
//把数据放在字符串常量池的原因： 字符串使用很频繁
//  "xy" --- 在字符串常量池中新建了一个String对象
// "abcdef" 和 "xy" 相结合，形成了一个新的字符串 “abcdefxy”,存放在字符串常量池中
  String s2 = "abcdef" + "xy";
//此时字符串常量池中有三个字符串对象


//用new对象的方式来创建字符串对象
//双引号括起来的字符串都在“字符串常量池”中有一份
//new对象时会在“堆内存”中开辟空间
//对内存中的String对象也是指向“字符串常量池”中的“xy”
//  new String("xy"); 对象的“内存地址”赋给了 s3
//s3是对象的引用，在内存中位置为“栈”中“main方法栈帧”中，存储的是其对象的内存的内存地址，同时“堆内存”中的该对象指向“字符串常量池”中“xy ”
  String s3 = new String("xy"); //在堆内存中开辟空间

上述代码中(例子1)的内存图：

在这里插入图片描述

例子2如：

public class User {
    private int id;
    private String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {

        //在“堆内存”中会存储一个“User对象”
        //“张三”这个值传最终传给 String name
        //在堆内存中有一个 “String name” ，其保存的是 “张三”这个字符串常量的“内存地址”，			这个“内存地址”指向“字符串常量池”中的“张三”对象
        // name变量中存的是 “张三”这个对象的内存地址
        User user = new User(101, "张三"); // "张三"存储在“字符串常量池”中
        /**
         *  User user 中的user的对象的引用，其的内存空间为“栈”的“main方法栈帧”中，其中		 *	存储的是该对象的“内存地址”
         *  该“内存地址”指向“堆内存中的”的User对象
         */
    }
}

上述代码(例子2)中的内存图：

在这里插入图片描述

2.new String对象和不new String对象时内存分析：

2.1 不new String对象时内存分析

//String s1 是一个变量
// s1是对象的引用 : 其的内存空间在“栈”的“main方法栈帧”中，其存储的内容为 "Hello"对象的内存地址
//这个内存地址指向 "Hello" 对象
//"Hello" 存储在“字符串常量池”中
String s1 = "Hello";
//所以第一个"Hello" 不会新建，直接拿来就行（因为这个对象已经存在了）
// s2中存的也是同一个"Hello" 对象的内存地址
String s2 = "Hello";
/*
对于对象引用类型:“==”比较的是对象的内存地址
对于基本类型数据,“==”其实比较的是它的值
*/
//此处的 == 号比较的是内存地址
System.out.println(s1==s2);  //true （两者都指向同一对象，内存地址一样）

上述代码的内存图：

在这里插入图片描述

2.2 new String对象时内存分析

 //创建了两个String对象
 /*
 String x : 是一个“变量”, 其的内存空间为“栈”中的“main方法栈帧”,存储的是new String的		“内存地址” (new String的内存地址赋给 x)
 */
// new String()对象的内存空间在“堆内存”中，该对象存储的"xyz"对象的“内存地址”
String x = new String("xyz"); //在“字符串”常量池中有“xyz”对象
//每new一次就会在“堆内存”里多一个对象
//此处 new String()对象的内存空间在“堆内存”中，但其的所在内存地址肯定不等于“上一个new的对     象”，该对象存储的"xyz"对象的“内存地址”
String y = new String("xyz");
//但这个两个new String()对象中存放的同一个"xyz"对象的"内存地址"

/**
 对于对象引用类型:“==”比较的是对象的内存地址
 对于基本类型数据,“==”其实比较的是它的值
 */
//false （两者都指向不同的new String()对象，这两个对象内存地址不一样）
System.out.println(x==y);  

//所以: 想要比较两个字符串是否相等，要用.equals()方法
//String重写了.equals()方法，让其判断两个“字符串的值”是否相等
System.out.println(x.equals(y)); //true

上述代码的内存图：

在这里插入图片描述

3.以下程序一共创建了几个对象？

   //以下程序一共创建了几个对象
   String s1 = new String("hello");
   String s2 = new String("hello");

   /**
    * 一共3个对象：
    *字符串常量池中1个“hello”对象。
    *堆内存中有两个String对象
    */

4.String类中常用“构造方法”

String s =“xxx” ：创建字符串对象最常用的方式

/**
   * 创建“字符串对象”最常用的一种方式
*/
String s1 = "hello world!";
/*
 s1保存的是 "hello world!"对象的内存地址,
 按理说以下应输出一个内存地址
 但输出了一个字符串，说明String重写了toString()方法
*/
System.out.println(s1); // helloWorld
System.out.println(s1.toString()); // helloWorld

String( )

   //无参构造方法
   String s = new String();

String(byte [ ] b)

        /**
         *   常用的构造方法
         */
        byte[] bytes = {97, 98, 99};
        String s2 = new String(bytes); //将“字节型数组”转换为“字符串对象”
        /*
           s2保存的是新new的String对象的在“堆内存”中的“内存地址”
           按理说以下应该输出该String对象的内存地址 （因为不重写toString的话，输出的是内存地址）
           但却输出了一个字符串(abc/字符串本身),说明String重写了toString()方法
         */
        System.out.println(s2); //abc

String( byte [ ] b ,int offset ,int length )

String(byte [ ] b ,int offset ,int length) : String(字节数组 ,数组元素下标的开始位置 ,长度)
byte[] bytes = {97, 98, 99,100,101};
String s3 = new String(bytes,2,3);
System.out.println(s3); //cde

String( char [ ]c )

   char [] chars ={'我','是','中','国','人'};
   //将char数组转换为 String字符串
   String s = new String(chars);
   System.out.println(s); //我是中国人

String( char [ ]c ,int offset ,int length )

   char [] chars ={'我','是','中','国','人'};
   //将char数组中“指定范围”的字符转换为字符串
   String s = new String(chars,2,3);
   System.out.println(s); //中国人

5.String类中常用“方法”

char charAt( int index)

  String s = "中国人"; //“中国人”是一个字符串String对象，只要是对象就能调用方法。
  //返回指定索引处的char值
  char c = s.charAt(1);
  System.out.println(c); //国

int compareTo( String s )

int compareTo( String s ) : 按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
（比较“对应位置”上的字符的Unicode值的大小，一个一个的比较，直到分出大小为止）

如果要比较的两个字符相等，返回值为0；

如果前面字符串的Unicode值 > 后字符串的Unicode值，返回值为一个大于0的数。

如果前面字符串的Unicode值 < 后字符串的Unicode值，返回值为一个小于0的数。

前后一致：返回值为0；
前大后小 : 返回值为一个大于0的数；
前小后大：返回值为一个小于0的数；
字符之间之间的比较不能用 > < ，需要使用功能compareTo( )方法

例子如：
  //比较“对应位置”上的字符的Unicode值的大小
        
  //如: 比较a与a:相等; 比较b与b:相等;  比较c与c:相等;  返回值为0
  System.out.println("abc".compareTo("abc"));    // 0

  System.out.println("abcd".compareTo("abce"));  // (前小后大: )一个小于0的值 :-1
  System.out.println("abce".compareTo("abcd"));  // (前大后小: )一个大于0的值 : 1

  System.out.println("abcd".compareTo("abcd"));  // 0

 //如: 比较a与a:相等; 比较b与b:相等;  比较c与c:相等;  d与空白: d大: 前大后小 : 返回值为1
 System.out.println("abcd".compareTo("abc"));     // (前大后小 :)一个大于0的数 : 1
 System.out.println("abcd".compareTo("abcdef"));  // (前小后大 :)一个小于0的值 :-2

boolean contains( CharSequence c )

判断前面的字符串是否包含后面的子字符串。

返回值为boolean类型。

   // 判断前面的字符串是否包含后面的子字符串。
   boolean contains1 = "HelloWorld.java".contains(".java");
   boolean contains2 = "http://www.baidu.com".contains("https://");

   System.out.println(contains1);//true
   System.out.println(contains2);//false

boolean endsWith( String s )

判断“当前字符串”是否以“某个字符串”结尾

返回值为boolean类型。

   //判断“当前字符串”是否以“某个字符串” "结尾"
   System.out.println("test.txt".endsWith(".java")); //false
   System.out.println("test.txt".endsWith(".txt")); //true
   System.out.println("abacaseihsuwksss".endsWith("sss")); //true

boolean startsWith( String s )

判断“当前字符串”是否以“某个字符串” 开始

返回值为boolean类型。

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

boolean equals( Object o )

判断两个字符串是否相等

  //判断两个字符串是否相等
  System.out.println("abc".equals("abc")); //true
  System.out.println("aaa".equals("bbb")); //false

boolean equalsIgnoreCase( String s)

判断两个字符串是否相等，并且同时忽略大小写.

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

byte[ ] getBytes(String s)

将“字符串”转换为“字节数组”

  //将“字符串”转换为“字节数组”
  String s = "Hello,World";
  byte[] bytes = s.getBytes();
  //遍历byte数组
  for (int i = 0; i < bytes.length; i++) {
  System.out.println(bytes[i]);
}

int indexOf( String s )

判断“某个子字符串”在“当前字符串”中 第一次 出现的索引/下标
(为 第一次 出现的字符串中的 第一个字符 的索引/下标)
能找到则返回值为: 该索引，不能找到则返回值为 -1

例子如：
   //判断“某个子字符串”在“当前字符串”中"第一次"出现的索引/下标
   //能找到则返回值为: 该索引，不能找到则返回值为 -1
   System.out.println("oracleJavaC++JavaoraclepythonC++".indexOf("Java")); //6
   System.out.println("123abc123abc".indexOf("123")); // 0
   System.out.println("123abc123abc".indexOf("11111")); //-1

int lastindexOf( String s )

判断“某个子字符串”在“当前字符串”中 最后一次 出现的索引/下标
(为 最后一次 出现的字符串中的 第一个字符 的 索引/下标)
能找到则返回值为: 该索引，不能找到则返回值为 -1

例子如：
  //判断“某个子字符串”在“当前字符串”中"最后一次"出现的索引/下标
  //能找到则返回值为: 该索引，不能找到则返回值为 -1
  System.out.println("JavaC++JavaoraclepythonJava".lastIndexOf("Java")); //23
  System.out.println("123abc123abc".lastIndexOf("123"));  // 6
  System.out.println("123abc123abc".lastIndexOf("11111")); //-1

boolean isEmpty( )

判断某个字符串是否为“空字符串”

   //判断某个字符串是否为“空字符串
   String s1 = "";
   String s2 = "123";
   System.out.println(s1.isEmpty()); //true
   System.out.println(s2.isEmpty()); //false

int length( )

获取字符串的“长度”

  //获取字符串的“长度”
  System.out.println("abc".length()); // 3

面试题：判断“数组长度”和“字符串长度”不一样

判断“数组长度”是length( )属性，判断“字符串长度”是length( )方法

  System.out.println("abc".length()); // .length()方法

  int[] a = {1, 2, 3};
  for (int i = 0; i < a.length; i++) { // .length属性
  System.out.println(a[i]);
}

String replace( CharSequence target, CharSequence replacement )

用”新字符“替换”老字符“,返回一个“新的String字符串”

  //用”新字符“替换”老字符“,返回一个“新的String字符串”
  String newString1 = "http://www.baidu.com".replace("http://", "https://");
  System.out.println(newString1); //https://www.baidu.com
 
  String newString2 = "name=zhangsan&password=123&word=123&age=20".replace("=",   ":");
  System.out.println(newString2); //name:zhangsan&password:123&word:123&age:20

String[ ] split( String s )

根据给定"字符"/“正则表达式”的匹配拆分此字符串。

   //根据给定"字符"/“正则表达式”的匹配拆分此字符串。
   String[] split = "1980-10-11".split("-");
   for (int i = 0; i < split.length; i++) {
   System.out.println(split[i]);
}

String substring( int beginIndex）

截取 “指定索引之后” 的字符，返回值为一个字符串。
  //截取字符串
  System.out.println("http://www.baidu.com".substring(7)); //www.baidu.com

String substring( int beginIndex , int endIndex)

截取 ”开始索引”到“结束索引-1”范围内 的字符，返回值为一个字符串
 //截取”开始索引”到“结束索引-1”范围内的字符，返回值为一个字符串
 System.out.println("http://www.baidu.com".substring(11,16)); //baidu

char[ ] toCharArray( )

将字符串转换为char数组

   //将字符串转换为char数组
   String str = "我是中国人呢";
   char[] chars = str.toCharArray();
   for (int i = 0; i < chars.length; i++) {
   System.out.println(chars[i]);
}

String toUpperCase( )

转换为大写

  //转换为大写
  String str3 = "klaghlig";
  String str4 = str1.toUpperCase();
  System.out.println(str4); //KLAGHLIG

String toLowerCase( )

转换为小写

  //转换为小写
  String str1 = "AFSGGAsgy";
  String str2 = str1.toLowerCase();
  System.out.println(str2); //afsggasgy

String trim( )

去除字符串 “前后” 的“空白"。不能去除字符串中间的空白。

  //去除字符串“前后”的“空白"
  String str1 = "    我是    中国人   ";
  String str2 = str1.trim();
  System.out.println(str2); //我是    中国人

String valueOf(Object o)

将 “非字符串“ 转换为 “字符串”。
valueOf( )方法是String类的静态方法，不需要new对象就能直接调用。

注意：
当将“对象”转换为“字符串”时， valueOf( ) 底层默认调用 Object类的toString( ) 方法，如果该对象重写了toString( )方法，则调用 重写后的toString( ) 方法。

      // 将“非字符串“转换为“字符串”
        boolean b = true;
        int i = 100;
        double d = 3.14;
        char c = '中';
        long l = 2000;

        //以下输出即为"字符串"类型
        System.out.println(String.valueOf(b));// true
        System.out.println(String.valueOf(i));//100
        System.out.println(String.valueOf(d));//3.14
        System.out.println(String.valueOf(b));//中
        System.out.println(String.valueOf(l));//2000

        //将"对象"转换为"字符串
         /*
           将"对象"转换为"字符串时，
           valueOf()方法底层默认调用的Object的toSring()方法 , 因为此处的Customer()方			 法重写了toString()方法，所以此处底层使用重写后的toString()方法。           
         */
        System.out.println(String.valueOf(new Customer())); //Customer类重写了toString方法了!!!!!
    }
}


 class Customer {

     //重写toString()方法
     @Override
     public String toString() {
         return "Customer类重写了toString方法了!!!!!";
     }

一只大皮卡丘

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
Javase | String字符串 - 1

1.字符串 (String) /2.new String对象和不new String对象时内存分析： 2.1 不new String对象时内存分析、2.2 new String对象时内存分析、3.以下程序一共创建了几个对象？、4.String类中常用“构造方法” String( ) String(byte [ ] b) String( byte [ ] b ,int offset ,int
复制链接

扫一扫