黑马程序员（Java）----API之常用类（StringBuffer、Integer、Character）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

4.4 StringBuffer

4.4.1 了解StringBuffer

SringBuffer：线程安全的可变字符串。跟String相比，使用StringBuffer做字符串的拼接不会浪费太多资源。

4.4.2 构造方法

public StringBuffer():无参构造方法

public StringBuffer(int capacity):指定容量的字符串缓冲区对象

public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

两个常见的方法：

public int capacity()：返回当前容量。理论值

public int length():返回长度（字符数）。 实际值

public class StringBufferDemo {
	public static void main(String[] args) {
		// public StringBuffer():无参构造方法
		StringBuffer sb = new StringBuffer();
		System.out.println("sb:" + sb);
		System.out.println("sb.length():" + sb.length());
		System.out.println("sb.capacity():" + sb.capacity());
		System.out.println("-----------------");
		//public StringBuffer(int capacity):指定容量的字符串缓冲区对象
		StringBuffer sb2 = new StringBuffer(50);
		System.out.println("sb2:" + sb2);
		System.out.println("sb2.length():" + sb2.length());
		System.out.println("sb2.capacity():" + sb2.capacity());
		System.out.println("-----------------");
		//public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
		StringBuffer sb3 = new StringBuffer("hello");
		System.out.println("sb3:" + sb3);
		System.out.println("sb3.length():" + sb3.length());
		System.out.println("sb3.capacity():" + sb3.capacity());
	}
}

运行结果：

4.4.3 部分方法

1、添加功能

public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身,这里用String类型举例

public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身，这里用String类型举例

public class StringDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();

		// public StringBuffer append(String str)
		// StringBuffer sb2 = sb.append("hello");

		// System.out.println("sb:" + sb);
		// System.out.println("sb2:" + sb2);

		/*
		 * sb.append("hello");
		 * sb.append(true);
		 * sb.append(123);
		 */

		// 链式编程
		sb.append("hello").append(true).append(123);
		System.out.println("sb:" + sb);

		// public StringBuffer insert(int offset,String
		// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身，这里用String类型举例
		sb.insert(5, "world");
		System.out.println("sb:" + sb);

	}
}

运行结果：

2、删除功能

public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身

public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身。包含上边界，不包含下边界

public class StringDemo {
	public static void main(String[] args) {

		StringBuffer sb = new StringBuffer();
		//添加功能
		sb.append("hello").append("world").append("java");
		System.out.println("sb:" + sb);
		//public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
		//需求：我要删除“e”这个字符
		sb.deleteCharAt(1);
		System.out.println("sb:" + sb);
		//public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
		//包含上边界，不包含下边界。
		//需求：我要删除“world”这个字符串
		sb.delete(4, 9);
		System.out.println("sb:" + sb);

	}
}

运行结果：

3、替换功能

public StringBuffer replace(int start,int end,String str):从start开始到end用str替换

public class StringDemo {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		// 添加数据
		sb.append("hello").append("world").append("java");
		System.out.println("sb:" + sb);

		// public StringBuffer replace(int start,int end,String
		// str):从start开始到end用str替换
		// 需求：把“world”替换为“节日快乐”
		sb.replace(5, 10, "节日快乐");
		System.out.println("sb:" + sb);
	}
}

运行结果：

4、反转功能

public StringBuffer reverse()

public class StringDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		// 添加数据
		sb.append("我爱avaJ");
		System.out.println("sb:" + sb);
		sb.reverse();
		System.out.println("sb:" + sb);
	}
}

运行结果：

5、截取功能

public String substring(int start)

public String substring(int start,int end)

public class StringDemo {
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		//添加元素
		sb.append("hello").append("world").append("java");
		System.out.println("sb:"+sb);
		//截取功能
		//public String substring(int start)
		String s = sb.substring(5);
		System.out.println("s:"+s);
		System.out.println("sb:"+sb);

		//public String substring(int start,int end)
		String ss = sb.substring(5,10);
		System.out.println("ss:"+ss);
		System.out.println("sb:"+sb);
	}
}

运行结果：

6、StringBuffer练习题

练习1：String和StringBuffer的互相转换

public class StringBufferTest {
	public static void main(String[] args) {
		// 将String转为StringBuffer
		String s = "hello";
		// 方式1：通过构造方法
		StringBuffer sb = new StringBuffer(s);
		System.out.println("sb:" + sb);
		// 方式2：通过append()方法
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		System.out.println("sb2:" + sb2);
		System.out.println("------------");

		// 将StringBuffer转为String
		StringBuffer buffer = new StringBuffer("java");
		// 方式1：通过构造方法
		String str = new String(buffer);
		System.out.println("str:" + str);
		// 方式2：通过toString()方法
		String str2 = buffer.toString();
		System.out.println("str2:" + str2);
	}
}

运行结果：

练习2：把数组拼接成一个字符串

public class StringBufferTest2 {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 44, 33, 22, 11 };

		// 定义功能
		// 方式1：用String拼接的方法
		String s1 = arrayToString(arr);
		System.out.println("s1:" + s1);
		// 方式2：用StringBuffer拼接的方法
		StringBuffer s2 = arrayToStringBuffer(arr);
		System.out.println("s2:" + s2);

	}

	// 用StringBuffer做拼接
	public static StringBuffer arrayToStringBuffer(int[] arr) {
		StringBuffer sb = new StringBuffer();
		sb.append("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				sb.append(arr[x]).append("]");
			} else {
				sb.append(arr[x]).append(", ");
			}
		}
		return sb;
	}

	// 用String做拼接
	public static String arrayToString(int[] arr) {
		String s = "";
		s += "[";
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				s += arr[x];
				s += "]";
			} else {
				s += arr[x];
				s += ", ";
			}
		}
		return s;
	}
}

运行结果：

练习3：字符串反转

public class StringTest3 {
	public static void main(String[] args) {
		// 键盘录入数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		// 方式1：用String做反转拼接
		String s1 = myReverse(s);
		System.out.println("s1:"+s1);
		// 方式2：用StringBuffer做反转
		String s2 = myReverse2(s);
		System.out.println("s2:"+s2);
	}
	//用StringBuffer做反转
	public static String myReverse2(String s){
		/*StringBuffer sb = new StringBuffer(s);
		sb.reverse();
		return sb.toString();*/
		//简易版
		return new StringBuffer(s).reverse().toString();
	}
	//用String做反转拼接
	public static String myReverse(String s) {
		String str = "";
		char[] chs = s.toCharArray();
		for (int x = chs.length - 1; x >= 0; x--) {
			str+=chs[x];
		}
		return str;
	}

}

运行结果：

练习4：判断一个字符串是否对称

/*
 * 判断一个字符串是否是对称字符串
 * 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
 *
 * 分析：
 * 		判断一个字符串是否是对称的字符串，我只需要把
 * 			第一个和最后一个比较
 * 			第二个和倒数第二个比较
 * 			...
 * 		比较的次数是长度除以2。
 */
import java.util.Scanner;

public class StringBufferTest4 {
	public static void main(String[] args) {
		// 创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入需要判断的字符串:");
		String s = sc.nextLine();
		boolean b1 = isSym(s);
		System.out.println("b1:" + b1);
		boolean b2 = isSym(s);
		System.out.println("b2:" + b2);
		boolean b3 = isSym(s);
		System.out.println("b3:" + b3);

	}

	public static boolean isSym(String s) {
		// 把字符串转成字符数组
		char[] chs = s.toCharArray();
		for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
			if (chs[start] != chs[end]) {
				return false;
			}
		}
		return true;
	}

	public static boolean isSym2(String s) {
		boolean flag = true;
		// 把字符串转成字符数组
		char[] chs = s.toCharArray();
		for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
			if (chs[start] != chs[end]) {
				flag = false;
				break;
			}
		}
		return flag;
	}
	public static boolean isSym3(String s){
		return new StringBuffer(s).reverse().toString().equals(s);
	}
}

运行结果：

7、面试题

面试题1：String,StringBuffer,StringBuilder的区别

1）String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。

2）StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高

面试题2：StringBuffer和数组的区别

1）二者都可以看出是一个容器，装其他的数据。

2）StringBuffer的数据最终是一个字符串数据；而数组可以放置多种数据，但必须是同一种数据类型的。

面试题3：String作为参数传递，StringBuffer作为参数传递

看程序，写结果

public class StringBufferDemo {
	public static void main(String[] args) {
		String s1 = "hello";
		String s2 = "world";
		System.out.println(s1 + "---" + s2);
		change(s1, s2);
		System.out.println(s1 + "---" + s2);

		StringBuffer sb1 = new StringBuffer("hello");
		StringBuffer sb2 = new StringBuffer("world");
		System.out.println(sb1 + "---" + sb2);
		change(sb1, sb2);
		System.out.println(sb1 + "---" + sb2);

	}

	public static void change(StringBuffer sb1, StringBuffer sb2) {
		sb1 = sb2;
		sb2.append(sb1);
	}

	public static void change(String s1, String s2) {
		s1 = s2;
		s2 = s1 + s2;
	}
}

运行结果：

分析：形式参数为基本数据类型时，形式参数的改变不影响实际参数；为引用类型数据时，形式参数的改变直接影响实际参数。String是引用类型，但是它作为参数传递时，效果和基本数据类型是一样的。StringBuffer作为参数传递时，调用方法时情况和引用类型是一样的，但是赋值时和基本数据类型是一样的。

4.5 Integer

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

4.5.1 构造方法

/*
 * public Integer(int value)
 * public Integer(String s)
 * 		注意：这个字符串必须是由数字字符组成
 */
public class IntegerDemo {
	public static void main(String[] args) {
		// 方式1：
		int i = 100;
		Integer ii = new Integer(i);
		System.out.println("ii:" + ii);

		//方式2：
		String s =  "100";
		Integer iii = new Integer(s);
		System.out.println("iii:"+iii);
	}
}

运行结果：

4.5.2  部分成员方法

1、int类型和String类型的互相转换

/*
* int类型和String类型的相互转换
*
* int -- String
* 		String.valueOf(number)
*
* String -- int
* 		Integer.parseInt(s)
*/
public class IntegerDemo {
	public static void main(String[] args) {
		// int --> String
		int number = 100;
		// 方式1
		String s1 = "" + number;
		System.out.println("s1:" + s1);
		// 方式2
		String s2 = String.valueOf(number);
		System.out.println("s2:" + s2);
		// 方式3
		// int --> Integer --> String
		Integer i = new Integer(number);
		String s3 = i.toString();
		System.out.println("s3:" + s3);
		// 方式4
		// public static String toString(int i)
		String s4 = Integer.toString(number);
		System.out.println("s4:" + s4);
		System.out.println("-------------");
		//String --> int
		String s = "100";
		//方式1
		//String --> Integer --> Int
		Integer ii = new Integer(s);
		//public int intValue()
		int x1 =	ii.intValue();
		System.out.println("x1:"+x1);
		//方式2
		int x2 = Integer.parseInt(s);
		System.out.println("x2:"+x2);
	}
}

运行结果：

2、十进制和其他进制之间的互相转换

/*
 * 常用的基本进制转换
 * public static String toBinaryString(int i)
 * public static String toOctalString(int i)
 * public static String toHexString(int i)
 *
 * 十进制到其他进制
 * public static String toString(int i,int radix)
 * 由这个我们也看到了进制的范围：2-36
 * 为什么呢?0,...9,a...z
 *
 * 其他进制到十进制
 * public static int parseInt(String s,int radix)
 */
public class IntegerDemo {
	public static void main(String[] args) {
		// 十进制到二进制，八进制，十六进制
		System.out.println(Integer.toBinaryString(100));
		System.out.println(Integer.toOctalString(100));
		System.out.println(Integer.toHexString(100));
		System.out.println("-------------------------");

		// 十进制到其他进制
		System.out.println(Integer.toString(100, 5));
		System.out.println(Integer.toString(100, 37));
		System.out.println(Integer.toString(100, 36));
		System.out.println("-------------------------");

		// 其他进制到十进制
		System.out.println(Integer.parseInt("100", 10));
		System.out.println(Integer.parseInt("100", 2));
		System.out.println(Integer.parseInt("100", 8));
		System.out.println(Integer.parseInt("100", 16));
		System.out.println(Integer.parseInt("100", 23));
	}
}

运行结果：

4.5.3 JDK1.5新特性：自动装箱和拆箱

自动装箱：把基本类型自动转换为包装类类型

自动拆箱：把包装类类型自动转换为基本类型

public class IntegerDemo {
	public static void main(String[] args) {
		// 定义了一个int类型的包装类类型变量i
		// Integer i = new Integer(100);
		Integer ii = 100;
		ii += 200;
		System.out.println("ii:" + ii);
	}
}

运行结果：

为什么将基本数据类型100赋值给引用数据类型ii不报错呢？还有，将200和ii相加后赋值给ii，为啥也不报错呢？

因为在JDK1.5以后，出现了自动装箱和自动拆箱的功能。反编译上面的class文件，得到：

Integer ii = Integer.valueOf(100); //自动装箱
ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
System.out.println((new StringBuilder("ii:")).append(ii).toString());

对比源代码和反编译出来的代码，可以看出来编译器对代码进行了自动装箱和自动拆箱。

注意：在使用时，Integer  x = null;代码就会出现NullPointerException。建议先判断是否为null，然后再使用。

面试题：看程序写结果

/*
 * 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
 */
public class IntegerDemo {
	public static void main(String[] args) {
		Integer i1 = 128;
		Integer i2 = 128;
		System.out.println(i1 == i2);
		System.out.println(i1.equals(i2));
		System.out.println("-----------");

		Integer i3 = 127;
		Integer i4 = 127;
		System.out.println(i3 == i4);
		System.out.println(i3.equals(i4));
	}
}

运行结果：

原因分析：Integer类复写了equals()方法，使其用来比较字面值。但是 == 用来比较地址值，为什么将128和127赋值给Integer类的对象时，情况不一样呢？由于在使用Integer  i = 127和Integer  i = 127时，编译器会自动装箱，即调用Integer类的valueOf(int i)方法，通过查看valueOf(int i)的源码，知道了Java针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间，即地址值相同。

4.6 Character

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

/*
<pre name="code" class="java" style="font-size: 18px;">* 构造方法：<span style="font-family: Arial, Helvetica, sans-serif;">Character(char value)：构造一个新分配的 Character 对象，用以表示指定的 char 值。 </span>

*/public class CharacterDemo {public static void main(String[] args) {// 创建对象Character ch = new Character(‘a‘);System.out.println("ch:" + ch);}}



运行结果：




/*
 * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
 * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
 * public static boolean isDigit(char ch):判断给定的字符是否是数字字符
 * public static char toUpperCase(char ch):把给定的字符转换为大写字符
 * public static char toLowerCase(char ch):把给定的字符转换为小写字符
 */
public class CharacterDemo {
	public static void main(String[] args) {
		//public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		//public static boolean isDigit(char ch):判断给定的字符是否是数字字符
		System.out.println("isDigit:"+Character.isDigit('0'));
		System.out.println("--------------");
		//public static char toUpperCase(char ch):把给定的字符转换为大写字符
		System.out.println("toUpperCase:"+Character.toUpperCase('a'));
		//public static char toLowerCase(char ch):把给定的字符转换为小写字符
		System.out.println("toUpperCase:"+Character.toLowerCase('A'));
	}
}


运行结果：




版权声明：本文为博主原创文章，未经博主允许不得转载。
				


				
时间： 2024-10-13 04:47:34 

		


		


	

	
	

		


		
黑马程序员（Java）----API之常用类（StringBuffer、Integer、Character）的相关文章


						

		

			

                黑马程序员——Java基础---反射Class类、Constructor类、Field类
			

		

		

									

				------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 反射的应用场景 一.概述 反射技术: Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类中的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的			

		

	

				

		

			

                黑马程序员--java基础之其他类
			

		

		

									

				-------android培训.java培训.期待与您交流! ---------- Java基础中的其他对象:System 关于System类的用法: /* System:类中的方法和属性都是静态的 out:标准输出,默认是控制台 in:标准输入,默认是键盘 获取系统属性信息:Properties getProperties(); */ import java.util.*; class SystemDemo { public static void main(String[] args) {			

		

	

				

		

			

                黑马程序员----java基础：String与StringBuffer及基本数据类型包装类
			

		

		

									

				java中一些基础类比如String.StringBuffer和基本数据类型包装类都是非常常见且使用非常频繁的类.这些类虽然简单,但是想要熟练使用也必须要学习,虽然API文档对这些类的用法都讲的比较详细,但是我觉得还是有必要再整理一下. 一.String类 1.概述 String就是字符串的意思,首先要明确一点的是String并不属于基本数据类型. 因为对象的默认值是null,所以String的默认值也是null:但它又是一种特殊的对象,有其它对象没有的一些特性. 注意new String()			

		

	

				

		

			

                黑马程序员-Java基础之String与StringBuffer
			

		

		

									

				String与StringBuffer < java.lang >-- String字符串 java中用String类进行描述.对字符串进行了对象的封装.这样的好处是可以对字符串这种常见数据进行方便的操作.对象封装后,可以定义N多属性和行为. 如何定义字符串对象呢?String s = "abc";只要是双引号引起的数据都是字符串对象. 特点:字符串一旦被初始化,就不可以被改变,存放在方法区中的常量池中. ----------------------------------			

		

	

				

		

			

                黑马程序员——Java基础---集合框架工具类
			

		

		

									

				黑马程序员——Java基础<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java为操作Set.List和Map提供了一系列工具类,主要有Collections和Arrays.这两个工具类的特点:类中的方法都是静态的,不需要创建对象,直接使用类名调用即可.Collections:是集合对象			

		

	

				

		

			

                黑马程序员——Java I/O流基础知识点（File类）
			

		

		

									

				File工具 File类就是用俩将文件或者文件夹封装对象,弥补流对象的不足--流只能操作数据,不能操作文件夹的 封装的是路径!!! 构造方法演示 1.可以将已有的未出现的文件或者文件夹封装成对象. File f1=new File("c:\\abc\\a.txt"): File f2=new File("d:\\abc","ab.txt"打印,会打印路径.:目录分隔符,为了更好地跨平台File. File类常见功能 1,创建 createNewF			

		

	

				

		

			

                黑马程序员——Java集合工具类和泛型
			

		

		

									

				Collections工具类和泛型 Collections和Collection Collections和Collection是不同的,Collections是工具类,用来操作集合的,而Collection是集合接口.Collections中有一系列的静态方法用来操作集合,但是不能更改集合内容.比如不能set()不能remove()元素,可以替换全部元素或者添加同一个元素. static List<String> list =Arrays .asList("one Two three			

		

	

				

		

			

                黑马程序员——Java基础---IO(下)
			

		

		

									

				黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正			

		

	

				

		

			

                黑马程序员——java基础---IO(input output)流字符流
			

		

		

									

				黑马程序员——java基础---IO(input output)流字符流 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- io(input output)流特点: 1,io流用来处理数据之间的传输 2,java对数据的操作是通过流的方式: 3,java用于操作流的对象都在io包中: 4,流按操作数据分为两种:字节流和字符流: 5,流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象			

		

	

				

		

			

                黑马程序员---Java多线程
			

		

		

									

				---------------------- Android开发.java培训.期待与您交流! ---------------------- 线程与进程是程序运行中体现的两个名词,它包含这不同的程序域.进程指的是一个正在运行的程序,如:360,QQ运行时就是不同的两个进程.当你打开windows任务管理器时,看到的每个进程就是此时windows中正在运行的程序.线程则就是进程中的一个个独立的控制单元,线程控制着进程的执行,也就是说每个正在运行的程序中就包括着很多的线程. 主线程:Java虚拟机运