java基础知识

文章目录

java基础知识
五、字符串

五、字符串

5.1.字符串简介

概念
- 日常生活所见的均是字符串
- 例如
表示
- 字符：char
  - char ch1='A ’
  - char ch2=‘Java’，这是一个错误表示，单引号用于字符，双引号用于字符串
- 字符串：String
  - String str1=“fuvfuerfv&”;
  - “1+2”输出结果不可能是3，因为前面的是字符串，结果就是字符串1+2
String类
- 声明字符串：声明一个字符串就是创建一个字符串对象，而String是一个类，所以其声明的就是一个对象
- String a,b,c;
- 只进行了声明，未进行赋值操作，其值使用默认的，即等于String a=null;
- 未进行赋值故不可以用于任何操作，声明的字符串变量必须初始化后才能使用，否则报错
- 换行使用加号连接，尽量一行写完
  - 错误
    System.out.println("i like
    
    java");
  - 正确
    System.out.println(“i ;ike”+
    “java”);

只要使用+连接的操作数中，有一个是字符串，就会自动将其他数据类型全部转换为字符型，同时注意运算优先级顺序

package java第五章_字符串;

public class t1_String字符串创建a {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int yanyu=5+2+0;
		String a="时间就是金钱，我的朋友";
		System.out.println(a);
		String b="你好，",c="java.";
		System.out.println(b+c);
		String str1,str2;
		str1="we are students.";
		str2="he is a dog!";
		System.out.println(str1+str2);
		System.out.println(a+yanyu+1);
		/*只要+这个运算符有一个操作数是字符串，编译器就会自动将其它操作数
		转换为字符串字符串与其它类型相连，自动调用toString()
		结果不是"时间就是金钱，我的朋友8"
		 分析：
		 	a是一个字符串，用加号与其它类型相连，会自动调用
		 	toString()方法将其它类型转换为字符串型，故在
		 	System.out.println(a+yanyu+1);中，yanyu被自动
		 	转换为字符串7，所以yanyu+1不会=8,而是71
		 			*/
//字符串定义，注意使用英文输入法双引号！
	    System.out.println(a+(yanyu+1));
	    System.out.println(a+(yanyu+1)+1);
	    //()优先级最高（yanyu+1）的结果=8,字符串a+8，最终转换为字符串81
	    System.out.println(a+(yanyu+1));
	    //（yanyu+1）的结果=8,最终转换为字符串8


	}

}

5.2.字符串赋值方法

引用字符串常量

package java第五章;

public class t1_String字符串创建a {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="时间就是金钱，我的朋友";
		System.out.println(a);
		String b="分手了，",c="就不能再做朋友。";
		System.out.println(b+c);
		String str1,str2;
		str1="we are students.";
		str2="he is a dog!";
		System.out.println(str1+str2);
//字符串定义，注意使用英文输入法双引号！
	}

}

利用构造方法直接实例化
- 使用new方法
- String a=new String(“yanyu”);
  
  真正起作用的是new String("yanyu");才是创建的对象，而a只是一个合法字符去接受对象，便于后续操作

package java第五章_字符串;

public class t2_String字符串创建b {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a=new String("我爱善于沟通的女孩子。");
		System.out.println(a);//输出字符串a
		String b=new String("我讨厌沉默的女孩子。");
		String c=new String(b);//将字符串b的值传递给c
		System.out.println(c);
	}

}

利用字符数组实例化

package java第五章_字符串;

public class t3_String字符串c {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		char[]arr= {'t','i','m','e'};//利用字符数组实例化，创建一个字符型的数组
		String a= new String(arr);//利用构造方法直接实例化    两种方法的综合使用
		System.out.println(a);
	}

}

切片法：从原有的字符串里截取一段出来，作为新的字符串

逗号隔开，从哪个位置开始取，取几个，注意数组起始是0

package java第五章_字符串;

public class t4_String字符串创建d {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		char[]arr={'我','是','一','个','学','生','。'};
                           0   1    2   3   4   5    6
		String a=new String(arr,2,5);//从数组的第二个开始，取几个，取五个
		System.out.println(a);
	}

}

利用字节数组实例化
对应“字符编码序列”

package java第五章_字符串;

public class t5_String字符串创建e {
	public static void main(String[]args) {
		byte[]arr= {-60,-6,-70,-61};//”您好“这个字符串对应的“字符编码序列”
		String a=new String(arr);
		System.out.println(a);
	}

}

注意：字符串赋值方法，掌握引用字符串常量和利用new构造方法即可，后面两种知道有这么回事基本就可以了

5.3.连接字符串

格式

package java第五章_字符串;

public class t6_String连接字符串 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="123"+"456";
        //不是579，不是数学，而是字符串连接
		System.out.println(a);
		String b="数字";
		System.out.println(b);
		 b+=a;
        //等价于b+a（b连接a）后赋值给b，   数字123456
		 System.out.println(b);


	}

}

5.4.获取字符串长度

背景

使用str.lastIndexOf();,效果与 lenght(); 一致

package java第五章_字符串;

public class t7_String统计字符串长度 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="我真的爱你";
        //定义了一个长度为“5”的字符串
		int b=a.length();
        //b是接受字符串长度的变量，使用格式
		System.out.println("a这个字符串的长度为："+b);
		String c="我 真的 爱你";
        //注意这里的两个空格算作两个字符，故长度=7
		long d=c.length();
		System.out.println("c这个字符串的长度为："+d);
		

	}

}

5.5.字符串查找

背景：找出B888

格式：

str.indexOf(“对象”)
原理：利用后面的索引位置
索引位置：字符串数组里的知识，索引是从0开始的整数，进行编号，因此，对于字符串而言，存在某个字符，那使用.indexOf()返回来的一定是>=0的整数，若不存在，则返回-1

package java第五章_字符串;

public class t8_String字符串查找 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String str1="8888";
		String str2="B888";
		String str3="88B8";
		if(str1.indexOf("B")>=-1) {
 //8888中没有B，返回值=-1，自然也就符合>=-1的if条件
			System.out.println(str1+"不包含字母B");
			int c=str1.indexOf('B');
  /*定义一个int的变量来接受输出字母B在字符串中的位置，字符串根本没有-1这个位置，说明压根就没有字母B*/
			System.out.println(c);
		}
		if(str2.indexOf("B")>-1) {
 //B888中,有B，返回值等于0或者大于0的数，自然也就符合>-1的if条件
			System.out.println(str2+"包含字母B");
			int a=str2.indexOf('B');
 //字母B 位于数组的第一个位置[0]
			System.out.println(a);
		}
		
		if(str3.indexOf("B")>-1) {
			System.out.println(str3+"包含字母B");
			int b=str3.indexOf('B');
     //字母3 位于数组的第一个位置[2]
			System.out.println(b);
		}
		//System.out.println(b);

	}

}

5.6.获取指定索引的字符

package java第五章_字符串;

public class t10_String获取指定索引位置字符 {
	public static void main(String[]args) {
		String a="我真的爱你。";
//                0 123 4
		char b=a.charAt(3);
        //字符串对象.charAt(指定的索引位置);
		char c=a.charAt(4);
		System.out.println("a字符串中第四个字符是："+b);
		System.out.println("a字符串中第五个字符是："+c);
	}

}

package java第五章_字符串;

public class t11_String获取子字符串索引位置 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String str1="we are the world";
		String str2="let it go!let it go!";
		int a=str1.indexOf("e");
        //从前往后第一个字母e的位置（1）
		System.out.println("a:"+a);
		int b=str1.indexOf("e", 2);
        //从指定的2位置开始往后，第一个字母e的位置
		System.out.println("b:"+b);
		int c=str2.lastIndexOf("t");
        //从后往前，最后一个字母t的位置
		System.out.println("c:"+c);
		int d=str2.lastIndexOf("t",7);
        //从指定的位置7开始往前找，最后一个字母t的位置
		System.out.println("d:"+d);


	}

}

5.7.获取子字符串

package java第五章_字符串;

public class t12_String获取子字符串 {
	public static void main(String[]args) {
		String id="360731199807188911";
		int a=id.length();
		System.out.println("id的长度是："+a);
		String birthdata=id.substring(6,14);
		//指定截取位置：索引6--14
		System.out.println("birthdata是："+birthdata);
		String b=id.substring(6);
		System.out.println("从索引6开始往后，全部截取"+b);
		//截取范围：指定的索引位置到最后
				
	}

}

5.8.去除空格

package java第五章_字符串;

public class t13_去除字符串首尾空格 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="      我爱你     ";
        //创建首尾有空格的字符串
		System.out.println("未去首尾空格效果："+"["+a+"]");
        //使用中括号方便看出空格效果
		String shorta=a.trim();
        //需要去空格的对象.trim()
		System.out.println("去除首尾空格后的效果："+"["+shorta+"]");
		
	}

}

package java第五章_字符串;

public class t13_去除字符串首尾空格 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="      我 爱    你  !    ";
        //创建有空格的字符串
		System.out.println("未去所有空格效果："+"["+a+"]");
        //使用中括号方便看出空格效果
		String shorta=a.replaceAll("\\s","");
        //需要去空格的对象.replaceAll("\\s","")
		System.out.println("去除所有空格后的效果："+"["+shorta+"]");
		
	}

}

5.9.字符串替换

替换时不可以出现原字符串中没有的，比如大小写不同

正则表达式替换使用replaceAll()

package java第五章_字符串;

public class t9_String字符串替换 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="馒头一文一个，馒头";
		String b=a.replaceFirst("一","壹");
        //将字符串中的”一“换成了”壹“其它保持不变
		System.out.println(b);			//replaceFirst替换只进行一次
		String c=b.replaceAll("馒头", "面包");
        //除了First不一样，其它效果一致
		
		System.out.println(c);
	}

}

5.10.判断字符串开头与结尾

尾部

package java第五章_字符串;
//用于判断上传网站的文件后缀名是否相等

public class t14判断字符串首尾内容 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		/*String a="HelloWorldjava";
		运行结果：
		java与HelloWorld.java尾部相等：true
        .java与HelloWorld.java尾部相等：false
		.jpg与HelloWorld.java尾部相等：false
		两种结果对比：用.endsWith("")里面的去与对象尾部比，与.无关
		*/
		String a="HelloWorld.java";
		boolean a1=a.endsWith("java");
        //判断是否与"HelloWorld.java"尾部相等，显然相等
		boolean a2=a.endsWith(".java");
        //判断是否与"HelloWorld.java"尾部相等，显然相等
//定义布尔型接受判断结果 需要判断的对象.endsWith("")
		boolean a3=a.endsWith(".jpg");
        //判断是否与"HelloWorld.java"后缀名相等，显然不等
		System.out.println("java与HelloWorld.java尾部相等："+a1);
		System.out.println(".java与HelloWorld.java尾部相等："+a2);
		System.out.println(".jpg与HelloWorld.java尾部相等："+a3);


	}

}

首部

package java第五章_字符串;

public class t15判断字符串首部内容 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="我心中永远爱你。";
		boolean a1=a.startsWith("我心里");
        //对象.startsWith("");
		boolean a2=a.startsWith("我心中");
		System.out.println("“我心中永远爱你。”"+"首部是“我心里”：\n"+a1);
		System.out.println("“我心中永远爱你。”"+"首部是“我心中”：\n"+a2);

				
		
	}

}

5.11.判断字符串是否相等

package java第五章_字符串;

public class t16判断字符串是否相等 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a=new String("tom");
        //new方法定义的两个字符串在堆中分别对应不同的两个实体
		String b=new String("tom");
        //两个实体虽然在栈中对应的值相同
		System.out.println(a==b);
        //==双等号的比较是内存地址，二者的堆地址不同，自然false
	}

}

在栈堆中创建了两个对象

5.11.1.使用equals

equals:若相等，意味着字符串内容与长度均要相等,推荐使用

package java第五章_字符串;

public class t17判断字符串是否相等 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a=new String("tom");
        //在栈堆中设置创建了两个不同的对象
		String b=new String("tom");
        //对应的值虽然都是tom，但==比较的是内存地址
		System.out.println(a.equals(b));
        //对象1.equals(对象2)，字符串对象1与对象2是否相等
		
	}

}

5.11.2.忽略大小写

package java第五章_字符串;

public class t18判断字符串是否相等a {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a=new String("abc");
		String b=new String("aBc");
        //大小写不同
		System.out.println(a.equals(b));
        //不忽略大小写比较
		System.out.println(a.equalsIgnoreCase(b));
        //忽略大小写

	}

}

5.11.3.特殊情况==

直接引用字符常量创建的字符串

package java第五章_字符串;

public class t19判断字符串是否相等b {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="tom";
        //a,b的值tom相同，使用的是引用字符串常量创建
		String b="tom";
        //这种创建方法在栈堆的堆中使用的是同一个内存地址，自然相等
		System.out.println(a==b);
        //内存判断自然相等
	}

}

5.11.4.按字典compareTo()

package java第五章_字符串;

public class t19判断字符串是否相等b {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="tom";
        //a,b的值tom相同，使用的是引用字符串常量创建
		String b="tom";
        //这种创建方法在栈堆的堆中使用的是同一个内存地址，自然相等
		System.out.println("引用字符串常量创建的字符串，在栈中用同一个地址，可以用==比较：");
		System.out.println("对String直接引用字符串使用==比较结果正确：\n"+(a==b));
        //内存判断自然相等
		System.out.println("-----------字符compare语法-------------");
//String stra=new String("gudigwedueg")  new方法实例化的字符串
//内存地址不同，必须用equals（字符串比较万能方法）比较
/*---------按字典（unicode表）进行比较  对象1.compareTo（对象2）--------------------------------*/
/*
 （1）数组下标角度，compare()在equals(Object)的及结果为true情况下
     返回值0，则二者相等
 （2）返回值负数，则对象1在对象2前面，
 （3）返回值正数，对象1在对象2后面*/
		String m="b";
		String n="c";
		String o="a";
		String p="b";
		String q="z";
		System.out.println("c与b比较：\n"+n.compareTo(m));
		//c在b后面第1个位置

		System.out.println("a与b比较：\n"+o.compareTo(m));
		//a在b前面第1个位置

		System.out.println("a与c比较：\n"+o.compareTo(n));
		//a在c前面第2个位置

		System.out.println("b与b比较：\n"+m.compareTo(p));
//b在b前面或后面第0个位置，也就是二者位置一样，相等


		System.out.println("z与b比较：\n"+q.compareTo(m));
		//z在b后面第24个位置
		System.out.println("-----------字符compare语法-------------");
		//对比结果取决于对比的字符串首字母在Unicode表的顺序来决定返回值
		String r="bcd";
		String s="efg";
		System.out.println("bcd与efg比较：\n"+r.compareTo(s));
		String t="bcdshsudhsdh";
		String u="fg";
		System.out.println("bcdshsudhsdh与efg比较：\n"+t.compareTo(s));
		System.out.println("bcd与fg比较：\n"+r.compareTo(u));
		System.out.println("对比结果，可知字符串使用compare比较时，结果以首字母为准");



	
	}

}

5.12.大小写转换

语法	含义
String str=str.toLowerCase()	将str中的大写字母转换为小写字母
String str=str.toUpperCase()	将str中的小写字母置换为大写字母
注意	只针对26个字母进行操作，其它字符无效

package java第五章_字符串;

public class t20字符串大小写转换 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="abcDEF";
		String aUp=a.toUpperCase();
        //对象.toUpperCase();
		String aLow=a.toLowerCase();
        //对象.toLowerCase();
		System.out.println("aUp:"+aUp);
		System.out.println("aLow:"+aLow);
	}

}

5.13.字符分割

package java第五章_字符串;

public class t21字符串分割 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String a="abc,def,ghi";
		String[] b=a.split(",");
        //分割成三个独立的字符串，最后以数组形式返回结果
		for(String c:b) {
            //foreach的使用，将b中所有元素依次输出
			System.out.println(c);
		}
	}

}

str.split(String sign,int n)
- 以sign为分割符，分割为n组，正则表达式匹配n-1次
- 数组最后一项是最后一次匹配分割符后面的全部内容
定义多个分割符使用 |
- 同时定义点和逗号
- ```
String str.split(".|,");
```

package java第五章_字符串;

public class t22字符串分割 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String ip="192.168.0.1";
		String ip1="192.168,172.2";
		String [] arrip1=ip1.split("\\.|\\,");
		//定义两个分割符  .  ,   并用   |   连接
		//   \\.    等于使用   .   分割
		String[] firstArray=ip.split("\\.");
        //未设置以点分割的次数
		String[] secondArray=ip.split("\\.",2);
        //设置以点分割的次数，2次
		for(String a:firstArray) {
            //foreach语句的使用
			System.out.println("a"+"["+a+"]");

		}

		System.out.println("\n");
		for(String b:secondArray) {
			System.out.println("b"+"["+b+"]");
		}
		for(String c:arrip1) {
			System.out.print("c"+"["+c+"]"+"\t");

		}

	}

}

5.14.时间日期格式化

背景

导入数据处理·的包

'b', 'B'  常规  如果参数 arg 为 null，则结果为 "false"。如果 arg 是一个 boolean 值或 Boolean，则结果为 String.valueOf() 返回的字符串。否则结果为 "true"。  
'h', 'H'  常规  如果参数 arg 为 null，则结果为 "null"。否则，结果为调用 Integer.toHexString(arg.hashCode()) 得到的结果。  
's', 'S'  常规  如果参数 arg 为 null，则结果为 "null"。如果 arg 实现 Formattable，则调用 arg.formatTo。否则，结果为调用 arg.toString() 得到的结果。  
'c', 'C'  字符  结果是一个 Unicode 字符  
'd'  整数  结果被格式化为十进制整数  
'o'  整数  结果被格式化为八进制整数  
'x', 'X'  整数  结果被格式化为十六进制整数  
'e', 'E'  浮点  结果被格式化为用计算机科学记数法表示的十进制数  
'f'  浮点  结果被格式化为十进制数  
'g', 'G'  浮点  根据精度和舍入运算后的值，使用计算机科学记数形式或十进制格式对结果进行格式化。  
'a', 'A'  浮点  结果被格式化为带有效位数和指数的十六进制浮点数  
't', 'T'  日期/时间  日期和时间转换字符的前缀。请参阅日期/时间转换。  
'%'  百分比  结果为字面值 '%' ('\u0025')  
'n'  行分隔符  结果为特定于平台的行分隔符  

任何未明确定义为转换的字符都是非法字符，并且都被保留，以供将来扩展使用。 

日期/时间转换
以下日期和时间转换的后缀字符是为 't' 和 'T' 转换定义的。这些类型相似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的类型。提供其他转换类型是为了访问特定于 Java 的功能（如将 'L' 用作秒中的毫秒）。 

以下转换字符用来格式化时间： 'H'  24 小时制的小时，被格式化为必要时带前导零的两位数，即 00 - 23。  
'I'  12 小时制的小时，被格式化为必要时带前导零的两位数，即 01 - 12。  
'k'  24 小时制的小时，即 0 - 23。  
'l'  12 小时制的小时，即 1 - 12。  
'M'  小时中的分钟，被格式化为必要时带前导零的两位数，即 00 - 59。  
'S'  分钟中的秒，被格式化为必要时带前导零的两位数，即 00 - 60 （"60" 是支持闰秒所需的一个特殊值）。  
'L'  秒中的毫秒，被格式化为必要时带前导零的三位数，即 000 - 999。  
'N'  秒中的毫微秒，被格式化为必要时带前导零的九位数，即 000000000 - 999999999。  
'p'  特定于语言环境的 上午或下午 标记以小写形式表示，例如 "am" 或 "pm"。使用转换前缀 'T' 可以强行将此输出转换为大写形式。  
'z'  相对于 GMT 的 RFC 822 格式的数字时区偏移量，例如 -0800。  
'Z'  表示时区缩写形式的字符串。Formatter 的语言环境将取代参数的语言环境（如果有）。  
's'  自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的秒数，即 Long.MIN_VALUE/1000 与 Long.MAX_VALUE/1000 之间的差值。  
'Q'  自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的毫秒数，即 Long.MIN_VALUE 与 Long.MAX_VALUE 之间的差值。  


以下转换字符用来格式化日期： 'B'  特定于语言环境的月份全称，例如 "January" 和 "February"。  
'b'  特定于语言环境的月份简称，例如 "Jan" 和 "Feb"。  
'h'  与 'b' 相同。  
'A'  特定于语言环境的星期几全称，例如 "Sunday" 和 "Monday"  
'a'  特定于语言环境的星期几简称，例如 "Sun" 和 "Mon"  
'C'  除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数，即 00 - 99  
'Y'  年份，被格式化为必要时带前导零的四位数（至少），例如，0092 等于格里高利历的 92 CE。  
'y'  年份的最后两位数，被格式化为必要时带前导零的两位数，即 00 - 99。  
'j'  一年中的天数，被格式化为必要时带前导零的三位数，例如，对于格里高利历是 001 - 366。  
'm'  月份，被格式化为必要时带前导零的两位数，即 01 - 13。  
'd'  一个月中的天数，被格式化为必要时带前导零两位数，即 01 - 31  
'e'  一个月中的天数，被格式化为两位数，即 1 - 31。  


以下转换字符用于格式化常见的日期/时间组合。 'R'  24 小时制的时间，被格式化为 "%tH:%tM"  
'T'  24 小时制的时间，被格式化为 "%tH:%tM:%tS"。  
'r'  12 小时制的时间，被格式化为 "%tI:%tM:%tS %Tp"。上午或下午标记 ('%Tp') 的位置可能与语言环境有关。  
'D'  日期，被格式化为 "%tm/%td/%ty"。  
'F'  ISO 8601 格式的完整日期，被格式化为 "%tY-%tm-%td"。  
'c'  日期和时间，被格式化为 "%ta %tb %td %tT %tZ %tY"，例如 "Sun Jul 20 16:17:00 EDT 1969"。  

日期/时间 
此转换可应用于 long、Long、Calendar 和 Date。 't'  '\u0074'  日期和时间转换字符的前缀。  
'T'  '\u0054'  't' 的大写形式。  


以下日期和时间转换字符后缀是为 't' 和 'T' 转换定义的。这些类型类似于但不完全等同于 GNU date 和 POSIX strftime(3c) 定义的那些类型。提供其他转换类型是为了访问特定于 Java 的功能（例如，'L' 用于秒中的毫秒）。 

以下转换字符用来格式化时间： 'H'  '\u0048'  24 小时制的小时，被格式化为必要时带前导零的两位数，即 00 - 23。00 对应午夜。  
'I'  '\u0049'  12 小时制的小时，被格式化为必要时带前导零的两位数，即 01 - 12。01 对应于 1 点钟（上午或下午）。  
'k'  '\u006b'  24 小时制的小时，即 0 - 23。0 对应于午夜。  
'l'  '\u006c'  12 小时制的小时，即 1 - 12。1 对应于上午或下午的一点钟。  
'M'  '\u004d'  小时中的分钟，被格式化为必要时带前导零的两位数，即 00 - 59。  
'S'  '\u0053'  分钟中的秒，被格式化为必要时带前导零的两位数，即 00 - 60（"60" 是支持闰秒所需的一个特殊值）。  
'L'  '\u004c'  秒中的毫秒，被格式化为必要时带前导零的三位数，即 000 - 999。  
'N'  '\u004e'  秒中的毫微秒，被格式化为必要时带前导零的九位数，即 000000000 - 999999999。此值的精度受底层操作系统或硬件解析的限制。  
'p'  '\u0070'  特定于语言环境的上午或下午标记以小写形式表示，例如 "am" 或 "pm"。使用转换前缀 'T' 可以强行将此输出转换为大写形式。（注意，'p' 产生的输出是小写的。而 GNU date 和 POSIX strftime(3c) 产生的输出是大写的。）  
'z'  '\u007a'  相对于 GMT 的 RFC 822 格式的数字时区偏移量，例如 -0800。  
'Z'  '\u005a'  表示时区的缩写形式的字符串。  
's'  '\u0073'  自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的秒数，也就是 Long.MIN_VALUE/1000 与 Long.MAX_VALUE/1000 之间的差值。  
'Q'  '\u004f'  自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的毫秒数，即 Long.MIN_VALUE 与 Long.MAX_VALUE 之间的差值。此值的精度受底层操作系统或硬件解析的限制。  


以下转换字符用来格式化日期： 'B'  '\u0042'  特定于语言环境的完整月份名称，例如 "January" 和 "February"。  
'b'  '\u0062'  特定于语言环境的月份简称，例如 "Jan" 和 "Feb"。  
'h'  '\u0068'  与 'b' 相同。  
'A'  '\u0041'  特定于语言环境的星期几的全称，例如 "Sunday" 和 "Monday"  
'a'  '\u0061'  特定于语言环境的星期几的简称，例如 "Sun" 和 "Mon"  
'C'  '\u0043'  除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数，即 00 - 99  
'Y'  '\u0059'  年份，被格式化为必要时带前导零的四位数（至少），例如 0092 等于格里高利历的 92 CE。  
'y'  '\u0079'  年份的最后两位数，被格式化为必要时带前导零的两位数，即 00 - 99。  
'j'  '\u006a'  一年中的天数，被格式化为必要时带前导零的三位数，例如，对于格里高利历是 001 - 366。001 对应于一年中的第一天。  
'm'  '\u006d'  月份，被格式化为必要时带前导零的两位数，即 01 - 13，其中 "01" 是一年的第一个月，("13" 是支持阴历所需的一个特殊值）。  
'd'  '\u0064'  一个月中的天数，被格式化为必要时带前导零的两位数，即 01 - 31，其中 "01" 是一个月的第一天。  
'e'  '\u0065'  一个月中的天数，被格式化为两位数，即 1 - 31，其中 "1" 是一个月中的第一天。  


以下转换字符用于格式化常见的日期/时间组合。 'R'  '\u0052'  24 小时制的时间，被格式化为 "%tH:%tM"  
'T'  '\u0054'  24 小时制的时间，被格式化为 "%tH:%tM:%tS"。  
'r'  '\u0072'  12 小时制的时间，被格式化为 "%tI:%tM:%tS %Tp"。上午或下午标记 ('%Tp') 的位置可能与地区有关。  
'D'  '\u0044'  日期，被格式化为 "%tm/%td/%ty"。  
'F'  '\u0046'  ISO 8601 格式的完整日期，被格式化为 "%tY-%tm-%td"。  
'c'  '\u0063'  日期和时间，被格式化为 "%ta %tb %td %tT %tZ %tY"，例如 "Sun Jul 20 16:17:00 EDT 1969"。

package java第五章_字符串;

import java.util.Date;
//使用alt+/引入date的包

public class t23时间日期格式化 {
    //获取目前设备的时间并对其进行处理

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Date date=new Date();
		System.out.println("未格式化："+date);
		//未格式化：Mon Oct 18 11:08:34 CST 2021
		String str=String.format("%tF",date);
		//String.format("%tF",对象)格式化后：2021-10-18
		System.out.println("格式化后："+str);
		String year=String.format("%tY",date);
        //格式化为年
		System.out.println("%tY的效果："+year);
		String month=String.format("%tB",date);
        //格式化为月
		System.out.println("%tB的效果："+month);
		String day=String.format("%td",date);
        //格式化为日
		System.out.println("%td的效果："+day+"日");
		
		String hour=String.format("%tH",date);
		String minute=String.format("%tM",date);
		String second=String.format("%tS",date);
		System.out.println("小时:"+hour+"分钟:"+minute+"秒:"+second);
		String str1=String.format("%tF", date);
        //%tF的效果：2021-10-18
		String str2=String.format("%tD", date);
        //%tD的效果：10/18/21

		String str3=String.format("%tc", date);
		//%tc的效果：周一 10月 18 11:34:05 CST 2021

		String str4=String.format("%tr", date);
        //%tr的效果：11:34:05 上午

		System.out.println("%tD的效果："+str2);
		System.out.println("%tc的效果："+str3);
		System.out.println("%tr的效果："+str4);
		System.out.println("%tF的效果："+str1);

	}

}

符号	含义
%c	输出位字符
%d	十进制整数
%f	默认保留六位小数，指定六位小数（%.2f）
%e	科学计数法
%d%%	百分之d
%b	输出布尔型结果

package java第五章_字符串;

public class t24常规类型格式化 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println(String.format("大写字母a是:%c",'A'));
		//%c以字符输出   String.format("大写字母a是:%c",'A')
		System.out.println(String.format("12+13的和是：%d", 12+13));
		//%d以十进制整数输出
		System.out.println(String.format("π保留两位小数是：%.2f", Math.PI));
		//%.2f  2表明以多少位小数，没有表明的话，默认6位
		System.out.println(String.format("π保留两位小数是：%f", 1.23345679933));

		System.out.println(Math.PI);
		System.out.println(String.format("1200000科学计数是：%e",1200000.));
		//科学计数，未完全掌握
		System.out.println(String.format("天才由%d%%的灵感和%d%%的汗水组成", 1,99));
		//分别对应后面的数字，%d   %%后面两个%才是百分号，代表前面整数的百分几



	}

}

5.15.正则表达式

在正则表达式中.代表任何一个字符，在正则表达式使用普通意义的.使用转义字符.

package java第五章_字符串;

public class t25使用正则表达式 {//判断邮箱地址合法性

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String email="\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";//创建email标准格式
//合法字符@合法字符（.合法字符）.com/cn
//最少一次  最少一次 可有可无
//	+最少一次   *零次或者多次  {2,3}2到3个字符	
		String str1="508200729@qq.com";//创建邮箱地址
		String str2="123.qq.com";
		String str3="wteydgyewe22354723@wgqueguyw.cn";
		String str4="123@456.vip.com";
		if(str1.matches(email)) {//判断str1邮箱与email标准格式是否相等
			//合法则输出下一行语句，不合法，则直接跳过，也就是相当于else是空语句
			System.out.println("str1=\"508200729@qq.com\""+"是合法的邮箱地址");
		}
		if(str2.matches(email)) {
			System.out.println("str2=\"123.qq.com\""+"是合法的邮箱地址");

		}
		if(str3.matches(email)) {
			System.out.println("str3=\"wteydgyewe22354723@wgqueguyw.cn\""+"是合法的邮箱地址");

		}
		if(str4.matches(email)) {
			System.out.println("str4=\"123@456.vip.com\""+"是合法的邮箱地址");

		}
		String a="\\w";
		String b="#";
		if(b.matches(a)) {
			System.out.println("#属于\\w范围");
		}else {
			System.out.println("#不属于\\w范围，不可用于email测试");
		}
	}

}

package java第五章_字符串;

import java.util.Scanner;

public class t26使用正则表达式 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		@SuppressWarnings("resource")//根据提示处理警告
		Scanner sc=new Scanner(System.in);
		String str="(13[0-9]|15[012356789]|18[056789])[0-9]{8}";
/*
(13[0-9]|15[012356789]|18[056789])三者中的任意一个，13[0-9]第三位是0-9的任意一位
15[012356789]，012356789中的任意一个
[0-9]{8}，0-9十个数字中任意取8个出来
 */
		for(int i=1;i<=5;i++) {//最好不要用while(true)不然可以无限输入，危险
			System.out.println("请输入电话号码：");
			String phone=sc.nextLine();
			if(phone.matches(str)) {
				System.out.println("是电话号码");
				
			}else{
				System.out.println("不是电话号码");
			}
		}
		System.out.println("尝试次数已达到5次，请下次再试！");
		
	}
}

5.16.字符串生成器

5.16.1.StringBuffer类

操作激动灵敏，保障线程安全和同步
创建
方法

5.16.2.StringBuilder类

用法上与StringBuffer兼容,但是不像StringBuffer一样，可以保证线程安全，就是无法线程同步
不能保证线程同步，不给线程加锁，且只能在单线程上使用，故其效率比StringBuffer更高

区别与同步

package java第五章_字符串;

public class t27StringBuffer类 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		StringBuffer sbf1=new StringBuffer(16);
		sbf1.append("门前大桥下，");
		System.out.println(sbf1);
		sbf1.append("游过一群鸭，");
		System.out.println(sbf1);
		StringBuffer tem=new StringBuffer("快来数一数，");
		System.out.println(tem);
		sbf1.append(tem);
		System.out.println(sbf1);
		int x=2345;
		sbf1.append(x);
		System.out.println(sbf1);
//门 前 大 桥 下 ， 游 过 一 群  鸭 ，  快  来  数  一  数  ， 2  3  4  5
//0 1 2  3 4  5 6 7 8  9  10 11 12 13 14  15 16 17 18 19 20 21
		sbf1.setCharAt(0,'木');
		System.out.println("将索引0上的“门”换成“木”：\n"+sbf1);
		sbf1.insert(6, "河水中");
		System.out.println("在索引6插入“河水中”：\n"+sbf1);
		sbf1.reverse();
		System.out.println("反向输出的效果：\n"+sbf1);
		sbf1.reverse();
		System.out.println("反向反向输出的效果：\n"+sbf1);
		sbf1.replace(0, 4, "门前");
		//木前大桥下，河水中游过一群鸭，快来数一数，2345
		//（0,0）则变成直接在索引0插入“门前”
		//(0，n)  0到n-1的内容替换，（0,4，“门前”）门前下，河水中游过一群鸭，快来数一数，2345
		//0-4，总共替换0--3四个位置，因替换对象只有门前两个字，所以，相当于0-3四个位置全部被删除，然后填上门前两个字

		System.out.println(sbf1);
		sbf1.insert(2,"大桥");//在索引2位置插入“大桥”
		System.out.println(sbf1);
		//门前大桥下，河水中游过一群鸭，快来数一数，2345
		sbf1.delete(0,0);
		//（0,0）不做操作，也就是不删除
		System.out.println(sbf1);
		sbf1.delete(0, 5);
		//(0,n)与replace的操作一致，范围均是（0，n-1）被删除
		System.out.println(sbf1);
		//，河水中游过一群鸭，快来数一数，2345
		char a=sbf1.charAt(0);//获取索引0的字符
		System.out.println(a);

	
		
	}

}

package java第五章_字符串;

public class t28StringBuffer类a {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		StringBuffer str=new StringBuffer("执子之手");
		System.out.println(str);
		str.insert(0, "执");
		//在索引0添加内容，即头部
		System.out.println("在索引0添加“执”效果：\n"+str);
		str.delete(1, 2);
		//之所以设置（0，n）执行删除n-1,就是为了可以对一个索引
		//位置进行操作，（1,1）则不会操作，要删除索引1的字，使用（1，2）即可
		System.out.println("删除索引1的“指”效果：\n"+str);
		str.append("，与之相老");
		//在末尾添加上“，与之相老”
		System.out.println("在str后面加上“与之相老”效果：\n"+str);
		str.reverse();//反向输出
		System.out.println("将str反向输出效果：\n"+str);
		str.reverse();
		System.out.println("将str回正向输出效果：\n"+str);

		int a=str.indexOf("之");
		System.out.println("字符“之”的索引位置：\n"+a);
		char ch=str.charAt(8);
		//若超出索引位置，则会报错，输出索引8的字符
		System.out.println("执子之手，与子偕老的索引8的字符：\n"+ch);
		String str1=str.substring(5);
		System.out.println("执子之手，与子偕老的索引5到最后，效果：\n"+str1);
		String str2=str.substring(0,2);
		System.out.println("执子之手，与子偕老的0-2索引，效果：\n"+str2);
		System.out.println("目前字符串为:\n"+str);
		int length=str.length();
		System.out.println("“执子之手，与子偕老”字符串的长度：\n"+length);
		
		




		
	}

}

package java第五章_字符串;

public class t29StringBuffer类b {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
	StringBuffer sbf1=new StringBuffer("ABCDEFG");
	System.out.println("常见的新字符串：\n"+sbf1);

	int index=sbf1.indexOf("BC");
	System.out.println("“BC”字符串索引位置：\n"+index);
	sbf1.replace(1, 2, "1");//（1,2，,1-1的替换就会索引1的字符，类似删除
	System.out.println(sbf1);
	//StringBuffer ten=sbf1.replace(1, 1, "1");//（1,1，,1-1的替换就会变成在索引1插入
	//A1BCDEFG
	String str1=new String("12");
	String str2=new String("12");
	System.out.println("结果为FALSE，说明创建的是String类(创建了两个对象)：\n"+str1==str2); 
	//转换为StringBuffer类
	StringBuffer str1B=new StringBuffer(str1);
	//使用str1.append("")报错，证明str1是一个String类
	str1B.append("34556");
	System.out.println("可以使用.append命令，说明转换成功"+str1B );
	

	}

}