Java中 char 类型只能表示单个字符，不能表示由多个字符连接而成的字符串。Java在语言中，字符串需要作为对象来处理，可以通过 java.lang 包中的 String 创建字符对象的类别。
1. 声明字符串
在Java语言中字符串必须包含在一对双引号（" "）内部。

“23.23” " ABCDE" “你好”

字符串变量可以通过以下语法格式声明：

String str;

其中 String 指的是该变量为字符串类型，而 str 代表字符串变量的名称。
2. 创建字符串
创建对象应采用类结构方法。String 常用的结构方法如下：

• ① String(char a[ ])
  用一个数组 a 创建 String 对象。
• ② String(char a[ ], int offset, int length)
  提取字符数组 a 其中一部分创建了字符串对象。 offset 表示开始截取字符串的位置，length 表示截取字符串的长度。
• ③ String(char [ ] value)
  这种结构方法可以分配新的 String 对象表示字符串数组参数中所有元素连接的结果。
  除上述使用外 String 类的构造方法来创建字符串变量外，还可以通过字符串常量的引用赋值给一个字符串变量。

1. 连接多个字符串
使用 “ ” 运算可以实现连接多个字符串的功能。“ ” 操作符可以连接多个操作符并产生一个 String 对象。

package Chapter5; import java.util.Date; public class Join { 
          public static void main(String[] args) { 
          String s1= new String("hello"); //new String("XXX")创建字符串  String s2= new String("world");  String s=s1 " " s2;//利用 可以连接不同的字符串  System.out.println(s);  } } 

1. 获取字符串长度
使用 length( ) 的方法可以获得字符串长度。

str.length( );

2. 字符串查找
String 类提供了两种字符串查找的方法，即 indexOf( ) 方法和 lastIndexOf( ) 方法。这两种方法都允许字符串中搜索指定条件的字符或字符串。indexOf( ) 方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf( ) 方法返回的是搜索字符或字符串最后一次出现的位置。

public class Join { 
        
	public static void main(String[] args) { 
        	
	        String str="We are students ";	
	        int size=str.lastIndexOf("");
			System.out.println("字符串的长度为："+str.length());
			System.out.println("去除空格后的字符串长为："+str.trim().length());
			System.out.println("空字符在字符串中的位置是："+size);
			System.out.println("字符串str中索引位置是5的字为："+str.charAt(5));
	}
}

3. 获取指定索引位置的字符
使用 charAt( ) 方法可以将指定索引位置的字符返回。语法为：

str.charAt(int index)

其中 index 为指定索引的位置。代码在上述已经给出。

1. 获取子字符串
通过 String 类的 substring( ) 方法可对字符串进行截取。这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串的下标是从0开始的。
substring( ) 方法被两种不同的方法重载，来满足不同的需要。

• ① substring(int beginIndex)
• ② substring(int beginIndex, int endIndex)

public class Join { 
        
	public static void main(String[] args) { 
        	
	        String str="We are students ";					
			String substr=str.substring(2, 5);
			System.out.println("截取后的字符段为："+substr);
	}
}

2. 去除空格
trim( ) 方法返回字符串的副本，忽略前导空格和尾部空格。具体用法和代码前述已经给出。

	System.out.println("去除空格后的字符串长为："+str.trim().length());

3. 字符串替换
replace( ) 方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：

str. replace(char oldChar, cahr newChar)

replace( ) 方法返回的结果是一个新的字符串。如果字符串 oldChar 没有出现在该对象表达式中的字字符串序列中，则将原字符串返回。
4. 判断字符串的开始与结尾
startsWith( ) 方法与 endsWith( ) 方法分别用于判断字符串是否以指定的内容开始或结束。这个两个方法的返回值都是 boolean 类型。

• ① startsWith( ) 方法
  该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：

str.startsWith(String prefix)

其中，prefix 是指作为前缀的字符。

• ② endsWith( ) 方法
  该方法用于判断当前字符串是否为以给定的子字符串结束。语法如下：

str.endsWith(String suffix)

其中，suffix 是指作为后缀的字符串。

public class Join { 
        
	public static void main(String[] args) { 
        	
	        String str="We are students ";						
			System.out.println("更换后的字符串为："+str.replace("a", "A"));
			boolean b1=str.startsWith("W");
			boolean b2=str.endsWith("S");
			System.out.println("字符串是以W开头的吗："+b1);
			System.out.println("字符串是以S开头的吗："+b2);
	}
}

5. 判断字符串是否相等
对字符串对象进行比较不能简单地使用比较运算符 “==” ，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回 false。
因此，要比较两个字符串内容是否相等，应使用 equals( ) 方法和 equalsIgnoreCase( ) 方法。

• ① equals( ) 方法
  如果两个字符串具有相同的字符和长度，则使用 equals( ) 方法进行比较时，返回 true。
  语法如下：

str.equals(String otherstr)

其中，str、otherstr 是要比较的两个字符串对象。

• ② equalsIgnoreCase( ) 方法
  使用 equals( ) 方法对字符串进行比较时是区分大小写的，而使用 equalsIgnoreCase( ) 方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为 boolean 类型。语法如下：

str.equalsIgnoreCase(String otherstr)

其中，str、otherstr 是要比较的两个字符串对象。

public class Join { 
        
	public static void main(String[] args) { 
        
			String str="We are students ";
			String str1="WE ARE STUDENTS";
			boolean b3=str.equals(str);//区分大小写
			boolean b4=str.equalsIgnoreCase(str1);//不区分大小写
			System.out.println("字符串str和str1是否相等："+(b3));
			System.out.println("字符串str和str1是否相等："+(b4));
	}
}

6. 按字典顺序比较两个字符串
compareTo( ) 方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的 Unicode 值，按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较，如果按照字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数；如果按照字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下：

str.compareTo(String otherstr)

	System.out.println("a "+ "compareTo"+ " b"+":"+a.compareTo(b));

其中，str、otherstr 为两个要比较的对象。
compareTo( ) 方法只有在 equals(Object) 方法返回 true 时才返回0。
7. 字母大小写替换
字符串的 toLowerCase( ) 方法可将字符串中的所有字符从大写字符改为小写字母，而 toUpperCase( ) 方法可将字符串中的小写字符改为大写字符。

• ① toLowerCase( ) 方法
  该方法将 String 转换为小写。如果字符串中没有应该被转换的字符，则将原字符返回；否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都转换为等价的小写字符。字符长度与原字符长度相同。语法如下：

str.toLowerCase( )

• ② toUpperCase( ) 方法
  该方法将 String 转换为大写。如果字符串中没有应该被转换的字符，则将原字符返回；否则将返回一个新的字符串，将原字符串中每个该进行大写转换的字符都转换为等价的大写字符。字符长度与原字符长度相同。语法如下：

str.toUpperCase( )

其中 str 为待转换的字符串。

public class UpAndLower{ 
        
    public static void main(String args[]){ 
        
        String str=new String("abc DEF");
        String newstr1=str.toLowerCase();
        String.newstr2=str.toUpperCase();
        System.out.println(newstr1);
        System.out.println(newstr2);
    }
}

8. 字符串分割
使用 split( ) 方法可以使字符串按指定的分割字符或者字符串对内容进行分割，并将分割后的结果存放在字符串数组中。 split( ) 方法提供了以下两种字符串分割形式。

str.split(String sign)
str.split(String sign, int limit)

其中 sign 为分割字符的分割符，也可以使用正则表达式。而 limit 为模式匹配次数，如果设置的值为 n，那么将根据正则表达式匹配 n-1 次，得到的结果数组的长度不会大于 n，数组的最后一项是最后匹配的分割符以后的全部内容。

String 类的静态 format( ) 法用于创建格式化的字行申。forma( ) 方法有两种重载形式。
(1) format(String format, Object…args)
该方法使用指定的格式宇符串和参数返回一个格式化字行串，格式化后的新字符串使用本地默认的语言环境。如法如下：

str.format(String format, Object…args)

(2) format(Local 1, String format, Object…args)

• 1：格式化过程中要应用的语言环境。如果1为 null，则不进行本地化。

1. 日期和时间字符串格式化

1. 日期格式化
   首先来看返回一个月中的天数，实例代码如下：

Date date=new Date();
String s= String.format("%te",date);

常用的日期格式化转换符为：
%te: 一个月中的某一天（1~31），如 2；
%tb: 指定语言环境的月份简称，如 Feb（英文），二月（中文）；
%tB: 指定语言环境的月份全称；
%tA: 指定语言环境的星期几全称；
%ta: 指定语言环境的星期几简称；
%tc: 包含全部日期和时间信息；
%tY: 4位年份，如 2008；
%tj: 一年中的第几天，如 085；
%tm: 月份，如 04；
%td: 一个月中的第几天，如 025；
%ty: 2位年份，

import java.util.Date;
public class Eval{ 
        
    public static void main(String args[]){ 
        
        Date date=new Date();
        String year=String.format("%tY",date);
        String month=String.format("%tB",date);
        String day=String.format("%td",date);
        System.out.println("今年是："+year+"年");
        Syetem.out.println("现在是："+month+"月")；
        Syetem.out.println("今天是："+day+"号")；
    }
}

2. 时间格式化
   时间格式化的转换符主要如下所示：
   

3. 格式化常见的日期和时间组合
   常见的格式如下：
   %tF: "年-月-日"格式（4位年份），如2022-06-02；
   %tD: "月/日/年"格式（2位年份），如06/02/22；
   %te: 全部日期和时间信息；
   %tr: "时:分:秒 PM(AM)"格式（12时制），如03:22:06 下午；
   %tT: "时:分:秒"格式（24时制），如15:23:50；
   %tR: "时:分"格式（24时制），如15:23。

2. 常规类型格式化
常规类型的格式化可应用于任何参数类型。
%tb、%tB：结果被格式化为布尔类型；
%th、%tH：结果被格式化为散列码；
%ts、%tS：结果被格式化为字符串类型；
%tc、%tC：结果被格式化为字符类型；
%d：结果被格式化为十进制类型；
%o：结果被格式化为八进制类型；
%x、%X：结果被格式化为十六进制类型；
%e：结果被格式化为科学计数表示的十进制数；
%a：结果被格式化为带有效位数和指数的十六进制浮点数；
%n：结果为特定于平台的行分割符；
%%：结果为字面值%。

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一个格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。正则表达式中元字符及意义如下：

在正则表达式中可以使用括号括起若干字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。
在正则表达式中允许使用限定修饰符来限定元字符出现的次数。常见的限定修饰符如下表所示：

• 字符串生成器 StringBuilder

数组是具有相同类型的一组数据的集合。在Java中将数组看作为一个对象。

一维数组实质上是一组相同类型数据的线性集合。
数组作为对象允许使用new关键字进行内存分配。在使用数组前，需要先定义数组变量所属的类型。

• 1. 创建一维数组

• 方法1：先声明，再用new运算符进行内存分配

数组元素类型 数组名字[ ];
数组元素类型[ ] 数组名字;

int arr[];
String str[];

然后再为数组分配内存空间：

数组名字 = new 数组元素的类型[数组元素的个数]；

int arr=new int[5];

• 方法2：声明的同时为数组分配内存

int month= new int[12];

• 2. 初始化一维数组
  数组的初始化可分别初始化数组中的每个元素。

int arr1=new int[]{ 
        1,2,3,4,5};
int arr2={ 
        1,2,3,4,6};

• 3. 使用一维数组

public class shuzu { 
        
	public static void main(String[] args) { 
        
		int Day[]=new int[] { 
        31,28,31,30,31,30,31,31,30,31,30,31};
		for(int j=0;j<12;j++) { 
        
			System.out.println((j+1)+"月有"+Day[j]+"天");
			}
	}
}

• 1. 创建二维数组
  先声明，再弄new运算符进行内存分配。

//直接位每一维分配内存空间
a=new int[2][4];
//分别为每一位分配内存空间
a=new int[2][];
a[0]=new int[2];
a[1]=new int[3];

• 2. 初始化二维数组

type arrayname[][]={value 1,value 2,…,value n}

• 3. 使用二维数组

public class shuzu { 
        
public static void main(String[] args) { 
        
		int a[][]=new int[3][4];//二维数组
		for(int i=0;i<a.length;i++) { 
        
			for(int j=0;j<a[i].length;j++) { 
        
				System.out.print(a[i][j]);
			}
			System.out.println();
			}
	}
}

• 1. 遍历数组
  数组遍历就是获取数组中的每个元素。通常遍历数组都是用for循环来实现。遍历二维数组需要使用双层for循环，通过数组的 length 属性可获得数组的长度。

public class shuzu { 
        
public static void main(String[] args) { 
        
		int a[][]=new int[3][4];//二维数组
		for(int i=0;i<a.length;i++) { 
        
			for(int j=0;j<a[i].length;j++) { 
        
				System.out.print(a[i][j]);
			}
			System.out.println();
			}
	}
}

在遍历数组时，使用 foreach 语句会更简单。

public class Tautog{ 
                                        //创建类
    public static void main(String[] args){ 
                 //主方法
        int arr2[][]={ 
        { 
        4,3},{ 
        1,2}};                 //定义二维数组
        System.out.println("数组中的元素是：");      //提示信息
        int k=0;                                    //外层循环计数器变量
		for(int x[]:arr2) { 
                                 //外层循环变量为一维数组
			k++;                                    //外层循环计数器递增
			int j=0;                                //内层循环计数器
			for(int e:x) { 
                                  //循环遍历每一个数组元素
				j++;                                //内存计数器递增
				if(k==arr2.length&&j==x.length) { 
           //判断变量是二维数组中的最后一个元素
					System.out.println(e);          //输出二维数组的最后一个元素
				}
				else                                //如果不是二维数组中的最后一个元素
					System.out.print(e+"、");       //输出信息
			}
		}
	}
}

• 2. 填充替换数组元素
  数组中的元素定义完成后，可通过Arrays类的静态方法 fill( ) 来对数组中的元素进行替换。该方法通过各种重载的形式可完成对任意类型的数组元素的替换。

• fill(int[ ] a, int value)
  该方法可以将指定的 int 值分配给 int 型数组的每个元素。其中：
  ① a： 表示要进行元素替换的数组。
  ② value： 要存储数组中所有原色的值。