黑马程序员——【学习笔记】集合——String、StringBuffer 以及集合

最新推荐文章于 2021-04-11 22:39:59 发布

oChuXinZhe

最新推荐文章于 2021-04-11 22:39:59 发布

阅读量453

点赞数

本文链接：https://blog.csdn.net/oChuXinZhe/article/details/49035927

版权

------- android培训、 java培训、期待与您交流！----------

1 String类的特点：

1.1 字符串对象一旦被初始化就不会被改变。

1.2 String覆写Object的equals方法，建立了String类自己的判断字符串对象是否相同的依据，之比较字符内容，不比较地址。

2 String类的构造函数：

2.1 String(bytes[] bytes)：通过使用平台的默认字符集解码指定的byte数组（不是获取数组内容，而是得出与数组元素相对应的解码），再组成一个新的String。

注意比如

byte[] i1 = {65,66,67,68};

String s2 = new String(i1);

它与String s3 = "ABCD";是不同的，但是内容相同。即==为false，equals为true

2.2 String(char[] value)

可以转化char[]的元素为字符串

2.3 String(char[] value, int offfset, int count)

可以转化char[]中从特定角标offset开始count位的元素为字符串。

char[] c = {‘2’,’d’,’r’,’h’,’t’}

String s = new String(c,0, 3)就是从角标为0开始获取3位数来转化，得到String的内容为2dr

3 String类的方法

int length(); 获取长度

char charAt(int index); 根据位置获取字符

int indexOf(int ch); 查找某个字符/数字第一次出现的角标。用int输入是因为参数类型int既可以支持字符，又可以支持字符中对应的数字。

int indexOf(int ch,int fromIndex); 查找从指定位置开始ch第一次出现的位置

int indexOf(String s ) 同理，查找指定字符串在已知字符串中的指定位置

int indexOf(String s , int fromIndex) 同理，从特定位置开始，查找指定字符串在已知字符串中的指定位置

int lastIndexOf(int ch)

int lastIndexOf(int ch,int fromIndex)

int lastIndexOf(String s)

int lastIndexOf(String s, int fromIndex) 根据字符/字符串在已知字符串中找出倒数第一次出现的角标（或从指定角标开始倒数）

以上字符角标的获取方法，都可以根据输出-1来判断字符串中不存在这个“目标”。

String[] split(String regex); 根据正则表达式规则分割字符串并生成到集合里。注意正则表达式里的特殊字符需要转义。

char[] toCharArray(); 讲字符串变成字符数组。

byte[] getBytes(); 将字符串变成字节数组。

String toUpperCase(); 将字符串中的字母转换大小写

String toLowerCase();

String replace(char oldCh,char newCh); 字符替换，如果没有找到要替换的内容，则不执行替换，返回原串

String replace(String oldStr,String newStr); 字符串替换。如果没有找到要替换的内容，则不执行替换，返回原串

String trim(); 去除字符串两端空格

String concat(String str); 将两个数组连起来，与+的效果相同。

String String.valueOf(int x); 将其它类型数据转换成字符串

boolean equals(String s); 判断两个字符串内容是否相同

boolean equalsIgnoreCase(String str); 忽略大小写比较字符串内容

boolean contains(String str); 判断字符串中是否包含指定字符串

boolean startWith(String str); 判断字符串是否以指定字符串为开头/结尾

boolean endWith(String str);

int compareTo(String str); 如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值，如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。小写比大写大

String intern(); 当调用intern方法时，先检查常量池，如果常量池一斤更包含一个等于此String对象的字符串，则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。

4 length，length()的区别：

length是一个属性，是数组的属性，比如String[] s={“sfs”,”gsdf”,”dfsa”,”dwee”}就可以s.length来查看它的长度属性

length()是一个方法，用于字符串调用来查看字符串长度。为什么要用方法，是因为字符串本身没有“长度”这个属性，需要调用方法获取。比如String s = “adfad”，查看要用s.length()

PS. 以后还会有一个size()，这是针对泛型集合来说的，可以查看这个泛型有多少个元素。比如List<Object> array = new ArrayList();

array.add(a);

array.size();获取长度。

5 String方法的一些使用示例：

示例一：

给定一个字符串数组，按照字典顺序进行从小到大的排序。
{"nba","abc","cba","zz","qq","haha"}

思路：

使用String类中的提供用于字符串比较的compareTo()方法来比较大小，

以此对数组进行排序。

public class Day15{
	public static void main(String[] args){
		String[] s = {"nba","abc","cba","zz","qq","haha"};
		printString(s);
		sortString(s);
		printString(s);
	}
	static void swap(String[] str,int x,int y){
		String s = str[x];
		str[x] = str[y];
		str[y] = s;
	}
	static void sortString(String[] str){	
		for(int x=0; x<str.length; x++){
			int  temp=x;
			String stemp=str[x];
			for (int y=x+1;y<str.length;y++){
				if(str[y].compareTo(stemp)<0){
					stemp=str[y];
					temp = y;	}
			}
			
			if(temp!=x)
					swap(str,temp,x);
		}
	}
	static void printString(String[] str){
		System.out.print("[");
				for(String s:str){
			System.out.print(s+",");
		}
		System.out.println("\b]");
	}
}

示例二：

一个子串在整串中出现的次数 "nbaernbatynbauinbaopnba" 子串为"nba"

思路：

字符串有搜索字符串的功能IndexOf(String str);用其获取子串的位置，如果输出-1，则结束.

返回位置后IndexOf(String str,int fromIndex)，用途int count记录，并从此字符位置+子串长度开始再搜索。

class Day15{
	public static void main(String[] args){
		String s = "nbaernbatynbauinbaopnba";
		String key = "nba";
		System.out.println(findString(s,key));
	}
	static int findString(String s,String key){
		//定义计数器
		int count = 0;
		//循环查找
		int num = 0;
		while (s.indexOf(key,num)!=-1){
			count++;
			num=s.indexOf(key,num)+key.length();
			System.out.println(num);
		}
		return count;
	}	
}

6 StringBuffer

StringBuffer就是字符串缓冲区，用于存储数据的容器。

6.1 StringBuffer的特点：

①长度是可变的。其缓冲区初始化容量为16个字符。因为其有长度属性，所以实质还是数组。当增加的内容超过了16个字符，则自动增加容量。但是用时是按照String来使用。

②可以存储不同类型数据。

③最终要转成字符串进行使用及操作。所以我们每次输出字符缓冲对象，都是以输出String一样的表现形式。以及使用length()方法来获取长度而不是用xxx.length获取

6.2 StringBuffer字符串缓冲区的四大功能：增删改查

6.2.1 增——添加

StringBuffer append(data);在字符串末端增加数据

StringBuffer insert(index,data);从指定角标插入数据，

public class Day15{
	public static void main(String[] args){
		StringBuffer sb1 = new StringBuffer();
		sb1.append("a");
		System.out.println(sb1);
		StringBuffer sb2 = sb1.append("bcd");
		System.out.println("sb1..."+sb1);
		System.out.println("sb2..."+sb2);
		System.out.println(sb1==sb2);
		System.out.println("------------------------");
		sb2 = sb2.append(" ");
		System.out.println(sb1.append("efgh"));
		System.out.println(sb2.append("efgh"));
		System.out.println(sb1==sb2);
		System.out.println(sb1.equals(sb2));
		System.out.println(sb1);
		System.out.println("------------------------");
		StringBuffer sb3 = new StringBuffer();
		sb3.append("abcd efghefgh");
		System.out.println(sb3==sb2);
		System.out.println(sb3.equals(sb2));
	}
}

注意输出

第二部分输出显示不管是操作sb1还是sb2，最终两者总是相等，从==判断也可知他们是指向同一个对象。

这是因为StringBuffer sb2 = sb1.append("bcd");实际上执行了两个：首先，sb1增加了bcd字符串，然后把sb1的指向对象的地址赋予sb2。

这样sb1和sb2的变量实际上指向的是同一个对象。所以不论操作sb1还是sb2实际都是操作那个对象。

而从第三部分输出可以看出当我们StringBuffer sb3 = new StringBuffer();，即new了一个字符缓冲区之后，sb2和sb3的==和equals判断都为false，说明他们不是同一个对象。

6.2.2 删——删除

StringBuffer delete(int start, int end);包含头，不含尾。

StringBuffer deleteCharAt(int index);删除指定位置的元素。

class Day15{
	public static void main(String[] args){
		StringBuffer sb=new StringBuffer("abcdefgh");
		sb.delete(1, 2);
		System.out.println(sb);
		sb.deleteCharAt(1);
		System.out.println(sb);
		sb.delete(0, sb.length());
		System.out.println("-"+sb+"-");
	}
}

acdefgh
adefgh
--

6.2.3 改——修改

StringBuffer replace(int start,int end,String str);将指定角标的字符串（包含start，不含end）用参数内的字符串来替换。

void setCharAt(int index,char ch);将指定角标的字符改为参数里的字符。注意setCharAt()没有返回，不能用StringBuffer来接受。所以建议用replace

6.2.4 查——查找

char charAt(index);查找指定角标的字符。没有返回。

int indexOf(String str); 从开头查找指定字符串的位置。

int lastIndexOf(String str);从结尾开始查找指定字符串的位置。

class Day15{
	public static void main(String[] args){
		StringBuffer sb=new StringBuffer("abcdefgh");
		sb.delete(1, 2);
		<span style="white-space:pre">	</span>System.out.println(sb);
		sb.deleteCharAt(1);
		<span style="white-space:pre">	</span>System.out.println(sb);
//		sb.delete(0, sb.length());
//		<span style="white-space:pre">	</span>System.out.println("-"+sb+"-");
		sb.replace(0,1,"hahaha");
		<span style="white-space:pre">	</span>System.out.println(sb);
		sb.setCharAt(1, '1');
//		StringBuffer sb1 = sb.setCharAt(1, "3");
		<span style="white-space:pre">	</span>System.out.println(sb);
		char c = sb.charAt(3);
		<span style="white-space:pre">	</span>System.out.println(c);
		String s = "sfafdsfas";
		String s1 = s.concat("ddd"); //注意String类型的concat()方法与字符缓冲去的append，insert方法的区别。String增加完之后必须有变量去接收。
		<span style="white-space:pre">	</span>System.out.println(s1);
		int i = sb.indexOf("ha");
		<span style="white-space:pre">	</span>System.out.println(i);
		int i1 = sb.lastIndexOf("ha");
		<span style="white-space:pre">	</span>System.out.println(i1);
	}
}

acdefgh
adefgh
hahahadefgh
h1hahadefgh
a
sfafdsfasddd
2
4

PS. 同样是增加数据，程序里注意区分String的concat方法和StringBuffer的append、insert方法的区别：

即String类使用完concat之后必须要有String来接受数据，否则报错；而StringBuffer是不用的。原因是String在增加字符串后是在常量池生成一个新的字符串，如果没有String对象来接收，这个新建的字符串将毫无意义。

但是StringBuffer增加字符串是直接在原缓冲区创建一个新长度的字符串数组，然后把原来的内容复制过去，再在后面加上添加的内容。并不产生新的字符缓冲区。所以可以不同声明StringBuffer来接收，仍然有效。

长度变化是：原长度*2+2

用capacity()方法可以判断容量。

6.3 StringBuffer的其它功能的介绍：

void setLength(int newLength);设置字符缓冲区字符序列的长度。如果记录的原字符串长度大于设定的字符长度，则多余的会抛弃，但设定的容量长度不会限制后续的输入。一个中文算一个长度单位。

public StringBuffer reverse();将字符序列用其翻转形式取代。

用构造函数StringBuffer(int capacity)可以将该缓冲区字符序列的容量初始化。

public class Day15{
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer("测试abcd");
		sb.setLength(3);
			System.out.println(sb);
		sb.setLength(5);
			System.out.println(sb);
		sb.insert(sb.length()-1, "测试");
			System.out.println(sb);
			System.out.println(sb.length());
		sb.reverse();
			System.out.println(sb);
	}
}

测试a
测试a
测试a 测试
7
试测 a试测

7 StringBuilder

StringBuilder是一个功能与StringBuffer一模一样的缓冲器。

与StringBuffer的区别是：

StringBuffer是线程同步的，通常用于多线程。

StringBuilder是线程不同步的，通常用于单线程，它的出现能够提高单线程程序效率。

所以StringBuilder用于多线程是不同步的，多线程需要使用StringBuffer

8 集合。

8.1 基本数据类型对象包装类

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

byte——Byte

short——Short

int——Integer

long——Long

float——Float

double——Double

char——Character

boolean——Boolean

该包装对象主要用于基本类型和字符串之间的转换。

①基本类型转化为字符串：

基本类型数值+“”

用String类中的静态方法valueOf(基本数据类型值)

②字符串转化为基本数据类型

使用包装类中的经他方法xxx parseXxx(String str)

int parseInt(String str)

long parseLong(String str)

boolean parseBoolean(String str)

只有Character没有parse方法

如果字符串被Inter进行对象的封装，可使用另一个非静态的方法，intValue：将一个Integer对象转成基本数据类型值。

用Integer的静态方法valueOf(String s);

public class Day15{
	public static void main(String[] args){
		String s  =String.valueOf('c');
		System.out.println(s);
		
		String s1 = 'c'+"";
		System.out.println(s1);
//		int i = Integer.parseInt("z");//注意不能放错误的类型，
//		System.out.println(i);
		boolean b = Boolean.parseBoolean("True");
		System.out.println(b);
		int i = Integer.valueOf("123");
		System.out.println(i);
	}
}

8.2 进制转换

十进制转换到其它进制：

String toBinaryString(int i);

String toOctalString(int i);

String toHexString(int i);

String toString（int i,int radix);

其它进制转换成十进制：

int parseInt(String s,int radix);注意，十进制转成其它进制是输出String的，所以其它进制也应该是以String为参数输入方法

public class Day15{
	public static void main(String[] args){
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.toBinaryString(6));
		System.out.println(Integer.toOctalString(5));
		System.out.println(Integer.toHexString(60));
		System.out.println(Integer.toString(6,2));
		System.out.println(Integer.toString(60,8));
		System.out.println(Integer.toString(60,16));
		System.out.println(Integer.parseInt("3c",16));
	}
}

8.3 集合类与集合框架

8.3.1 我们直到对象用于封装特有数据，当对象多了，就需要存储。如果对象的个数不确定，就使用集合容器进行存储。

集合特点：

①用于存储对象的容器。

②集合的长度是可变的。PS：StringBuffer也是长度可变的。

③集合中不可以储存基本数据类型。PS：StringBuffer可以储存基本类型，而且可以储存不同类型。

所以，储存基本类型用StringBuffer，储存其它类型用集合类。

PS：数组和集合类同是容器，有何不同？

①数组虽然也可以寸处对象，但长度是固定的，集合长度是可变的。

②数组中可以存储基本数据类型，集合只能寸处对象。

8.3.2 集合容器因为内部的数据结构不同，有很多种具体容器，不断地向上抽取，就形成了集合框架。

oChuXinZhe

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——【学习笔记】集合——String、StringBuffer 以及集合

1 String类的特点：1.1 字符串对象一旦被初始化就不会被改变。1.2 String覆写Object的equals方法，建立了String类自己的判断字符串对象是否相同的依据，之比较字符内容，不比较地址。2 String类的构造函数：2.1 String(bytes[] bytes)：通过使用平台的默认字符集解码指定的byte数组（不是获取数组内容，而是得出与数组元素
复制链接

扫一扫