黑马程序员--字符串篇

最新推荐文章于 2024-06-05 22:43:50 发布

迪兰奇迹

最新推荐文章于 2024-06-05 22:43:50 发布

阅读量645

点赞数 1

文章标签：黑马程序员正则表达式字符串

本文链接：https://blog.csdn.net/u013485029/article/details/23100587

版权

字符串

----------------------------------------------------------------------------------------------------------------------

String概述：String代表字符串，字符串是一个特殊的对象，字符串是常量；它们的值在创建之后不能更改，

也正是因为 String 对象是不可变的，所以可以共享！

通常我们见到的Java 程序中的所有字符串字面值（如 "abc" ）都作为String类的实例对象。通过不同的

方法创建的字符串对象在内存中的位置和数目是不同的：

public static void main(){

String s1 = “ abc ”;

String s2 = new String(“ abc ”);

System.out.println(s1==s2 ); //结果为false，因为地址值不相同！

System.out.println(s1.equals( s2 ) ); //结果为true，因为String类复写了equals

//方法，它的作用是比较字符串内容是否相同

}

这里的s1和s2用什么区别？

s1所指向的对象在内存中的字符串缓冲池中，而s2所直接指向的对象在堆内存中，而堆内存它又指向了

字符串缓冲池，所以s1和s2地址值不同！

String类是用于描述字符串事物的类，他提供了下面这些对字符串进行操作的方法：

-----获取：

a. 字符串中包含的字符数，也就是字符长度： int length( ) ；

b. 获取字符串中指定位置上的字符：char charAt(int index)；

c. 根据字符来找出其在字符串中出现的角标位：

int indexOf( int ch )：返回字符在字符串中第一次出现的位置；

int indexOf( int ch，int fromIndex )：从指定角标位开始字符在字符串中第一次出现的位置；

int indexOf( String str )：返回字符子串在字符串中第一次出现处的位置；

int indexOf( String str,，int fromIndex ）：

返回从指定位置开始，字符子串在字符串中第一次出现处的位置；

int lastIndexOf( intch ) ：返回字符在字符串中最后一次出现处的位置。

int lastIndexOf(int ch, int fromIndex) ：从指定的位置开始进行反向搜索，

返回字符在此字符串中最后一次出现处的位置。

int lastIndexOf(String str) ：返回字符子串在此字符串中最右边出现处的位置。

int lastIndexOf(String str, int fromIndex) ：从指定的索引开始反向搜索。返回字符子串在

此字符串中最后一次出现处的位置。

----判断：

a. 判断字符串是否包含某个子串：boolean contains（String str）；

b. 字符串是否是空的：boolean isEmpty( )；

c. 字符串是否以指定的内容开头：boolean startWith(String str )；

d. 字符串是否以指定的内容结尾：boolean endWith(String str)；

e. 判断字符串内容是否相同：boolean equals(String str)；

f. 忽略大小写，判断字符串内容是否相同：boolean equalsIgnoreCase(String str)；

-----转换：

a. 将字符数组转换成字符串：copyValueOf ( char[ ] )或者String( char[ ] )--构造方法

将一个字符数组的一部分转换成字符串：copyValueOf(char[ ]，offset，count )或者

String(char[ ]，offset，count)--构造方法

b. 将字符串转成字符数组：char[ ] toCharArray()；

c. 将字节数组转成字符串：String( byte[ ] )，String( byte[ ]，offset，count)--构造方法

d. 将字符串转成字节数组：byte[ ] getBytes( )；

e. 大小写转换：

转成大写：StringtoUpperCase( )；

转成小写：String toLowerCase( )；

-----替换：

replace(char oldChar,char newChar)：用指定新的字符替换字符串中出现的所有旧的字符，

从而得到一个新的字符串。

replace(CharSequence target, CharSequencereplacement)：用指定新的字符串替换字符

串中出现的所有旧的字符串，从而得到一个新的字符串。

-----切割：

按照正则表达式将字符串切割成若干个字符串数组：String[] split( regex );

-----子串：

String subString(begin)：获取从指定位置开始的字符串子串；

String subString( begin，end)：获取从指定位置开始到指定位置结束的子串，包含头不包含尾巴。

-----比较：

compareTo( )：按照字典（ASCII码表）顺序比较两个字符串！

-----去除首尾空格：

String trim( )：将字符串两端的多个空格去掉。

字符串练习1：模拟一个trim方法，去除字符串两端的空格；

思路：

a. 判读一个字符串的首位是否是空格，如果是，就继续往后判断，直至不是空格为止，结尾处判断空格也是如此；

b. 当开始和结尾均不是空格，就开始获取字符子串。

代码：

class  StringTrimTest{
	public static void sop(String  str){
		System.out.println(str);
	}
	public static String myTrim(String  str){
		int start = 0;
		int end = str.length-1;
		while(start<end&&str.charAt(start)==‘ ’){  //找出前端没有空格的第一的角标位
			start++
		}
		while(end>start&&start.charAt(end)==‘ ’){ //找出后端没有空格的第一的角标位
			end--;
		}
		Return str.subString(start，end+1);   //取首位均无空格的子串，包含头不包含尾；
	}
	public static void main(String[ ]  args){
		String  s = “  abcfd  ”;
		sop(“（”+s+“）”)；
		s = myTrim(s)；
		sop(“（”+s+“）”)；
	}
}

字符串练习2：将一个字符串进行反转，将其中指定部分进行反转

思路：

a. 曾经学过对数组中的元素进行反转，

b. 将字符串转换成数组，在用数组的方法进行反转；

c. 将翻转后的数组变成字符串；

d. 只要将反转部分作为参数传递，便可完成对字符串的指定部分进行反转；

代码：

class  StringReverseTest{
	public static String reverseString(String  s，int  start，int  end){
		char[ ]  chs = s.toCharArray();
		reverse(chs，start，end);
		return new String(chs);
	}	
	public static String reverseString(String  s){       
		return reverseString(s，0，s.length());        //借用部分反转进行整体反转
	}
	Public static void reverse(char[ ]  arr，int  x，int  y){    
		for(int  start =x; end = y-1; start<end;start++,end--){
			swap(arr, satrt, end);                    //由外向内依次反转
		}
	}
	private static void swap(char[ ]  arr，int  x，int  y){  //完成反转动作的核心代码！
		char  temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}	
	public static void main(String[ ]  args){
		String  s = “abkfuebd”;
		System.out.println(reverseString(s，2，5))；
	}
}

字符串练习3：获取一个字符串在另外一个字符串中出现的次数

思路：

a. 定义一个计数器；

b. 获取kk第一次出现的位置；

c. 然后从剩余的位置继续查找kk的位置，每找到一次，计数器加一

d. 当获取不到时，就停止！

class  StringContainCountTest{
	public static int getSubCount1(String str，String  key){   //方法一
		int  count = 0;
		int index = 0;
		while((index = str.indexOf(key))!=-1){       //判断串中是否包含目标字符串！
			str = str.subString(index+key.length());   //截取子串
			count++;
		}
		return  count;
	}          //但是此方法截取了太多的子串，耗费内存！
	public static int getSubCount1(String str，String  key){          //方法二
		int  count = 0;
		int index = 0;
		while((index = str.indexOf(key，index))!=-1){  //从指定位置看是否包含目标字符串
			index = index+key.length;
			count++;
		}
		return  count;
	}
}

此外用spit的方式也可以判断，但是需要判断头尾是否为目标字符串，需要分三种情况，不建议使用！

字符串练习4：获取两个字符串的最大相同子串

思路：

a. 将较短字符串按照长度递减一次获取；

b. 将每次获取的子串拿来与长串放一块判断；

public  static  String  getMaxSubString(String  s1，String  s2){
				//这里s2为较长的字符串，可以通过三元运算符来获取到！
	for(int  x=0; x<s2.length(); x++){
		for(int y = 0, z= s2.length()-x;  z!=s2.length()+1; y++,z++){
			String temp = s2.subString(y,z);
			If(s2.contains(temp))
				return temp;
		}
	}
}

字符串缓冲区

---------------------------------------------------------------------------------------------------------------

StringBuffer：他是一个容器，里边封装了对字符串进行增删改查的常见方法！

---增加：

append( )：将指定的数据添加到已有数据的结尾处；

insert(index，数据)：将数据插入到指定的角标位置；

---删除：

delete（start，end）:删除缓冲区中指定范围的数据，包含头不包含尾；

deleteCharAt(index):删除指定角标位置的元素；

---获取：

charAt(index):获取指定角标位置的字符；

indexOf(String str)：获取指定目标的角标位置；

lastIndexOf(String str)：获取指定目标在容器尾部出现的角标位置；

length( )：获取容器的大小；

subString(int start , int end)：获取指定范围的子串，包含头不包含尾；

---修改：

replace（start，end，str ）：将指定范围的内容替换为指定内容，包含头不包含尾；

setCharAt(int index, char ch):将指定角标位置的字符替换为传入的字符；

---反转：

reverse（str）:将传入的字符串进行反转

---将缓冲区中指定的数据存储到指定字符数组中：

getChars( start, end, chs[ ],dstBegin)：将缓冲区中指定的数据存储到指定字符数组中;

StringBuilder：它的功能和StringBuffer几乎完全一致，只不过他是线程不安全的，但是如果是

单线程使用的话，效率要高一些；而StringBuffer是线程安全的，但是效率低；

基本数据类型对象包装类

----------------------------------------------------------------------------------------------------------------------

对于常用的八中基层数据类型，他们都有相对应的包装类，这些包装类中定义了相应的基本数据类型

操作的常见方法，以及基本数据类型和字符串之间进行转换的方法；

基本数据类型转换成字符串类型：

方法一：基本数据类型+“”；

方法二：基本数据类型.toString();

字符串转成基本数据类型的方法：

xxx a = Xxx.parseXxx(String) //静态方法！

比如：int a = Interger.parseInt(“123”);

int a = parseInt(“110”，2) //说明此110是二进制，要将其转换成十进制；

基本数据类型对象包装类的新特性：

1. 自动装箱和自动拆箱：

Integer x = 4 //被自动装箱，其相当于：Integer x = newInterger(4);

x = x+2; //此处x自动拆箱，和2相加，再将和自动装箱赋给x;

2. 享元模式—flyweight；

很多小对象，他们之间有很多的相同属性，仅有部分属性不同，为了避免new太多的对象，占耗内存，

可以将他们记为一个对象，而不同的属性记为方法的参数，作为外部状态，而相同属性作为内部状态！

Integer i1 = 3;

Integer i2 = 3;

i1 == i2 ; //结果为true！

在-128~127范围内，Integer i通过享元模式不会new新的对象，所以i1==i2。

正则表达式

----------------------------------------------------------------------------------------------------------------------

定义：符合一定规则的表达式；

作用：专门用于操作字符串；对于字符串如果我们需要它有一定的格式要求，例如：不以0开头，长度

在5~15位之间，传统的校验需求通过String 类中大量的方法组合才可以完成，但是通过正则表达式，

我们可以大大的简化代码；

例如：判断下面的字符串是否符合要求：

String qq = “23456”;

String regex = “[1-9][0-9]{4，14}”；

boolean flag =qq.matches(regex); //如果flag为true则说明qq符合要求；

特点：用一堆特定的符号来表示特定的代码，从而达到简化代码的效果；

所以学习正则表达式就是学习这些特定的符号；

字符类：

[abc] 所匹配的字符只能是a、b、c三个中的一个；

[^abc] 所匹配的字符只要是除了 a、b 或 c以外任何一个字符都可以；

[a-zA-Z] 所匹配的字符可以是a到z或A到Z中任意一个字符；

[a-d[m-p]] 所匹配的字符只能是a到d或m到p中的任意一个字符（取交集）；

[a-z&&[def]] 所匹配的字符只能是d、e 或 f中的任意一个字符（交集）

[a-z&&[^bc]] 所匹配的字符可以是除了b和c 以外，a到z范围内的任意一个字符；

[a-z&&[^m-p]] 所匹配的字符可以是除了[m-p]以外a到z范围内的任意一个字符；

预定义字符类----在正则表达式中\出现必须成对的出现，否则单个的\会将后面的字母转义

. 代表任何字符

\d 代表数字：[0-9]

\D 代表非数字：[^0-9]

\s 代表空白字符：[ \t\n\x0B\f\r]

\S 代表非空白字符：[^\s]

\w 代表单词字符：[a-zA-Z_0-9]

\W 代表非单词字符：[^\w]

Greedy数量词---规则出现的次数！

X? X出现一次或一次也没有

X* X出现零次或多次

X+ X出现一次或多次

X{n} X出现恰好 n 次

X{n,} X出现至少 n 次

X{n,m} X出现至少 n 次，最多出现m次

单词边界的概念：

\b 单词边界

String regex = “\\b[a-z]{3}\\b”; 他所匹配的是长度为3的单个独立单词！

组的概念：

为了将一个不确定的字符再一次进行引用，可以通过“（）”将其扩起来，这样他就可以被再一次的引用，

而且每一个组他都有一个自己的编号（从1开始），然后通过\编号来引用，如果想要多次引用，可以通过：

\编号+的形式！

((( ))( ))：对于这样一个复杂的由多个括号形成的多个组的混杂体，他有几个组，就看他有几个左括号，

左括号从左往右依次是1、2、3……组！

正则表达式的弊端：由于正则表达式是由许多特定符号组成的，所以它的阅读性极差！

正则表达式的具体功能：

匹配：String类中的matches( )，用规则匹配整个字符串，只要有一处不符合规则，

匹配就结束，然后返回false；

切割：通过split（regex）将一个字符串切割成一个字符数组；

技巧：1.按照多个空格来切：String regex = “ +”；

2.按照\\来切：String regex = “\\\\”；

3.按照叠词来切：String regex = “（.）\\1+”;

替换：通过replaceAll（String regex， String str）:将字符串中所有符合正则表达式规则的字符子串

全部替换为传入的字符串；

在替换中可以通过“$编号”获取正则表达式中特定组！

获取：将符合规则的子串取出！

操作步骤：

a.将正则表达式装成对象；

Pattern a=Pattern.compile(regex);

b.让正则对象与要操作的字符串相关联；

Matcher m =p.matcher(str);

c.关联后，获取正则匹配引擎；

d.通过引擎对符合规则的子串进行操作，比如取出;

boolean b =m.find( );

String s = m.group( ); //该操作是获取匹配过的符合规则的字符串，所以

//在调用该方法之前，必须保证对字符串进行过匹

//配操作，比如：find( ),否则会报无效状态异常！

常见的操作格式如下：

while( m.find( ) ){

String s =m.group( );

System.out.println(s);

} //这个操作有点类似于迭代器的迭代取出操作！

String类中的matches(),replaceAll()等方法实际上就是用了匹配引擎中的相应的方法！

迪兰奇迹

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员--字符串篇

字符串----------------------------------------------------------------------------------------------------------------------String概述：String代表字符串，字符串是一个特殊的对象，字符串是常量；它们的值在创建之后不能更改，也正是因为 String 对象是不可变的，
复制链接

扫一扫