java String类

最新推荐文章于 2023-03-02 16:13:14 发布

chinusyan

最新推荐文章于 2023-03-02 16:13:14 发布

阅读量937

点赞数

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/chinus_yan/article/details/121096195

版权

Java 专栏收录该内容

58 篇文章 1 订阅

订阅专栏

学一个类：
这个类是什么？
构造函数有哪些？
成员方法有哪些？

1、String类

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！（所有程序默认导入java.lang）

1.1 String类常用的构造方法

常用的构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(char[] value, int offset, int count)	根据指定字符数组范围的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象。使用平台的默认字符集解码指定的字节数组来构造新的 String
public String(byte[] bytes, int offset, int length)	根据指定字节数组范围的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

/**
 * 构造方法通过new来调用
 * 成员方法:
 *      非静态成员方法:通过对象名来调用
 *      静态成员方法:通过类名来调用
 * 方法:
 *      无返回值:直接调用
 *      有返回值:
 *          直接调用
 *          赋值调用
 *          输出调用
 */
public class Test {
    public static void main(String[] args) {
        /*
            public   String() 创建一个空白字符串对象，不含有任何内容
            public   String(char[] chs) 根据字符数组的内容，来创建字符串对象
            public   String(char[] value, int offset, int count) 根据指定字符数组范围的内容，来创建字符串对象
            public   String(byte[] bys) 根据字节数组的内容，来创建字符串对象
            public   String(byte[] bytes, int offset, int length)根据指定字节数组范围的内容，来创建字符串对象
            String s =   “abc”;直接赋值的方式创建字符串对象，内容就是abc
         */
        // 创建空白字符串对象
        String str1 = new String();// str1字符串内容: ""
        System.out.println("="+str1+"=");// ==

        // 根据字符数组的内容，来创建字符串对象
        char[] chs = {'a','b','c','d'};
        String str2 = new String(chs);// str2字符串内容:"abcd"
        System.out.println(str2);// abcd

        // 根据指定字符数组范围的内容，来创建字符串对象
        String str3 = new String(chs, 0, 3);// str3字符串内容:"abc"
        System.out.println(str3);// abc

        // 根据字节数组的内容，来创建字符串对象
        byte[] bys = {97,98,99,100,101,102};
        String str4 = new String(bys);// str4字符串内容:"abcdef"
        System.out.println(str4);// abcdef

        // 根据指定字节数组范围的内容，来创建字符串对象
        String str5 = new String(bys, 2, 3);// str5字符串内容:"cde"
        System.out.println(str5);// cde

        // 直接赋值的方式创建字符串对象 语法糖
        String str6 = "abc";// str6字符串内容:"abc"
        System.out.println(str6);

    }
}

1.2 创建字符串对象两种方式的区别

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容相同，但是地址值不同

char[] chs = {'a','b','c'};
String s1 = new String(chs);// s1字符串的内容: abc
String s2 = new String(chs);// s2字符串的内容: abc
// 上面的代码中,JVM首先会先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的
// String底层是靠字符数组实现的,jdk9底层是字节数组。

直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

String s3 = "abc";
String s4 = "abc";
// 上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行代码,则让s4直接参考字符串池中String对象,也就是说他们本质上是同一个对象

绘制内存图
在这里插入图片描述

1.3 String类的特点

String类的字符串不可变，它们的值在创建后不能被更改

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd" 
// 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。

虽然 String 的值是不可变的，但是它们可以被共享

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

字符串效果上相当于字符数组( char[] )

//例如： 
String str = "abc";

//相当于： 
char[] data = {'a', 'b', 'c'};     
String str = new String(data);
// String底层是靠字符数组实现的,jdk9底层是字节数组。

byte[] bys = {97,98,99};
String str = new String(bys);

1.4 字符串的比较

==号的比较

比较基本数据类型：比较的是具体的值

int num1 = 10;
int num2 = 20;
num1 == num2  ===> 10==20  结果:false

比较引用数据类型：比较的是对象地址值

String str1 = new String("abc");
String str2 = new String("abc");
str1 == str2 ===> str1存储的对象地址值 == str2存储的对象地址值  结果: false

equals方法的作用

字符串是对象,它比较内容是否相同,是通过一个方法来实现的,就是equals()方法

public boolean equals(Object s)     //比较两个字符串内容是否相同、区分大小写
public boolean equalsIgnoreCase (String anotherString) //将此字符串与指定对象进行比较，忽略大小写。

1.5 String类常用的方法

    - public int length () ：返回此字符串的长度。
    //提取
    - public char charAt (int index) ：返回指定索引处的 char值。 //数组名[索引值]
    - public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) //提取多个字符 
    //拼接
    - public String concat (String str) ：将指定的字符串连接到该字符串的末尾。拼接 // +也可以拼接,但浪费内存空间
    
    //查找子串
    - public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
    - public int indexOf(String str, int fromIndex)  返回从指定索引位置查找,该子字符串第一次出现在该字符串内的索引。
    - public int lastIndexOf(String str) 返回指定子字符串最后一次出现在该字符串内的索引。
    - public int lastIndexOf(String str, int fromIndex) 返回从指定索引位置向前查找,该子字符串最后一次出现在该字符串内的索引。

	//截取子串
    - public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
    - public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。
    //含beginIndex，不含endIndex。
        //判断
    public boolean isEmpty() //判断字符串是否为空(长度为0返回true，不为0返回false) 不是判断null
    public boolean contains(CharSequence s)    //判断字符串中是否包含 给定的字符串。
    public boolean endsWith(String suffix) //判断字符串是否以 给定的字符串 结尾。
		public boolean startsWith(String prefix) //测试此字符串是否以指定的前缀开头。
		public boolean startsWith(String prefix, int toffset) //测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。
		
		//转换
	public String replace(char oldChar, char newChar) //用新内容替代全部旧内容，返回新的字符串
	public String replace(CharSequence target, CharSequence replacement)
	public String replaceAll(String regex, String replacement)
	public String replaceFirst(String regex, String replacement)
	   
        toLowerCase();  //把字母都转成其对应的小写形式。
        toUpperCase();  //把字母都转成其对应的大写形式。
	public char[] toCharArray() // 把字符串转换为字符数组
	public byte[] getBytes() // 把字符串转换为字节数组
	public byte[] getBytes(Charset charset) 
	public byte[] getBytes(String charsetName)
	void getChars(char dst[], int dstBegin)
	public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) 
	
	public String trim()            //移除首尾空格。
	public String[] split(String regex)   //根据给定的内容，切割字符串，返回字符串数组
		                        //.特殊字符串(正则表达式),而在正则表达式中点表示任意字符
	public String[] split(String regex, int limit) //limit参数控制应用模式的次数，因此影响得到的数组的长度。如果限制n大于0，那么模式将至多应用n - 1次，数组的长度将不大于n.并且数组的最后一项将包含最后匹配的分隔符以外的所有输入。
	
		//正则
		public boolean matches(String regex) //将"本对象"与参数"正则表达式"进行匹配，如果本对象符
											//合正则表达式的规则，则返回true，否则返回false
		//生成字符串
		//基本类型(boolean,char,int,long,float,double,)转字符串
		public static String valueOf(int i) //返回int参数的字符串表示形式。
		public static String valueOf(long l)
		
		static String valueOf(char[] data) //返回 char数组参数的字符串表示形式。  
		static String valueOf(char[] data, int offset, int count) //返回 char数组参数的特定子数组的字符串表示形式。  

		static String valueOf(Object obj) //返回 Object参数的字符串表示形式。 

    理解的口诀:
        判断功能：  首尾中空加判断  

        获取功能:   截长取位取元素

        转换功能：   大小拼串转数组
            //toCharArray(), getBytes();
        其他功能：  除空切换字典拍
            //copareTo();

java中 concat()方法 , "+"和append()方法的区别？
concat()方法：String类的concat()方法（只能用于拼接字符串，不能拼接其他类型的数据）将指定的字符串拼接到该字符串的末尾。并且字符串本身和拼接的字符串都不能为null，否则运行程序后会报空指针异常NullPointerException（编译时没有报错）。

“+”：可以对字符，数字，字符串等数据类型的拼接

append()方法：可以对字符，数字，字符串等数据类型的拼接，结果返回一个StringBuffer类型的对象

Java中concat()和+运算符之间的区别

        String str1 = "Hello-World-Hello-It";
        // 把str1字符串转换为字符数组
        char[] arr1 = str1.toCharArray();
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");// H e l l o - W o r l d - H e l l o - I t
        }
        System.out.println();// 换行

        // 把str1字符串转换为字节数组
        byte[] arr2 = str1.getBytes();
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");// 72 101 108 108 111 45 87 111 114 108 100 45 72 101 108 108 111 45 73 116 
        }
        System.out.println();// 换行

        String str3 = "Hello.World.Hello.It";
        // 以.对str3进行分割
        String[] arr3 = str3.split("\\.");// .特殊字符串(正则表达式),而在正则表达式中点表示任意字符
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

遍历字符串

public class Test {
    public static void main(String[] args) {
        // 需求:键盘录入一个字符串，使用程序实现在控制台遍历该字符串
        // 1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String str = sc.next();

        // 2.获取字符串的长度(字符个数)
        int len = str.length();

        // 3.循环遍历
        for (int i = 0; i < len; i++) {
            // 4.在循环中,通过charAt方法字符,打印输出
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}

1.6 Java字符串和数字间的转换

Java字符串和数字间的转换

字符串转数字

通过基本类型对应的包装类则可以实现把字符串转换成基本类型
8个包装类都提供了一个parseXxx(String str)静态方法用于将字符串转换成基本类型。（注意：如果字符串不是数值型字
符串，转换将导致一个运行时错误。）

String s = "123";

byte b = Byte.parseByte(s);
short t = Short.parseShort(s);
int i = Integer.parseInt(s);
long l = Long.parseLong(s);
Float f = Float.parseFloat(s);
Double d = Double.parseDouble(s);
boolean bo = Boolean.parseBoolean(s);
char c = Character.parseCharacter(s);

数字转字符串

//各种数字类型转换成字符串型
public static String valueOf(Object obj)

2、StringBuilder类

字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";// s = s + "World";
        System.out.println(s);// HelloWorld
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

2.1 StringBuilder类概述

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

StringBuilder类和String类的区别

String类：内容是不可变的
StringBuilder类：内容是可变的

一个可变的字符序列。此类提供与StringBuffer的API，但不保证同步（线程不安全）。此类设计用作简易替换为StringBuffer在正在使用由单个线程字符串缓冲区的地方（如通常是这种情况）。在可能的情况下，建议使用这个类别优先于StringBuffer ，因为它在大多数实现中将更快。

2.2 StringBuilder类的构造方法

常用的构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象（把不可变字符串转换为可变字符串）

2.3 添加和反转方法

//附加
public StringBuilder append(任意类型) 拼接数据，并返回对象本身

//插入数据
public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身

//反转
public StringBuilder reverse()  反转字符串,并返回对象本身

//删除
public StringBuilder delete(int start, int end) //删除此序列的子字符串中的字符 start -- end-1 
//如果开始等于结束，则不做任何更改。

public StringBuilder deleteCharAt(int index)

//查找
public int indexOf(String str) //查找子符串第一次出现，没有则返回-1	
public int indexOf(String str, int fromIndex)

public int lastIndexOf(String str)
public int lastIndexOf(String str, int fromIndex)

public class Test {
    public static void main(String[] args) {
        /*
            public StringBuilder append(任意类型) 拼接数据，并返回对象本身
            public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
            public StringBuilder reverse()  反转字符串,并返回对象本身
         */
        // 创建可变字符串对象
        StringBuilder sb1 = new StringBuilder("hello");

        // sb1字符串末尾拼接上"-world"
        StringBuilder sb2 = sb1.append("-world");
        System.out.println(sb1);// hello-world
        System.out.println(sb2);// hello-world
        System.out.println(sb1==sb2);// sb1和sb2的地址值是一样的,true

        System.out.println("=======================================");

        // 把-java插入到sb1可变字符串中,使得sb1为:hello-java-world
        sb1.insert(5,"-java");
        System.out.println(sb1);// hello-java-world

        System.out.println("=======================================");
        // 把sb1中的字符串内容进行反转
        StringBuilder sb3 = sb1.reverse();
        System.out.println(sb1);// dlrow-avaj-olleh
        System.out.println(sb3);// dlrow-avaj-olleh
        System.out.println(sb1==sb3);// true

    }
}

2.4 StringBuilder和String相互转换

String转换为StringBuilder

public StringBuilder(String s)：通过StringBuilder的构造方法就可以实现把 String 转换为 StringBuilder

StringBuilder转换为String

public String toString()：通过StringBuilder类中的 toString() 就可以实现把 StringBuilder 转换为 String

2.5 StringBuilder的常用方法

public StringBuilder delete(int start, int end)

3、ArrayList

3.1 集合

集合其实就是一个大小可变的容器,可以用来存储多个引用数据类型的数据

集合与数组的区别

数组：数组大小固定
集合：集合大小可动态扩展

3.2 ArrayList类

集合类有很多,目前我们先学习一个: ArrayList

通过查看ArrayList类的API:
- java.util.ArrayList <E> ：该类需要 import导入使后使用。
- 表示一种未知的数据类型,叫做泛型,用于约束集合中存储元素的数据类型
- 怎么用呢?
  - 在出现E的地方我们使用引用数据类型替换即可，表示我们将存储哪种引用类型的元素。
  - 例如:
    - ArrayList<String> 表示ArrayList集合中只能存储String类型的对象
    - ArrayList<Student> 表示ArrayList集合中只能存储Student类型的对象
    - …
    - ArrayList<int> 编译报错,因为E这个位置只能写引用数据类型
- 概述:
  - ArrayList类底层是大小可变的数组的实现，存储在内的数据称为元素。也就是说ArrayList 中可以不断添加元素，其大小会自动增长。

3.3 ArrayList类构造方法

ArrayList() 构造一个初始容量为 10 的空列表。

import java.util.ArrayList;

/**
 * @Author：
 * @Date: 
 */
class Student{

}
public class Test {
    public static void main(String[] args) {
        /*
            ArrayList类构造方法:
                    public ArrayList() 构造一个初始容量为 10 的空列表。

                    基本数据类型            对应            包装类类型
                    byte                                    Byte
                    short                                   Short
                    int                                     Integer
                    long                                    Long
                    float                                   Float
                    double                                  Double
                    boolean                                 Boolean
                    char                                    Character
         */
        // 创建ArrayList集合对象,限制集合中元素的类型为String类型
        ArrayList<String> list1 = new ArrayList<String>();
        ArrayList<String> list2 = new ArrayList<>();

        // 创建ArrayList集合对象,限制集合中元素的类型为Student类型
        ArrayList<Student> list3 = new ArrayList<>();

        //  创建ArrayList集合对象,限制集合中元素的类型为int类型
        //ArrayList<int> list4 = new ArrayList<int>();// 编译报错
        //  集合中存储基本数据类型
        // 创建ArrayList集合对象,限制集合中元素的类型为Integer类型
        ArrayList<Integer> list5 = new ArrayList<>();// 存储int类型的数据

        // 创建ArrayList集合对象,不限制集合中元素的类型
        ArrayList list6 = new ArrayList();// 存储任意类型的对象
        
    }
}

3.4 ArrayList类添加元素方法

ArrayList添加元素的方法

public boolean add(E e)：将指定的元素追加到此集合的末尾
public void add(int index,E element)：在此集合中的指定位置插入指定的元素 index为0-size

3.5 集合存储基本数据类型

public class Test {
    public static void main(String[] args) {
        // 创建ArrayList集合对象,限制集合中元素的类型为Integer类型
        ArrayList<Integer> list = new ArrayList<>();

        // 往集合中添加元素
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        System.out.println("list:"+list);// list:[10, 20, 30, 40]

        System.out.println("============================");
        // 基本类型--->包装类
        Integer i = 10;// 自动装箱: 系统会自动把基本类型的数据装箱为包装类类型的对象
        // 包子类---->基本类型
        int num = i;// 自动拆箱: 系统会自动把包装类类型的对象拆箱为对应的基本数据类型
        
        // 思考一:指定索引为4的位置添加一个元素50,是否可以?---可以
        list.add(4,50);// 相当于list.add(50);
        System.out.println("list:"+list);// list:[10, 20, 30, 40, 50]

        // 思考二:指定索引为6的位置添加一个元素100,是否可以?----不可以
        //list.add(6,100);// 运行报异常,IndexOutOfBoundsException索引越界异常

    }
}

3.5 ArrayList类常用方法

public boolean   remove(Object o) 删除指定的元素，返回删除是否成功
public E   remove(int   index) 删除指定索引处的元素，返回被删除的元素
public E   set(int index, E  element) 修改指定索引处的元素，返回被修改的元素
public E   get(int   index) 返回指定索引处的元素
public int   size() 返回集合中的元素的个数

注意事项

public class Test2 {
    public static void main(String[] args) {
        //  public boolean remove(Object o) 删除指定的元素，返回删除是否成功
        //  public E   remove(int   index) 删除指定索引处的元素，返回被删除的元素
        // 1.创建ArrayList集合对象,限制集合中元素的类型为Integer
        ArrayList<Integer> list = new ArrayList<>();

        // 2.往集合中存储int类型的整数
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list);// [1, 2, 3, 4]

        list.remove(1);// 删除索引为1的元素
        System.out.println(list);// [1, 3, 4]

        // 删除1这个元素,需要传入1的Integer对象
        list.remove(new Integer(1));
        System.out.println(list);// [3, 4]
    }
}

4、StringUtils 工具类

StringUtils
org.apache.commons.lang.StringUtils中方法的操作对象是java.lang.String类型的对象，是JDK提供的String类型操作方法的补充，并且是null安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理，例如，如果输入为null则返回也是null等，具体可以查看源代码)。
除了构造器，StringUtils中一共有130多个方法，并且都是static的，
所以我们可以这样调用StringUtils.xxx()。

StringUtils类的常用方法：

   //检查字符串是否为空: ("")或null
1、public static boolean isEmpty(String str)
       StringUtils.isEmpty(null)      = true
       StringUtils.isEmpty("")        = true
       StringUtils.isEmpty(" ")       = false
       
   //检查字符串是否为: 空格、("")或null
2、public static boolean isBlank(String str)
       StringUtils.isBlank(null)      = true
       StringUtils.isBlank("")        = true
       StringUtils.isBlank(" ")       = true
3、

chinusyan

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java String类

1、String类String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！（所有程序默认导入java.lang）String类常用的构造方法常用的构造方法方法名说明public String()创建一个空白字符串对象，不含有任何内容public String(char[]
复制链接

扫一扫