String 字符串类和编码 以及StringBuilder StringBuffer

遍历字符串

方式1：通过charAt()方法

方式2：通过字符数组

package com.ztt.Demo01;

public class demo01 {
	public static void main(String[] args) {
		String s1 = "阴天傍晚车窗外";
		
		//遍历字符串
		//方式1：通过charAt()方法
		for(int i = 0;i < s1.length();i++) {
			char c = s1.charAt(i);
			System.out.print(c);
		}
		System.out.println();
		//方式1：通过字符数组
		char[] array = s1.toCharArray();//将字符串转换成char[]字符数组
		for(int i = 0;i < array.length;i++) {
			char c = array[i];
			System.out.print(c);
		}
	}
}

运行结果：

阴天傍晚车窗外
阴天傍晚车窗外

字符串的比较

实现方式: String类implements实现了Comparable接口，重写了compareTo()方法

package com.ztt.Demo01;

public class demo02 {
	
		//字符串的比较
		//实现方式: String类implements实现了Comparable接口，重写了compareTo()方法
		public static void main( String[] args) {
		String s1 = "abbf";
		String s2 = "abf";
		
		System.out.println(s1.compareTo(s2));
		
	}

}

运行结果：

-4

字符串的内容等值比较

实现思路:重写object类的equals()方法

?

package com.ztt.Demo01;

//字符串的内容等值比较
//实现思路:重写object类的equals()方法
public class demo03 {
	public static void main( String[ ] args) {
		//字符串常量池
		String s1 = "just so so" ;
		String s2 = "just so so";
		System.out.println(s1 == s2);//比较内存地址 
		System.out.println(s1.equals(s2)); //比较内容
		
		//在堆区重新分配空间
		String s3 = new String( "just so so" );
		String s4 = new String( "just so so" );
		System.out.println(s3 == s4); //比较内存地址
		System.out.println(s3.equals(s4));//比较内容
	}
}

运行结果：

true
true
false
true

字符串的查找搜索

indexOf()方法:从原字符串中查找目标字符串，返回第一次出现的位置

lastIndexOf()方法:从原字符串中查找目标字符串，返回最后一次出现的位置

contains()方法:判断原字符串中是否存在目标字符串

startwWith()方法:判断原字符串是否以目标字符串开头

endsWith()方法:判断原字符串是否以目标字符串结尾

package com.ztt.Demo01;

public class demo04 {

	public static void main(String[] args) {
		//字符串的查找
		String s="可怜无定河边骨";//原字符串
		String target="河";//目标字符串
		
		//indexOf()方法
		//如果存在：返回该目标字符串的下标（>=0）
		//如果不存在：返回-1
		int index=s.indexOf(target);
		System.out.println(index);

	}

}

运行结果：

4

package com.ztt.Demo01;
//字符串的查找搜索
//indexOf()方法:从原字符串中查找目标字符串，返回第一次出现的位置
//lastIndexOf()方法:从原字符串中查找目标字符串，返回最后一次出现的位置
//contains()方法:判断原字符串中是否存在目标字符串
//startwWith()方法:判断原字符串是否以目标字符串开头
//endsWith()方法:判断原字符串是否以目标字符串结尾

public class demo05 {

	public static void main(String[] args) {
		String s="唧唧复唧唧木兰当户织";
		String target="当户织";
		
		boolean isEnd=s.endsWith(target);
		System.out.println(isEnd);
		
		boolean isStrats=s.startsWith(target);
		System.out.println(isStrats);
		
		//lastIndexOf()方法:
		//如果存在，则返回true
		//如果不存则，则返回false
		boolean isContains = s.contains(target);
		System.out.println( isContains );
		
		//lastIndexOf()方法:
		//如果存在:返回该目标字符串的下标(>=0)
		//如果不存在:返回-1
			
		int index = s.lastIndexOf(target);	
		System.out.println(index ) ;
		
		// indexOf()方法:
		//如果存在:返回该目标字符串的下标(>=0)
		//如果不存在:返回-1
			
		int index1 = s.indexOf(target,2);	
		System.out.println(index1 ) ;	

	}

}

运行结果：

true
false
true
7
7

判断网址格式?

必须以"http"或"https"开头

必须以.com或.cn结尾

package com.ztt.Demo01;

public class demo06 {

	public static void main(String[] args) {
		
		//判断网址格式
		//必须以"http"或"https"开头
		//必须以.com或.cn结尾
		
		String url = "http://www.163.com" ;
		if((url.startsWith("http")||url.startsWith("https"))&&
		(url.endsWith(".com")|| url.endsWith(".cn"))){
		System.out.println("合法网址! ");
		}else {
		System.out.println("不合法网址! ");
		}
		

	}

}

运行结果：

合法网址! 

通过邮箱地址 截取用户名 邮箱服务器?

package com.ztt.Demo01;

public class demo07 {

	public static void main(String[] args) {
		// 邮箱地址
		String email="3418813089@qq.com";
		
		//截取用户名
		int endIndex=email.indexOf("@");
		String userName=email.substring(0,endIndex);
		
		//截取邮箱服务器
		int beginIndex=endIndex+1;
		endIndex=email.indexOf(".");
		String host=email.substring(beginIndex,endIndex);
		
		System.out.println("用户名账号："+userName);
		System.out.println("邮箱服务器："+host);

	}

}

运行结果：

用户名账号：3418813089
邮箱服务器：qq

字符串是不可变的每次截取，都会产生一个新的字符对象? 使用substring() 方法

package com.ztt.Demo01;

public class demo08 {

	public static void main(String[] args) {
		//字符串是不可变
		String s ="我本将心向明月";
		
		//每次截取，都会产生一个新的字符对象
		String ret = s.substring(4);
		
		System.out.println(s);
		System.out.println(ret);

	}

}

运行结果：

我本将心向明月
向明月

?去除首位“空白字符” 空白字符：空格 \t \r \n 使用：trim()方法

package com.ztt.Demo01;

public class demo09 {

	public static void main(String[] args) {
		//空白字符：空格 \t \r \n
		String s=" ABC\t\r\n";
		
		//去除首位“空白字符”
		s=s.trim();
		
		System.out.println(s);
		System.out.println(s.length());
		

	}

}

运行结果：

ABC
3

替换字符串

使用：1.replace() 方法?

? ? ? ? ? ?2.replaceAll()方法使用正则表达式进行匹配

? ? ? ? ? ? ? [\\,\\.\\$]匹配一个字符内容

? ? ? ? ? ? ? [\\,\\.\\$]+匹配多个字符内容

?

package com.ztt.Demo01;

public class demo10 {

	public static void main(String[] args) {
		// 替换字符串
		String ip="127.0.0.1";
		
		//字符替换字符
		String ret=ip.replace('.', '#');
		
		//字符串替换字符串
		String ret1=ip.replace(".", "[.]");
		
		System.out.println("原字符串:"+ip);
		System.out.println("替换结果:"+ret);
		

	}

}

运行结果：

原字符串:127.0.0.1
替换结果:127#0#0#1

package com.ztt.Demo01;
//字符串的替换
public class demo11 {

	public static void main(String[] args) {
		String s= "A,B,,C,D.E,G$H.I";
		//replace()方法将“，” “.替换成“#”
		String ret=s.replace(",", "#").replace(".", "#");
		
		//replaceAll()方法使用正则表达式惊醒匹配
		//[\\,\\.\\$]匹配一个字符内容
		//[\\,\\.\\$]+匹配多个字符内容
		String ret1=s.replaceAll("[\\,\\.\\$]+", "#");
		//[A-Z]+ 匹配多个大写字母
		String ret2=s.replaceAll("[A-Z]+", "#");
		
		// "."代表1个正则表达式，匹配任意字符
		//“\\."代表1个普通字符串内容，仅匹配"."
		String ret3 = s.replaceAll("\\.","#");
		
		System.out.println(s);
		System.out.println(ret);
		System.out.println(ret1);
		System.out.println(ret2);
		System.out.println(ret3);

	}

}

运行结果：

A,B,,C,D.E,G$H.I
A#B##C#D#E#G$H#I
A#B#C#D#E#G#H#I
#,#,,#,#.#,#$#.#
A,B,,C,D#E,G$H#I

字符串的分割? 使用：split() 方法

package com.ztt.Demo01;

import java.util.Arrays;

//字符串的分割
public class demo12 {

	public static void main(String[] args) {
		String s1 ="北京#上海#南京#苏州#杭州3常州#无锡#深圳#乌鲁木齐";
		String[] ret1 = s1.split("\\#");
		System.out.println(s1);
		System.out.println(Arrays.toString( ret1));
		
		//按照正则表达式的特殊字符进行分割
		String s2 ="北京+上海+南京+苏州+杭州+常州+无锡+深圳+乌鲁木齐";
		String[] ret2 = s2.split("\\+");//＋属于正则表达式的特殊符号，必须转义
		System.out.println(s2);
		System.out.println(Arrays.toString(ret2) );
		
		//按照正则表达式进行分割
		String s3 = "北京A上海F南京K苏州w杭州u常州M无锡s深圳w乌鲁木齐";
		String[] ret3 = s3.split("[A-Z]");
		System.out.println(s3);
		System.out.println(Arrays.toString(ret3));
		
		String s4 = "北京0上海2南京7苏州1杭州4常州2无锡8深圳55乌鲁木齐";
		String[] ret4 = s4.split("[0-9]+");
		System.out.println(s4);
		System.out.println(Arrays.toString(ret4));

	}

}

运行结果：

北京#上海#南京#苏州#杭州3常州#无锡#深圳#乌鲁木齐
[北京, 上海, 南京, 苏州, 杭州3常州, 无锡, 深圳, 乌鲁木齐]
北京+上海+南京+苏州+杭州+常州+无锡+深圳+乌鲁木齐
[北京, 上海, 南京, 苏州, 杭州, 常州, 无锡, 深圳, 乌鲁木齐]
北京A上海F南京K苏州w杭州u常州M无锡s深圳w乌鲁木齐
[北京, 上海, 南京, 苏州w杭州u常州, 无锡s深圳w乌鲁木齐]
北京0上海2南京7苏州1杭州4常州2无锡8深圳55乌鲁木齐
[北京, 上海, 南京, 苏州, 杭州, 常州, 无锡, 深圳, 乌鲁木齐]

字符编码

ASCII码：包含A-Z a-z 、符号、占1个字节

Unicode码:包含主流编码集，占2个字节

UTF-8：占3个字节

package com.ztt.Demo01;
import java.util.Arrays;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

//字符编码
//ASCII码：包含A-Z a-z 、符号、占1个字节
//Unicode码:包含主流编码集，占2个字节
//UTF-8：占3个字节

public class demo14 {

	public static void main(String[] args) throws UnsupportedEncodingException {
		
			String s1 = "A";
			String s2 ="中";
			String s3 ="中";
			System.out.println(Charset.defaultCharset());
			
			// 获取字符串的字节数组
			byte[] b1 = s1.getBytes(); // 按照默认Unicode码获取字节值
			byte[] b2 = s2.getBytes("GBK"); // 按照默认Unicode码获取字节值
			byte[] b3 = s3.getBytes("UTF-8"); // 按照UTF-8码获取字节值
			System.out.println("A=" + Arrays.toString(b1));
			System.out.println("中=" + Arrays.toString(b2));
			System.out.println("中=" + Arrays.toString(b3));
		}
	}
		
		

运行结果：

UTF-8
A=[65]
中=[-42, -48]
中=[-28, -72, -83]

频繁的字符串拼接(修改)

应该选择“可变字符串” : StringBuilder或stringBuffer

创建1个可变字符串: 内部的char[]字符数组采用默认容量16

String:不可变字符串

StringBuilder:可变字符串

StringBuffer:可变字符串

相同点：

1.都是可变字符串，都继承自AbstractStringBuilder父类

区别点：

StringBuilder:线程不安全（每个方法没有加synchronized锁），性能好

StringBuffer:线程安全（每个方法没有加synchronized锁），性能差

package com.ztt.Demo01;

public class demo15 {

	public static void main(String[] args) {
		// 频繁的字符串拼接(修改)
		// 应该选择“可变字符串” : StringBuilder或stringBuffer
		// 创建1个可变字符串: 内部的char[]字符数组采用默认容量16
		StringBuilder s1 = new StringBuilder();
		// 创建1个可变字符串: 内部的char[]字符数组采用指定容量512
		StringBuilder s2 = new StringBuilder(512);
		// 创建1个可变字符串: 内部的char[]字符数组采用指定字符串的长度+16
		StringBuilder s3 = new StringBuilder("A");System.out.println(s3);
		// 向当前字符串s3的尾部追加
		s3.append("B"); // 第2个字符
		s3.append("C");
		s3 .append("D");
		//...
		s3.append("Z"); // 第18个字符，内部数组容量不足时，数组扩容
		System.out.println(s3);
		// 向当前字符串s3的指定位置插入
		s3.insert(0,"a");
		System.out.println(s3);
		// 删除字符串// s3.delete(0，2);
		// System.out.println(s3);
		// 截取字符串
		String ret = s3.substring(0,2);
		System.out.println(s3);
		System.out.println(ret);
	}
}

运行结果：

A
ABCDZ
aABCDZ
aABCDZ
aA

替换字符串中所有的数字，在原有数字基础上+1

package com.ztt.Demo01;

import java.util.UUID;

public class demo16 {

	public static void main(String[] args) {
		String uuid=UUID.randomUUID().toString();
		System.out.println(uuid);
		
		//替换字符串中所有的数字，在原有数字基础上+1
		StringBuilder sb=new StringBuilder(uuid);
		
		//遍历字符串
		for(int i=0;i<sb.length();i++) {
			//获取每个字符
			char c=sb.charAt(i);
			
			//判断该字符是否是数字
			if(c>='0' && c<='9') {
				//转换成数字后，+1
				int n=Integer.parseInt(String.valueOf(c));
				
				//0-9
				n=n+1>9?0:n+1;
				
				//直接在当前字符串对象的内存中，完成替换
				sb.replace(i, i+1, String.valueOf(n));
			}
		}
		System.out.println(sb);

	}

}

运行结果：

16e9a643-18aa-4e44-928d-0401cc883057
27e0a754-29aa-5e55-039d-1512cc994168

逆序遍历字符串?

package com.ztt.Demo01;

public class demo17 {

	public static void main(String[] args) {
		
		String s1="ABCDEFG";
		
		//方式1：逆序遍历，追加拼接至可变字符串的尾部
		StringBuilder ret1=new StringBuilder();
		for(int i=s1.length()-1;i>=0;i--) {
			char c=s1.charAt(i);
			ret1.append(c);//当前字符串拼接在字符串尾部
		}
		System.out.println(ret1);
		
		//方式2：
		StringBuilder ret2=new StringBuilder();
		ret2.reverse();//逆序
		System.out.println(ret2);
	}

}

运行结果：

GFEDCBA

?将空格替换为 “%20”

package com.ztt.Demo01;

//String:不可变字符串
//StringBuilder:可变字符串
//StringBuffer:可变字符串

public class demo18 {

	public static void main(String[] args) {
		//将空格替换为 “%20”
		String s="just do IT hi chi le mei";
		
		//方式1：
		System.out.println(s);
		String ret1=s.replace(" " , "%20");
		System.out.println(ret1);
		
		//方式2：
		StringBuilder sb=new StringBuilder(s);
		System.out.println(sb);
		
		int index=-1;
		while((index=sb.indexOf(" " ))>=0) {
			System.out.println(index);
			sb.replace(index, index+1, "%20");
		}
		
		System.out.println(sb);
	}

}

运行结果：

just do IT hi chi le mei
just%20do%20IT%20hi%20chi%20le%20mei
just do IT hi chi le mei
4
9
14
19
25
30
just%20do%20IT%20hi%20chi%20le%20mei

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?

?