java —— 字符串

已于 2024-06-03 18:05:22 修改
阅读量1k 收藏 17
点赞数 32
分类专栏： java 文章标签： java 开发语言
于 2024-05-31 04:25:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/firstgrass/article/details/139337285
版权

一、.equals() 与 == 的区别

.equals() 表示判断两个字符串的值是否相等；== 表示不仅判断两个字符串的值是否相等，还要判断他们的内存地址是否相同。

public static void main(String[] args)
{
    String a1="123";
    String a2=String.valueOf("123");
    String a3=new String("123");
    String a4=new String("123");

    System.out.println(a1==a2);      //结果为true;
    System.out.println(a1==a3);      //结果为false;
    System.out.println(a3==a4);      //结果为false;

    System.out.println(a1.equals(a2));    //结果为true;
    System.out.println(a1.equals(a3));    //结果为true;
    System.out.println(a2.equals(a4));    //结果为true;
}

采用直接赋值或者 .valueOf() 的办法表示在内存的 String Pool（字符串缓冲区）写入一个 “123” 的字符串，之后不论声明多少对象，只要其值为 “123”，内存地址均相同，也就是这些对象都指向同一个 “123”。

采用 new 方法赋值表示在内存的堆区开辟一个新的地址来存放 “123”，new 一次就开辟一个新的，尽管其值相同，但内存地址却不同。

二、字符串与基本类型的转换

（一）字符串转基本类型

public static void main(String[] args)
{
    String t="true";
	boolean t1=Boolean.valueOf(t);         //方法1
	boolean t2=Boolean.parseBoolean(t);    //方法2

    String m="123";
    int m1=Integer.valueOf(m);             //方法1
    int m2=Integer.parseInt(m);            //方法2
}

（二）基本类型转字符串 

public static void main(String[] args)
{
    boolean a=true;
	String a1=a+"";                    //方法1
	String a2=String.valueOf(a);       //方法2
	String a3=Boolean.toString(a);     //方法3

    int b=123;
	String b1=b+"";                    //方法1
	String b2=String.valueOf(b);       //方法2
	String b3=Integer.toString(b);     //方法3
}

三、字符串与数组之间的转换

 （一）数组转字符串

public static void main(String[] args)
{
    char[] x={'h','e','l','l','o'};

    String x1=Arrays.toString(x);
    System.out.println(x1);         //结果是[h,e,l,l,o]

    String x2=x.toString();         
    System.out.println(x2);         //结果是[C@4517d9a3

    String x3=new String(x);
    System.out.println(x3);         //结果是hello
}

本案例中，使用 Arrays.toString() 生成的是一个方括号字符数组；使用 .toString() 生成的是数组与编码信息；使用 new String() 生成的是由字符元素组成的字符串。 

public static void main(String[] args)
{
    char[] x={78,79,80,81,82};

    String x1=Arrays.toString(x);
    System.out.println(x1);         //结果是[N,O,P,Q,R]

    String x2=x.toString();         
    System.out.println(x2);         //结果是[C@4517d9a3

    String x3=new String(x);
    System.out.println(x3);         //结果是NOPQR
}

本案例中，char[] 数组的元素本应该用单引号限定一个字符的形式，不加单引号的整数在 char[] 数组里面代表 ASCII 码值，显示时会自动转化为对应的字符。

public static void main(String[] args)
	{
		 byte[] x={78,79,80,81,82};

		    String x1=Arrays.toString(x);
		    System.out.println(x1);         //结果是[78, 79, 80, 81, 82]

		    String x2=x.toString();         
		    System.out.println(x2);         //结果是[B@4517d9a3

		    String x3=new String(x);
		    System.out.println(x3);         //结果是NOPQR	
	}

 本案例中，byte[] 数组的元素就是一组二进制数字的十进制表现形式，使用 Arrays.toString() 不会转化为对应的字符；但是使用 new String() 则会按照 ASCII 码值转化为对应的字符。

public static void main(String[] args)
{
    int[] x={78,79,80,81,82};

    String x1=Arrays.toString(x);
    System.out.println(x1);         //结果是[78,79,80,81,82]

    String x2=x.toString();         
    System.out.println(x2);         //结果是[I@4517d9a3
}

本案例中，int[] 数组就不能使用 new String() 的转换方法，因为字符串本质上是由一串字符组成的，字符串可以与字符数组相互转换，却不能与整数数组相互转换。

（二）字符串转数组

public static void main(String[] args)
	{
		String s="hello";
		char[] x=s.toCharArray();
		System.out.println(Arrays.toString(x));   //结果是[h, e, l, l, o]
		
		byte[] y=s.getBytes();
		System.out.println(Arrays.toString(y));   //结果是[104, 101, 108, 108, 111]		
	}

本案例中，.toCharArray() 生成的结果是字符数组；.getBytes() 生成的结果则是组成该字符串的所有字节的 ASCII 码值数组，如果是汉字，则不一定是一个字符对应一个字节。例如：

public static void main(String[] args)
	{
		String s="你好";
		char[] x=s.toCharArray();
		System.out.println(Arrays.toString(x));   //结果是[你, 好]
		
		byte[] y=s.getBytes();
		System.out.println(Arrays.toString(y));   //结果是[-60, -29, -70, -61]		
	}

四、字符与字节数组之间的转换

 字符与字节数组之间不能直接转换，需要借助字符串作为中介。

public static void main(String[] args)
{
//字符转字节数组
    char a='你';
    String x=Character.toString(a);
    byte[] b=x.getBytes();
    System.out.println(Arrays.toString(b));
//字节数组转字符
    byte[] m={-60,-29,-70,-61};
    String y=new String(m);
    char[] n=y.toCharArray();
    System.out.println(Arrays.toString(n));
}

本案例中，字节数组 m 里面的元素组成的显然不止一个字符，所以用字符数组作为最终结果。 

 五、正则表达式

正则表达式由通用字符和元字符两部分构成。通用字符表示匹配的内容，元字符表示匹配规则。

通用字符/元字符
.匹配任意字符
^匹配开头
$匹配结尾
[]匹配方括号内的任意字符
[^]匹配方括号内^后面以外的字符
\w匹配任意字母、数字、下划线
\d匹配数字
\s匹配空格
\W匹配字母、数字、下划线以外的字符
\D匹配数字以外的字符
\S匹配空格以外的字符
[0-9]匹配0-9之间的数字
[a-z]匹配小写英文字母
[A-Z]匹配大写英文字母
[\u4e00-\u9fa5]匹配汉字
{n}前面的表达式连续出现n次
{n,}前面的表达式至少连续出现n次
{n,m}前面的表达式连续出现n到m次
\转义
|或
()分组

例如：

public static void main(String[] args)
{
    String a="I have a pen && ##_64598";
    
    //如果要匹配所有的空格
    String pat1="\\s";

    //如果要匹配所有的大写字母
    String pat2="[A-Z]";

    //如果要匹配所有的数字
    String pat3="\\d";

    //如果要匹配所有的除字母、数字、下划线以外的字符
    String pat4="\\W";

    //如果要匹配&&
    String pat5="&{2}";

    //如果要匹配have或者pen
    String pat6="have|pen";
}

六、Pattern 类与 Matcher 类

在 java 中，pattern 类与 matcher 类紧密相关，主要用于处理与正则表达式相关的操作。

Pattern 类最主要的作用是通过 .compile() 方法将正则表达式编译成 Pattern 对象，而后配合 Matcher 类进行后续的查找、获取、替换等操作。

public static void main(String[] args)
{
    String a="Tom is a cat; Jerry is a mouse; Tom and Jerry are good friends.";
    String pat=";\\s";             //编写正则表达式

    //将表达式编入Pattern对象
    Pattern p=Pattern.compile(pat);     
    //根据已编入表达式的Pattern对象创建要处理的字符串的Matcher对象
    Matcher m=p.matcher(a);       

    //执行匹配
    m.matches();                  //返回布尔值，true则完全匹配
    //执行查找
    m.find();                    //返回布尔值，true则包含该正则表达式表示的内容    
    if(m.find){m.start()}；      //返回表达式匹配到的第一个内容的索引
    if(m.find){m.end()}；        //返回表达式匹配到的最后一个内容的索引
    //获取内容
    if(m.find){m.group()}；      //返回字符串，即表达式匹配到的内容      
    //执行替换 
    m.replaceFirst("%");        //将表达式匹配到的第一个内容替换为%
    m.replaceAll("%");          //将表达式匹配到的所有内容替换为%   
}

上述案例中的 m 通常也可表达为：Pattern.compile(pat).compile(a) 

此外，Pattern 类单独可执行的操作如下：

public static void main(String[] args)
{
    String a="Tom is a cat; Jerry is a mouse; Tom and Jerry are good friends.";
    String pat=";\\s";         //编写正则表达式

    Pattern.matches(pat,a);    //效果与Pattern.compile(pat).matcher(a).matches()相同

    Pattern p=Pattern.compile(pat);
    p.split(a);               //执行分割，返回一个字符串数组
}

七、字符串常用方法

length()获取字符串的长度
equals(Object obj)比较字符串内容是否相等
equalsIgnoreCase(String anotherString)比较字符串内容是否相等，忽略大小写
concat(String str)连接字符串
indexOf(int ch)返回指定字符在字符串中首次出现的索引
indexOf(String str)返回指定子字符串在字符串中首次出现的索引
lastIndexOf(int ch)返回指定字符在字符串中最后一次出现的索引
lastIndexOf(String str)返回指定子字符串在字符串中末次出现的索引
substring(int beginIndex)截取从指定索引开始到结尾的子字符串
substring(int beginIndex, int endIndex)截取指定起始索引到结束索引（不包含）的子字符串
toLowerCase()将字符串转换为小写
toUpperCase()将字符串转换为大写
trim()去除字符串两端的空白字符
replace(char oldChar, char newChar)替换字符串中的字符
replaceAll(String regex, String replacement)根据正则表达式替换字符串
split(String regex)根据正则表达式分割字符串

八、StringBuffer 类与 StringBuilder 类

StringBuffer 与 StringBuilder 用法基本相同，均是对字符串缓冲区进行的操作，速度很快。

常用方法：

① 拼接：.append()

② 插入：.insert()

③ 删除：.delete()

④ 反转：.reverse()

⑤ 转为字符串：.toString()

public static void main(String[] args)
{
    StringBuffer sb=new StringBuffer("hello");
    sb.append(" world").append(" WOW");           //拼接
    sb.insert(0,"Tom:");                          //插入
    sb.reverse();                                 //把字符串反向输出
    sb.delete(3,6);                               //删除索引3至5的内容
    sb.toString();                                //转化为字符串
}

张民遇
关注
  • 32
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值