Java字符串

最新推荐文章于 2024-03-04 09:48:21 发布

尹白

最新推荐文章于 2024-03-04 09:48:21 发布

阅读量218

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_42498502/article/details/100562283

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java字符串

创建String对象的方法

创建一个字符串对象one，名为s1
String s1="one";
创建一个空字符串对象，名为s2
String s2=new String();
创建一个字符串对象one，名为s3
String s3=new String("one");

String的常用方法

方法	说明
int length()	返回当前字符串的长度
int indexOf(int ch)	查找ch字符在该字符串第一次出现的位置
int indexOf(String str)	查找str字符串在该字符串第一次出现的位置
int lastIndexOf(int ch)	查找ch字符在该字符串最后一次出现的位置
int lastIndexOf(String str)	查找str字符串在该字符串最后一次出现的位置
String substring(int beginIndex)	获取从beginIndex位置开始到结束的子字符串
String substring(int beginIndex，int endIndex)	获取从beginIndex位置开始到endInedx位置的子字符串
String trim()	返回去除了前后空格的字符串
boolean equals(Object obj)	将该字符串与指定对象比较，返回true或false
String toLowerCase()	将字符串转换成小写
String toUpperCase()	将字符串转换成大写
char charAt(int index)	获取字符串中指定位置的字符
String[ ] split(String regex,int limit)	将字符串分割为子字符串，返回字符串数组
byte[ ] getBytes()	将该字符串转换为byte数组


    public static void main(String[] args) {


    String str = "JaVA 编程 思想 java";
    //int length()	返回当前字符串的长度
    System.out.println("当前字符串长度: "+str.length());

//int indexOf(String str)	查找str字符串在该字符串第一次出现的位置
        System.out.println("str字符串第一次出现的位置: "+str.indexOf("JAVA 编程 思想"));

//int lastIndexOf(String str)	查找ch字符在该字符串最后一次出现的位置
        System.out.println("str字符串最后一次出现的位置: "+str.lastIndexOf(str));

//int indexOf(int ch)	查找ch字符在该字符串第一次出现的位置
        System.out.println("A字符在该字符串第一次出现的位置: "+str.indexOf('A'));

//int lastIndexOf(int ch)	查找A字符在该字符串最后一次出现的位置
        System.out.println("编程字符在该字符串最后一次出现的位置: "+str.lastIndexOf("编程"));

//String substring(int beginIndex)	获取从beginIndex位置开始到结束的子字符串
        System.out.println("从2开始到结束的字符串: "+str.substring(2));

//String substring(int beginIndex，int endIndex)	获取从beginIndex位置开始到endInedx位置的子字符串
        System.out.println("从2到5的字符: "+str.substring(2,5));//5以前的，不包含5

//String trim()	返回去除了前后空格的字符串
        System.out.println("去除了前后空格的字符串: "+str.trim());

//boolean equals(Object obj)	将该字符串与指定对象比较，返回true或false
        System.out.println("将str字符串与指定字符串比较: "+str.equals("JAVA 编程 思想"));

//String toLowerCase()	将字符串转换成小写
        System.out.println("大写转小写: "+str.toLowerCase());

//String toUpperCase()	将字符串转换成大写
        System.out.println("转换大写: "+str.toUpperCase());

//char charAt(int index)	获取字符串中指定位置的字符
        System.out.println("获取2位置的字符: "+str.charAt(2));

//String[ ] split(String regex,int limit)	将字符串分割为子字符串，返回字符串数组
      //  System.out.println("分割： "+str.split());

//byte[ ] getBytes()	将该字符串转换为byte数组
        byte[] arrs = str.getBytes();
        System.out.print("转换成数组: ");
        for (int i = 0;i<arrs.length;i++){
            System.out.print(arrs[i]+"  ");
        }
        System.out.println();
//将byte数组转换成字符串
        String str1 = new String(arrs);
        System.out.println("将byte数组转换成字符串"+str1);

        // JaVA 编程 思想 java
        System.out.println("从字符串index值为3往后开始找“A”出现的位置"+str.indexOf('A',3));
        //从字符串index值为3往后开始找'A'出现的位置，包含当前位置
        //如果该字符在fromIndex之前未出现，则返回-1
        System.out.println("前14中，a最后一次出现的位置"+str.lastIndexOf('a',14));

    /* lastIndexOf(int ch, int fromIndex)
        返回指定字符在此字符串中最后一次出现处的索引，只搜索指定的索引之前位置。

        lastIndexOf(String str, int fromIndex)
        返回指定子字符串在此字符串中最后一次出现处的索引，只搜索指定的索引之前位置。
  */
    }
}

输出结果

当前字符串长度: 15
str字符串第一次出现的位置: -1
str字符串最后一次出现的位置: 0
A字符在该字符串第一次出现的位置: 3
编程字符在该字符串最后一次出现的位置: 5
从2开始到结束的字符串: VA 编程 思想 java
从2到5的字符: VA 
去除了前后空格的字符串: JaVA 编程 思想 java
将str字符串与指定字符串比较: false
大写转小写: java 编程 思想 java
转换大写: JAVA 编程 思想 JAVA
获取2位置的字符: V
转换成数组: 74  97  86  65  32  -25  -68  -106  -25  -88  -117  32  -26  -128  -99  -26  -125  -77  32  106  97  118  97  
将byte数组转换成字符串: JaVA 编程 思想 java
从字符串index值为3往后开始找“A”出现的位置: 3
前14中，a最后一次出现的位置: 14

Process finished with exit code 0

==和equals的区别

 public static void main(String[] args) {
        String str1 = "java";
        String str2 = "java";
        String str3 =  new String("java");
        System.out.println("str1和str2的内容相同吗"+str1.equals(str2));
        System.out.println("str1和str3的内容相同吗"+str1.equals(str3));
        System.out.println("str1和str2的地址相同吗"+str1==str2);
        System.out.println("str1和str3的地址相同吗"+str1==str3);

    }

运行结果


str1和str2的内容相同吗true
str1和str3的内容相同吗true
str1和str2的地址相同吗true
str1和str3的地址相同吗false

Process finished with exit code 0

在栈存放str1和str2引用,常量池存放字符串，堆存放new的对象
String str1 = “java”;
栈中的str1会指向常量池中的java
String str2 = “java”;
常量池已经存在了java，str2的引用会直接指向已经存在的java,所以str1和str2的地址相同。
String str3 = new String(“java”);
栈中会生成str3，new String(“java”)会放到堆中
String str4 = new String(“java”);
栈中会生成str4，并指向堆中新的new String(“java”)
在这里插入图片描述
一、关于==和equals方法

Java中判断变量相等一般使用==运算符和equals方法。

其中，关于“= = ” ，当我们使用= =来比较基本数据类型时，比较的是其值，只要他们的值相同，= =就可以返回true。当用==比较引用类型时，比较的是的地址，二者是否引用同一个堆内存空间，如果是，则返回true。即便二引用变量引用的堆内存中的内容完全相同，只要是不同的两个堆内存，也只会返回false。

而equals是Object中的方法，用来比较留个对象是否相等，程序员可以通过覆写该方法，定义自己的对象比较规则。String类已经覆写了该方法，用于比较字符串序列内容是否相等。

如果我们自定义了某个类，且此类需要进行对像是否相同的比较，那我们需要覆写equals方法，定义自己的比较规则，而不能直接调用Object的equals方法。

二、 ==比较运算符

==比较的是两个基本数据类型的值是否相等，或者两个对象的引用地址是否一样。

如下代码：

public static void main(String args[]) {
        int a = 1000, b = 1000;
        System.out.println(a == b);
 
        Integer c = 1000, d = 1000;
        System.out.println(c == d);
 
        Integer e = 100, f = 100;
        System.out.println(e == f);
    }

运行的结果为：

true   false   true

原因：

（1）a和b都是基本数据类型，值也相等，所以 a==b 为true

（2）Integer c = 1000 是将一个基本数据类型的值赋给对象的引用。这里涉及到了装箱的概念，

就是把把基本类型用它们相应的引用类型包装起来，使其具有对象的性质。

编译器用的是public static Integer valueOf(int i)方法。

来看下它的源码：

  public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }

当i的值在[-128,127]之间时，返回的是IntegerCache缓存的对象的已用，否则返回的是新的对象的引用。
因此，c 和 d 是两个不同的对象， e 和 f 是两个相同的对象。
通过调试也可以看到他们的id值也说明了这一点。

所以，c= =d 为 false ，e= =f 为 true。

三、 equals运算符

equals比较的是两个对象是否相等。由于每个类都是使用Object作为超类的，所以所有对象（包括数组）也实现这个类方法。

对于Object类的equals方法源代码如下：

public boolean equals(Object obj) {
return (this == obj);
}
可以看到它调用的就是 == 比较运算符。因此下面的代码结果就很容易看出为false了。

覆写equals判断对象是否相同需要注意以下几点：

equals的参数类型应该为Object，Object可以接收一切类型的对象;
接受之可以先通过==进行判断，看二对象应用的地址是否相同，相同则直接返回true;

3.在以上不成立的情况下进行进一步判断。通过instanceof判断此对象是否是此类的实例。同一个类的实例才可以进行比较，不同类的实例自然不会相同。

4.最后对两对象的每个属性的值进行比较，相同则两对象相同，不同则两对象不同。

现按以上思路覆写equals方法，代码如下：

class Person
{
	private String name;
	private String idStr;
	public Person(){}
	public Person(String name , String idStr)
	{
		this.name = name;
		this.idStr = idStr;
	}
	//此处省略name和idStr的setter和getter方法。
	//name属性的setter和getter方法
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
 
	//idStr属性的setter和getter方法
	public void setIdStr(String idStr)
	{
		this.idStr = idStr;
	}
	public String getIdStr()
	{
		return this.idStr;
	}
	//重写equals方法，提供自定义的相等标准
	public boolean equals(Object obj)
	{
		// 如果两个对象为同一个对象
		if (this == obj)
			return true;
		//只有当obj是Person对象
		if (obj != null && obj.getClass() == Person.class)
		{
			Person personObj = (Person)obj;
			//并且当前对象的idStr与obj对象的idStr相等才可判断两个对象相等
			if (this.getIdStr().equals(personObj.getIdStr()))
			{
				return true;
			}
		}
		return false;
	}
}
public class OverrideEqualsRight
{
	public static void main(String[] args) 
	{
		Person p1 = new Person("孙悟空" , "12343433433");
		Person p2 = new Person("孙行者" , "12343433433");
		Person p3 = new Person("孙悟饭" , "99933433");
		//p1和p2的idStr相等，所以输出true
		System.out.println("p1和p2是否相等？" 
			+ p1.equals(p2));
		//p2和p3的idStr不相等，所以输出false
		System.out.println("p2和p3是否相等？"
			+ p2.equals(p3));
	}
}

程序输出：

p1和p2是否相等？true
p2和p3是否相等？false

Process finished with exit code 0

总结：

1. ==通常用于判断基本类型数据是否相等； 等它用于比较引用类型数据时，表示比较的引用变量所指向的堆内存空间是一致的。

2. equals方法是Object中的，用于比较两个对象是否相等； 程序员可以通过覆写该方法，定义自己的对象比较规则。

字符串的不可变性
String对象一旦被创建，则不能修改，是不可变的。
修改其实就是创建新的对象，所指的内存空间不变。

   public static void main(String[] args) {
        //字符串的不可变性
        //String对象一旦被创建，则不能修改，是不可变的。
        //修改其实就是创建新的对象，所指的内存空间不变。
        String s1 = "java";
        String s2 = "hello"+s1;
        //s1不再指向java所在的内存空间，而是指向了"hello java"
        System.out.println("s1="+s1);
        System.out.println("s2="+s2);
        String s3 = new String("hello,java");
        System.out.println("子串"+s3.substring(0,5));
        System.out.println("s3="+s3);
    }

s1=java
s2=hellojava
子串hello
s3=hello,java

Process finished with exit code 0

在这里插入图片描述

StringBuilder
String和StringBuilder的区别： String具有不可变性，而StringBuilder不具备。
建议：当频繁操作字符串时，使用StringBuilder。

StringBuilder和StringBuffer
二者基本相似
StringBuffer是线程安全的，StringBuilder则没有，所以性能略高
在执行速度方面的比较：StringBuilder > StringBuffer

方法	说明
StringBuilder append(参数)	追加内容到当前StringBuilder对象的末尾
StringBuilder insert(位置，参数)	将内容插入到StringBuilder对象的指定位置
String toString()	将StringBuilder对象转换为String对象
int length()	获取字符串的长度

    public static void main(String[] args) {
        //定义一个字符串"你好"
        StringBuilder str = new StringBuilder("你好");
        //在“你好”后面添加“，imooc"
        str.append(",");
        str.append("imooc!");
        System.out.println("str="+str);
        //System.out.println("str="+str.append(',').append("imooc!"));

        //将字符串变成"你好，iMOOC"
        //两种方式：
        //1.使用delete删除mooc,然后插入iMOOC
       // System.out.println("替换后： "+str.delete(4,8).insert(4,"MOOC"));
        //2.使用replace方法直接替换
        System.out.println("替换后： "+str.replace(4,8,"MOOC"));

        //在字符串“你好。IMOOC”中取出“你好”，输出
        System.out.println(str.substring(0,2));
    }

str=你好,imooc!
替换后： 你好,iMOOC!
你好

Process finished with exit code 0

StringBuilder str = new StringBuilder(“你好”);
在这里插入图片描述
str.append(",");

str.append(“imooc”);

尹白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java字符串

Java字符串创建String对象的方法创建一个字符串对象one，名为s1String s1="one";创建一个空字符串对象，名为s2String s2=new String();创建一个字符串对象one，名为s3String s3=new String("one");String的常用方法方法说明int length()返回当前字符串的...
复制链接

扫一扫