how2j.cn


工具版本兼容问题
StringBuffer第二道练习题答案

本视频是解读性视频,所以希望您已经看过了本知识点的内容,并且编写了相应的代码之后,带着疑问来观看,这样收获才多。 不建议一开始就观看视频



36分5秒
本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)



步骤 1 : IStringBuffer接口   
步骤 2 : value和capacity   
步骤 3 : 带参构造方法   
步骤 4 : 反转 reverse   
步骤 5 : 插入insert 和 append   
步骤 6 : 删除 delete   
步骤 7 : 练习-性能比较   
步骤 8 : 答案-性能比较   

步骤 1 :

IStringBuffer接口

package character; public interface IStringBuffer { public void append(String str); //追加字符串 public void append(char c); //追加字符 public void insert(int pos,char b); //指定位置插入字符 public void insert(int pos,String b); //指定位置插入字符串 public void delete(int start); //从开始位置删除剩下的 public void delete(int start,int end); //从开始位置删除结束位置-1 public void reverse(); //反转 public int length(); //返回长度 }
package character;
 
public interface IStringBuffer {
    public void append(String str); //追加字符串 
    public void append(char c);  //追加字符
    public void insert(int pos,char b); //指定位置插入字符
    public void insert(int pos,String b); //指定位置插入字符串
    public void delete(int start); //从开始位置删除剩下的
    public void delete(int start,int end); //从开始位置删除结束位置-1
    public void reverse(); //反转
    public int length(); //返回长度
}
步骤 2 :

value和capacity

value:用于存放字符数组
capacity: 容量
无参构造方法: 根据容量初始化value

public MyStringBuffer(){
value = new char[capacity];
}
package character; public class MyStringBuffer implements IStringBuffer{ int capacity = 16; int length = 0; char[] value; public MyStringBuffer(){ value = new char[capacity]; } @Override public void append(String str) { // TODO Auto-generated method stub } @Override public void append(char c) { // TODO Auto-generated method stub } @Override public void insert(int pos, char b) { // TODO Auto-generated method stub } @Override public void delete(int start) { // TODO Auto-generated method stub } @Override public void delete(int start, int end) { // TODO Auto-generated method stub } @Override public void reverse() { // TODO Auto-generated method stub } @Override public int length() { // TODO Auto-generated method stub return 0; } }
步骤 3 :

带参构造方法

package character; public class MyStringBuffer implements IStringBuffer{ int capacity = 16; int length = 0; char[] value; public MyStringBuffer(){ value = new char[capacity]; } //有参构造方法 public MyStringBuffer(String str){ if(null!=str) value =str.toCharArray(); length = value.length; if(capacity<value.length) capacity = value.length*2; } @Override public void append(String str) { // TODO Auto-generated method stub } @Override public void append(char c) { // TODO Auto-generated method stub } @Override public void insert(int pos, char b) { } @Override public void delete(int start) { // TODO Auto-generated method stub } @Override public void delete(int start, int end) { // TODO Auto-generated method stub } @Override public void reverse() { // TODO Auto-generated method stub } @Override public int length() { // TODO Auto-generated method stub return length; } @Override public void insert(int pos, String b) { } }
步骤 4 :

反转 reverse

package character; public class MyStringBuffer implements IStringBuffer { int capacity = 16; int length = 0; char[] value; public MyStringBuffer() { value = new char[capacity]; } // 有参构造方法 public MyStringBuffer(String str) { this(); if (null == str) return; if (capacity < str.length()) { capacity = value.length * 2; value = new char[capacity]; } if (capacity >= str.length()) System.arraycopy(str.toCharArray(), 0, value, 0, str.length()); length = str.length(); } @Override public void reverse() { for (int i = 0; i < length / 2; i++) { char temp = value[i]; value[i] = value[length - i - 1]; value[length - i - 1] = temp; } } @Override public void append(String str) { // TODO Auto-generated method stub } @Override public void append(char c) { // TODO Auto-generated method stub } @Override public void insert(int pos, char b) { // TODO Auto-generated method stub } @Override public void insert(int pos, String b) { // TODO Auto-generated method stub } @Override public void delete(int start) { // TODO Auto-generated method stub } @Override public void delete(int start, int end) { // TODO Auto-generated method stub } @Override public int length() { // TODO Auto-generated method stub return length; } public String toString() { char[] realValue = new char[length]; System.arraycopy(value, 0, realValue, 0, length); return new String(realValue); } public static void main(String[] args) { MyStringBuffer sb = new MyStringBuffer("there light"); sb.reverse(); System.out.println(sb); } }
步骤 5 :

插入insert 和 append

边界条件判断
插入之前,首先要判断的是一些边界条件。 比如插入位置是否合法,插入的字符串是否为空

扩容
1. 要判断是否需要扩容。 如果插入的字符串加上已经存在的内容的总长度超过了容量,那么就需要扩容。
2. 数组的长度是固定的,不能改变的,数组本身不支持扩容。 我们使用变通的方式来解决这个问题。
3. 根据需要插入的字符串的长度和已经存在的内容的长度,计算出一个新的容量。 然后根据这个容量,创建一个新的数组,接着把原来的数组的内容,复制到这个新的数组中来。并且让value这个引用,指向新的数组,从而达到扩容的效果。

插入字符串
1. 找到要插入字符串的位置,从这个位置开始,把原数据看成两段,把后半段向后挪动一个距离,这个距离刚好是插入字符串的长度
2. 然后把要插入的数据,插入这个挪出来的,刚刚好的位置里。

修改length的值
最后修改length的值,是原来的值加上插入字符串的长度

insert(int, char)
参数是字符的insert方法,通过调用insert(int, String) 也就实现了。

append
追加,就是在最后位置插入。 所以不需要单独开发方法,直接调用insert方法,就能达到最后位置插入的效果
package character; public class MyStringBuffer implements IStringBuffer{ int capacity = 16; int length = 0; char[] value; public MyStringBuffer(){ value = new char[capacity]; } //有参构造方法 public MyStringBuffer(String str){ this(); if(null==str) return; if(capacity<str.length()){ capacity = value.length*2; value=new char[capacity]; } if(capacity>=str.length()) System.arraycopy(str.toCharArray(), 0, value, 0, str.length()); length = str.length(); } @Override public void append(String str) { insert(length,str); } @Override public void append(char c) { append(String.valueOf(c)); } @Override public void insert(int pos, char b) { insert(pos,String.valueOf(b)); } @Override public void delete(int start) { // TODO Auto-generated method stub } @Override public void delete(int start, int end) { // TODO Auto-generated method stub } @Override public void reverse() { for (int i = 0; i < length/2; i++) { char temp = value[i]; value[i] = value[length-i-1]; value[length-i-1] = temp; } } @Override public int length() { // TODO Auto-generated method stub return length; } @Override public void insert(int pos, String b) { //边界条件判断 if(pos<0) return; if(pos>length) return; if(null==b) return; //扩容 while(length+b.length()>capacity){ capacity = (int) ((length+b.length())*1.5f); char[] newValue = new char[capacity]; System.arraycopy(value, 0, newValue, 0, length); value = newValue; } char[] cs = b.toCharArray(); //先把已经存在的数据往后移 System.arraycopy(value, pos, value,pos+ cs.length, length-pos); //把要插入的数据插入到指定位置 System.arraycopy(cs, 0, value, pos, cs.length); length = length+cs.length; } public String toString(){ char[] realValue = new char[length]; System.arraycopy(value, 0, realValue, 0, length); return new String(realValue); } public static void main(String[] args) { MyStringBuffer sb = new MyStringBuffer("there light"); System.out.println(sb); sb.insert(0, "let "); System.out.println(sb); sb.insert(10, "be "); System.out.println(sb); sb.insert(0, "God Say:"); System.out.println(sb); sb.append("!"); System.out.println(sb); sb.append('?'); System.out.println(sb); sb.reverse(); System.out.println(sb); } }
步骤 6 :

删除 delete

删除 delete
package character; public class MyStringBuffer implements IStringBuffer{ int capacity = 16; int length = 0; char[] value; public MyStringBuffer(){ value = new char[capacity]; } //有参构造方法 public MyStringBuffer(String str){ this(); if(null==str) return; if(capacity<str.length()){ capacity = value.length*2; value=new char[capacity]; } if(capacity>=str.length()) System.arraycopy(str.toCharArray(), 0, value, 0, str.length()); length = str.length(); } @Override public void append(String str) { insert(length,str); } @Override public void append(char c) { append(String.valueOf(c)); } @Override public void insert(int pos, char b) { insert(pos,String.valueOf(b)); } @Override public void delete(int start) { delete(start,length); } @Override public void delete(int start, int end) { //边界条件判断 if(start<0) return; if(start>length) return; if(end<0) return; if(end>length) return; if(start>=end) return; System.arraycopy(value, end, value, start, length- end); length-=end-start; } @Override public void reverse() { for (int i = 0; i < length/2; i++) { char temp = value[i]; value[i] = value[length-i-1]; value[length-i-1] = temp; } } @Override public int length() { // TODO Auto-generated method stub return length; } @Override public void insert(int pos, String b) { //边界条件判断 if(pos<0) return; if(pos>length) return; if(null==b) return; //扩容 while(length+b.length()>capacity){ capacity = (int) ((length+b.length())*1.5f); char[] newValue = new char[capacity]; System.arraycopy(value, 0, newValue, 0, length); value = newValue; } char[] cs = b.toCharArray(); //先把已经存在的数据往后移 System.arraycopy(value, pos, value,pos+ cs.length, length-pos); //把要插入的数据插入到指定位置 System.arraycopy(cs, 0, value, pos, cs.length); length = length+cs.length; } public String toString(){ char[] realValue = new char[length]; System.arraycopy(value, 0, realValue, 0, length); return new String(realValue); } public static void main(String[] args) { MyStringBuffer sb = new MyStringBuffer("there light"); System.out.println(sb); sb.insert(0, "let "); System.out.println(sb); sb.insert(10, "be "); System.out.println(sb); sb.insert(0, "God Say:"); System.out.println(sb); sb.append("!"); System.out.println(sb); sb.append('?'); System.out.println(sb); sb.reverse(); System.out.println(sb); sb.reverse(); System.out.println(sb); sb.delete(0,4); System.out.println(sb); sb.delete(4); System.out.println(sb); } }
步骤 7 :

练习-性能比较

Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
使用Java自带的 StringBuffer 和 这个我们自己开发的MyStringBuffer性能比较。
参考比较方案:
1. 生成长度是10的随机字符串
2. 使用StringBuffer追加1000000次统计时间
3. 使用MyStringBuffer追加1000000次统计时间

性能统计办法 参考 比较StringBuffer和String的性能
如果追加的次数太大,会导致内存不够使用(默认情况下是分配16m),你会看到OutOfMemoryError 这样的错误。 调整的方式参考 JVM调试与设置 设置最大内存
步骤 8 :

答案-性能比较

在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

3分18秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)


答案-性能比较
package character; public class TestString { public static void main(String[] args) { int total = 5000000; String s = randomString(10); MyStringBuffer msb = new MyStringBuffer(); StringBuffer sb = new StringBuffer(); long start = System.currentTimeMillis(); for (int i = 0; i <total; i++) { sb.append(s); //使用 StringBuffer } long end = System.currentTimeMillis(); System.out.printf("使用StringBuffer的方式,连接%d次,耗时%d毫秒%n",total,end-start); start = System.currentTimeMillis(); for (int i = 0; i <total; i++) { msb.append(s); //使用MyStringBuffer } end = System.currentTimeMillis(); System.out.printf("使用MyStringBuffer的方式,连接%d次,耗时%d毫秒%n",total,end-start); } private static String randomString(int length) { String pool = ""; for (short i = '0'; i <= '9'; i++) { pool += (char) i; } for (short i = 'a'; i <= 'z'; i++) { pool += (char) i; } for (short i = 'A'; i <= 'Z'; i++) { pool += (char) i; } char cs[] = new char[length]; for (int i = 0; i < cs.length; i++) { int index = (int) (Math.random() * pool.length()); cs[i] = pool.charAt(index); } String result = new String(cs); return result; } }


HOW2J公众号,关注后实时获知布最新的教程和优惠活动,谢谢。


问答区域    
2018-10-09 交作业
桀树南桃



结果为; StringBuffer 消耗时间为18 MyStringBuffer消耗时间为13 发现insert方法的循环中 capacity = (int) ((length + b.length())*1.5f); 对性能影响极大; 我原来使用的是 capacity =(length + b.length()*2; 耗时居然超过1000毫秒
public class MyStringBuffer implements IStringBuffer{
	
	//将类视为一个容器,给予体积  和  盛放类型的属性
	//一、容器长度                          		体积
	int capacity = 16;
	//用于存放 字符的数组              	类型
	char[] value;
	//设置一个型变量记录装入字符串的长度
	int length = 0;
	
	//用长度初始化这个类的无参构造方法
	public MyStringBuffer(){
		value = new char[capacity];
	}
	
	//带参数的构造方法
	public MyStringBuffer(String str){
		//传进来的参数为空的话,直接返回
		if(null == str){
			return;
		}
		//如果容器的体积被被装入的字符串小则 扩大容器的体积
		if(capacity<str.length()){
			capacity = str.length()*2;
			value = new char[capacity];
		}
		//器足够装入传入的字符串直接装入容器
		if(capacity>=str.length()){
			System.arraycopy(str.toCharArray(),0, value, 0, str.length());
		}
		length = str.length();
	}

	//追加字符串		可以直接使用插入字符串的方法
	public void append(String str) {
		insert(length,str);
	}

	//追加字符     		可以直接使用插入字符串的方法
	public void append(char c) {
		insert(length,String.valueOf(c));
		
	}

	 //指定位置插入字符      可以直接使用插入字符串的方法
	public void insert(int pos, char b) {
		insert(pos,String.valueOf(b));
		
	}

	//指定位置插入字符串  
	public void insert(int pos, String b) {
	//插入之前,首先要判断的是一些边界条件。 比如插入位置是否合法,插入的字符串是否为空  pos是指插入的位置
		if(pos<0||pos>length||null == b){
			return;
		}
		//扩大容器的容量
		while (length+b.length()>capacity) {
			
			//这一步及其影响性能
			capacity = (int) ((length + b.length())*1.5f);
			char[] newvalue =new char[capacity];
			System.arraycopy(value, 0, newvalue, 0, length);
			value = newvalue;
		}
		//把传入的字符
		char[] cs = b.toCharArray();
		//把存好的数据往后面移动   从原文件的pos位置开始   往后移动插入字符的长度的位置
		System.arraycopy(value, pos, value, pos+cs.length, length-pos);
		//然后插入内容
		System.arraycopy(cs,0, value, pos, cs.length);
		
		length = length+cs.length;
	}

	//从开始位置删除剩下的     直接使用删除的方法
	public void delete(int start) {
		delete(start,length);
		
	}

	//从开始位置删除结束位置-1
	public void delete(int start, int end) {
	//判定起始位置和结束位置
		if(start<0||start>length||end<0||end>length||start>=end){
			return;
		}
		System.arraycopy(value, start, value, end, length -end);
		
		length -= (end -start);
	}

	//反转
	public void reverse() {
		for (int i = 0; i < length/2; i++) {
			char temp = value[i];
			value[i] = value[length-i-1];
			value[length-i-1] = temp;
		}
	}

	//返回长度
	public int length() {
		return length;
	}
	
	//返回字符串的方法
	public String toString() {
        char[] realValue = new char[length];
 
        System.arraycopy(value, 0, realValue, 0, length);
 
        return new String(realValue);
	}
	
	public static void main(String[] args) {
		
		//对比与原生StringBuffer类的性能差距
		/* 
		 	1. 生成长度是10的随机字符串
			2. 使用StringBuffer追加1000000次统计时间
			3. 使用MyStringBuffer追加1000000次统计时间
		*/
		// -----1------
		char[] cs =new char[10];
        int i = 0;
		while(i<cs.length)  {
             int m = (int)(48+Math.random()*(123-48));  //48-122随机数字
             if((48<=m && m<=57) || (65<=m && m<=90) || (97<=m && m<=122) ) {
                 cs[i] = (char)m;
                 i++;
             }
        }
		String str = String.valueOf(cs);
		
		// ——— 2 ————
		StringBuffer sb = new StringBuffer();
		
		long l = System.currentTimeMillis();
		
		int i1 =0;
		while(i1<100000){
			sb.append(str);
			i1++;
		}
		System.out.println("消耗时间为" + (System.currentTimeMillis()-l));
	
		// ——— 3 ————
		MyStringBuffer msb = new MyStringBuffer();
		
		l = System.currentTimeMillis();
	
		int i2=0;
		while(i2<100000){
			msb.append(str);
			i2++;
		}
		System.out.println("消耗时间为" + (System.currentTimeMillis()-l));
	}
}

							


1 个答案

Hello_Java_001 答案时间:2018-11-26
老哥电脑这么快的么10万次才18毫米.......




答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2018-10-02 交作业
asd32123



5137毫秒 4219毫秒 才开始试的时候十万次StringBuffer用时还少不少时间越大String Buffer用时差距越明显
public class Test {
	public static String a() {
		char a = (char)(Math.random()*('z'-'a')+'a');
		return Character.toString(a);
	}
	
	public static void main(String[] args) {
		StringBuffer s = new StringBuffer();
		MyStringBuffer my = new MyStringBuffer();
		long start  = System.currentTimeMillis();
		for (int i = 0; i < 100000000; i++) {
			s.append(a());
		}
		long end = System.currentTimeMillis();
		System.out.println(end-start+"毫秒");
		start = System.currentTimeMillis();
		for (int i = 0; i < 100000000; i++) {
			my.append(a());
		}
		end = System.currentTimeMillis();
		System.out.println(end-start+"毫秒");
	}
}

							






答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2018-09-27 写完程序,找不到错误
2018-08-31 按在地上摩擦~
2018-08-02 insert后输出未加上insert的部分
2018-07-26 1.构造扩容问题(1是不是可以防止字符串超出32位. 2是效率会有提升?)
2018-06-28 有参构造有错误,扩容后还需new一个字符素组进行值拷贝
2018-04-26 【交作业】MyStringBuffer
2018-04-08 参考了老师说的方法
2018-02-06 带参构造方法似乎有错误,我改了下,你们看看
2018-02-05 部分参考了站涨的代码,才完成的,很难。
2018-01-29 我自己的和答案的构造函数的对比,我的就是错误,答案的我也理解,但想不明白错的原因
2018-01-26 不知道为啥输出有空格子
2018-01-14 站长大大,我发现有个小bug不知道到是不是我想的这样
2017-11-20 delete函数中。start = length时也应该return
2017-11-20 带参的构造函数有错误存在
2017-11-19 这个问题描述的太简略了。。
2017-10-31 关于delete
2017-10-30 含参构造方法capacity
2017-09-07 自己写的stringbuffer在调用了delete等方法过后不能直接利用println输出,
2017-09-01 有个疑问
2017-08-10 改了JVM参数以后报out of memory
2017-08-05 为什么System.arraycopy()比for循环效率高呢?
2017-06-30 insert(int, String) 这个方法哪里来的,怎么直接就调用了
2017-06-13 toString() 问题
2017-05-10 老师现在的StringBuffer优化了吗?按照您的方法建立的MyStringBuffer比java自带的慢
2017-04-30 在delete的时候,如果后面数据的长度 小于 被删除数据的长度 的时候,是如何做到把需要删除的数据覆盖?
2017-04-21 关于删除
2017-03-17 实际工作中有必要再弄个MyStringBuffer嘛?
2017-02-22 含参构造方法
2017-01-20 toString
2016-10-12 为什么不用String 来实现StringBuffer呢?
2016-09-07 带参构造错误
2016-09-07 带参构造错误
2016-06-08 有个疑问




提问之前请登陆
关于 JAVA 基础-数字与字符串-MyStringBuffer 的提问

尽量提供截图代码异常信息,有助于分析和解决问题。 也可进本站QQ群交流: 902680467
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
在已经存在的几千个提问里,有相当大的比例,是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本,可以节约自己大量的学习时间。 站长把教学中用的软件版本整理了,都统一放在了这里, 方便大家下载: http://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图