Java面向对象编程-字符串

字符串

1、String赋值的方法

String 类 中有两种赋值

• 直接赋值 String str = “x” ;

• 实例化赋值 String str = new String (“x”);

字符串本身就是一个匿名对象，即便没有利用String；

例如：System.out.println(“aaaaa”); //这五个a就是String的匿名对象

public class JavaDemo{
	public static void main(String [] args){
		int stra = 10 ; 
		int strb = 10 ;
		String strA = "A" ;			// 
		String strB = new String ("A") ;	// 开辟了一个新的空间
		System.out.println(stra == strb);	
		System.out.println(strA == strB);	// 对于 == 这种比较在String 中 直接赋值比较可以相等，但是在利用实例化赋值的话是不相等的，此时的 == 比较的是储存空间的地址
		System.out.println(strA.equals(strB));	//利用JDK中的方法来比较字符串内容
	}
}

在String中，可以利用字符串和equals 来判断是否String 类型的字符串，原理是利用了String 的匿名类

public class JavaDemo{
	public static void main(String [] args){
		String strA = "A" ;
		System.out.println("A".equals(strA));
	}
}

在用户输入数据时，与原有的数据进行比较时，要将原有的字符写在equals方法的前面,这样可以利用String的匿名类来规避用户输入为空的情况，这是利用equals方法中本身规避null的原理，因此要将字符串常量写在前面

public class JavaDemo{
	public static void main(String [] args){
		String strA = null ;
		System.out.println("A".equals(strA));
	}
}

在String 中拥有一个字符串池，在对一个String属性的变量赋值时，首先先回去String池中寻找是否拥有此赋值的数据，
若有，则新的变量会指向池中原有的数据；若无，则开辟新的空间，将新的字符串添加入池中；这样可以减少对象的产生以来减少空间的使用
String stra = “A” ; //开辟新池中新的空间，空间中有A
String strb = “A” ; //寻找到池中的A，strb指向A的地址，此时stra==starb
若使用new来实例化String的对象，这样会开辟新的空间，不会采用池中的数据。
String stra = “A” ; //开辟池中新的空间
String strc = new String(“A”) ; //strc会开辟新的空间，但在"A"依然会在池中寻找，找到之后交给strc然后再开辟一条新的空间。

但为了方便开发者使用，在String中拥有 intern()的方法来使new的对象手工入池

public class JavaDemo{
	public static void main(String [] args){
		String strA = "abcd" ;			//在池中开辟一个新的空间
		String strB = new String ("abcd") ;		//在池中寻找abcd，然后交给strc再开辟一个新的空间
		String strC = new String ("abcd").intern() ;	//在池中寻找abcd，然后将strc指向abcd。手工入池
		System.out.println(strA == strB);		//false
		System.out.println(strA == strC);		//true
	}
}

在池中拥有静态常量池和动态常量池

public class JavaDemo{
	public static void main(String [] args){
		String strA = "abcd" ;
		String strC = "ab" ;
		String strB = "ab" + "cd" ;
		String strD = strC + "cd" ;
		System.out.println(strA == strB);	//true 在A和B中，依然可以将字符串组合，java是知道字符串的，因此是静态的地址
		System.out.println(strA == strD);	//false 在A和D因为具有C变量，java无法确定C中的数据，因此是动态的地址
	}
}						//可以使用equals来判断

当使用 String strA = “A” ; strA = Str + “B” ; 这种类型的修改时，会产生新的空间，即先产生A，之后再产生B，最后再产生AB，那么就会有垃圾空间的产生，如果多次改变String的变量，那么会产生很多垃圾空间，
这样会使程序的性能变差，因此，在程序开发中，要尽量避免大量的修改String类型的变量。

2、main分析

public static void main(String [] args)

• public:描述的是一种访问权限，主方法是一切的开始点，开始点一定是公共的

• static:程序的执行是通过类名称完成的，所以表示此方法是由类直接调用的

• void:主方法是一切的起点，起点一旦开始就没有返回的可能

• main:是一个系统定义好的方法名称

• String [] args:字符串数组，可以实现 程序启动参数的接受

//输出String [] args 中的参数，首先javac编译，然后执行java JavaDemo，而参数跟在JavaDemo后面，java JavaDemo “Hello World”,参数中有空格需要加上"，否则认为空格是将参数分为两个

public class JavaDemo{
	public static void main(String [] args){
		for(String arg : args){
			System.out.println(arg) ;
		}
	}
}

以后可以通过这种启动参数，来实现数据输入的模拟

3、字符串与字符

charAt()是可以获取某一个指定索引位置的字符，但是程序之中索引下表都是从0开始的

public class JavaDemo{
	public static void main(String [] args){
		String str = "asdag" ;	//创建字符
		char c = str.charAt(2) ;	//取出第3个字符
		System.out.println(c) ;
	}
}

在程序语言之中，String 类中的方法中也是有体现的

public class JavaDemo{
	public static void main(String [] args){
		String str = "helloworld" ;	//创建小写字母
		char [] c = str.toCharArray(); 
		for(int x = 0 ; x < c.length ; x ++ ){
			c[x] -= 32 ;		//将小写字母更改为大写
		}
		String newStr = new String(c) ;
		System.out.println(newStr) ;		//全部输出
		System.out.println(new String (c,0,5)) ;	//输出五个
	}
}

判断一个字符串是否全部由数字组成

• 判断字符串每一位的最好的做法是将字符串变为字符数组

• 可以判断每一位字符是否在数字范围之内（‘0’~‘9’）;

public class JavaDemo{
	public static void main(String [] args){
		String str = "helloworld" ;	//创建小写字母
		String num = "156756" ;	//创建数字
		System.out.println(isNumber(str) ? "数字" : "不是数字");
		System.out.println(isNumber("123") ? "数字" : "不是数字");
	}

	public static boolean isNumber(String str){
		char [] c = str.toCharArray();
		for(int x = 0 ; x < c.length ; x ++){
			if(c[x] < '0' || c[x] > '9'){
				return false ;
			}
		}
		return true ;
	}

}

在实际开发之中处理中文的时候往往使用char类型，因为它可以包含中文数据。

字符串与字节数组

public class JavaDemo{
	public static void main(String [] args){//利用字符串转换为字节数组
		String str = "helloworld" ;	
		byte data[] = str.getBytes() ;
		for(int x = 0 ; x < data.length ; x ++) {
			data[x] -= 32 ;
		}
		System.out.println(new String(data)) ;
		System.out.println(new String(data,0,5)) ;
	}
}

public String (byte[] bytes) 构造，将全部的字节数组转变为字符串

public String (byte[] bytes,int offset,int length) 构造，将部分的字节数组转表为字符串

public byte[] getBytes() 普通，将字符串转换为字节数组

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException 普通，编码转换 --二进制中需要掌握的重点方法

4、字符串比较

一下两种方法十分重要，主要比较的是 ANSI 值 的大小
equals()

public class JavaDemo{
	public static void main(String [] args){
		String strA = "helloworld" ;	
		String strB  = "HELLOWORLD" ;
		System.out.println(strA.equals(strB));	//equals可以比较会区分大小写
	}

}

equalsIgnoreCase()

public class JavaDemo{
	public static void main(String [] args){
		String strA = "helloworld" ;	
		String strB  = "HELLOWORLD" ;
		System.out.println(strA.equalsIgnoreCase(strB));	//equalsIgnoreCase()方法不区分大小写
	}

}

compareTo() //该方法比较字符串大小

public class JavaDemo{
	public static void main(String [] args){
		String strA = "h" ;	
		String strB  = "H" ;
		System.out.println(strA.compareTo(strB));	//compare()方法区分大小写
	}

}

compareToIgnoreCase() //该方法表示 忽略大小写的比较

public class JavaDemo{
	public static void main(String [] args){//利用字符串转换为字节数组
		String strA = "h" ;	
		String strB  = "H" ;
		System.out.println(strA.compareToIgnoreCase(strB));	//compareToIgnoreCase()方法不区分大小写
		System.out.println(strB.compareToIgnoreCase(strA));
	}

}

5、字符串查找

contains()方法 用来查找字符串
该方法在JDK 1.5 之后加上的

public class JavaDemo{
	public static void main(String [] args){
		String strA = "hello" ;	
		System.out.println(strA.contains("hello"));//true
		System.out.println(strA.contains("world"));//false
	}

}

indexOf() 方法 用来查找字符串的位置，返回 的是字符串 在被查找的字符串的 第几位
若没有查到，则返回 -1
该方法是从前往后查找的
lastIndexOf() 方法 是从后往前查找

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shenmeng.linhello" ;	
		System.out.println(strA.indexOf("hello"));// 12
		System.out.println(strA.indexOf("world"));// -1
		if(strA.indexOf("hello") != -1){
			System.out.println("数据存在") ;
		}
		System.out.println(strA.lastIndexOf("lin"));//  9
		System.out.println(strA.lastIndexOf("."));// 8
	}

}

startsWith() 方法 用来查找 是否 以 某字符串开头
endsWith() 方法 用来查找 是否 以 某字符串结尾
这两个方法十分重要，在开发中会经常用到

public class JavaDemo{
	public static void main(String [] args){
		String strA = "***@@shenmeng.linhello##" ;	
		System.out.println(strA.startsWith("**"))	;// true
		System.out.println(strA.endsWith("##")) ;// true
		System.out.println(strA.startsWith("@@",3)) ;// true
	}

}

字符串替换

replaceAll() 方法 用于 替换全部的 字符replaceFirst() 方法 用于 替换 第一个 字符
这两个方法十分的重要

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shenmeng.linhello" ;	
		System.out.println(strA.replaceAll("l","x")) ;// shenmeng.xinhexxo
		System.out.println(strA.replaceFirst("n","a")) ;// sheameng.linhello
	}

}

6、字符串拆分

split() 方法 用来 拆分 字符串 () 中 是按照什么拆分的方法

如下面代码中 是 按照 “ ”空格拆分的

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shen meng lin hello" ;
		String result [] = strA.split(" ") ;	//按照空格拆分
		for(int x = 0 ;  x < result.length ; x ++){
			System.out.println(result[x]) ;
		}
	}
}

结果为：
shen
meng
lin
hello

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shen meng lin hello" ;
		String result [] = strA.split(" ",2) ;	//按照空格拆分，拆分成两个
		for(int x = 0 ;  x < result.length ; x ++){
			System.out.println(result[x]) ;
		}
	}
}

结果为：
shen
meng lin hello

但是在进行拆分的时候有可能遇到拆不了的情况，这个时候最简单的理解就是使用“\”进行转义

下面的代码是拆不开的情况

public class JavaDemo{
	public static void main(String [] args){
		String strA = "192.168.123.1" ;
		String result [] = strA.split(".") ;	//按照空格拆分
		for(int x = 0 ;  x < result.length ; x ++){
			System.out.println(result[x]) ;
		}
	}
}

下面的代码是转义之后的代码

public class JavaDemo{
	public static void main(String [] args){
		String strA = "192.168.123.1" ;
		String result [] = strA.split("\\.") ;	//按照空格拆分
		for(int x = 0 ;  x < result.length ; x ++){
			System.out.println(result[x]) ;
		}
	}
}

结果为：
192
168
123
1

7、字符串截取

substring() 方法 用来 截取字符串

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shenmenglin.123" ;
		System.out.println(strA.substring(4)) ;// menglin.123
		System.out.println(strA.substring(4,11)) ;// menglin
	}
}

在实际的开发中，有些时候或者结束索引往往都是通过indexOf() 方法 计算 来的
通过indexOf() 方法 来获取 字符串的位置，然后再用substring() 方法 来截取字符串

public class JavaDemo{
	public static void main(String [] args){
		// 字符串结构：用户id-photo-姓名-后缀
		String strA = "sml-photo-沈梦琳.jpg" ;
		int beginIndex = strA.indexOf("-",strA.indexOf("photo")) +1;//查找 - ，从 photo 开始查找
		int endIndex = strA.lastIndexOf(".") ;
		System.out.println(strA.substring(beginIndex,endIndex)) ;// 沈梦琳
	}
}

在以后的开发之后，通过计算来确定索引的情况十分常见，因此这个方法十分重要

8、字符串格式化

format() 方法 用来 格式化 操作

public class JavaDemo{
	public static void main(String [] args){
		String name = "沈梦琳" ;
		int age = 18 ;
		double grade = 98.76526 ;
		String strA = String.format("姓名：%s、年龄：%d、成绩：%5.2f" , name,age,grade ) ;
		System.out.println(strA) ;//姓名：沈梦琳、年龄：18、成绩：98.77
		//将结果中的成绩后面的小数四舍五入了
	}
}

这种格式化的输出操作算的String 的一种附加方法

9、其他方法

concat() 方法
附加字符串，但不将附加的字符串加入String 常量池中

public class JavaDemo{
	public static void main(String [] args){
		String strA = "shenmenglin" ; 
		String strB = "shen".concat("meng").concat("lin") ;
		System.out.println(strB) ;		//shenmenglin
		System.out.println(strA == strB) ;	//false
	}
}

intern() 方法，附加字符串，将附加的字符串加入 String 静态常量池

isEmpty() 方法 用来判断字符串是否为空 这里的空不是指null

null指实例化对象为空，但是该方法是在实例化对象不为null 的情况下做出的字符串判断

即““””和null不是同一个概念

public class JavaDemo{
	public static void main(String [] args){
		String strA = "" ;
		System.out.println(strA.isEmpty()) ;//true
		System.out.println("ggg".isEmpty()) ;//false
	}
}

trim() 方法 用来 消除 两端的“ ”空格
但没有消除字符串中间的空格的能力

public class JavaDemo{
	public static void main(String [] args){
		String strA = "  Hello World " ;
		System.out.println(strA.length()) ;//14
		System.out.println(strA.trim()) ;//Hello World
	}
}

toUpperCase() 方法 用来将小写字母转换为大写字母
toLowerCase() 方法 用来将大写字母转换为小写字母

public class JavaDemo{
	public static void main(String [] args){
		String strA = "  Hello World !!!!" ;
		System.out.println(strA.toUpperCase()) ;//HELLO WORLD!!!!
		System.out.println(strA.toLowerCase()) ;//hello world!!!!
	}
}

在Java中没有提供首字母大写的功能，但是我们可以利用已有的方法来实现首字母大写

public class JavaDemo{
	public static void main(String [] args){
		System.out.println(StringUtil.initcap("h")) ;//H
		System.out.println(StringUtil.initcap("hello")) ;//Hello
	}
}

class StringUtil{
	public static String initcap(String str){
		if(str == null || "".equals(str)){	//如果为空，原样返回
			return str;	
		}
		if(str.length() == 1){		//如果只有一个字符，将其变成大写返回
			return str.toUpperCase();
		}
					//否则取出第一个字符，将其变成大写，剩下的字符原样返回
		return str.substring(0,1).toUpperCase() + str.substring(1) ;
	}
}