精华内容
下载资源
问答
  • StringBuilder可变长度字符串什么是可变长度字符串为什么需要StringBuilderStringBuilder的使用 什么是可变长度字符串 StringBulder类在java.lang包下,该类维护一个可变长度字符串。它本身并不是字符串,二十提供...

    什么是可变长度字符串

    StringBulder类在java.lang包下,该类维护一个可变长度字符串。它本身并不是字符串,二十提供维护字符串功能的API

    为什么需要StringBuilder

    因为String类型对象不可变,在频繁修改时性能低下哎,内存开销大,所以在频繁修改字符串时,需要避免使用String类型。
    例如:

    package com.tedu.String;
    
    /**
     * 循环修改字符串的性能问题
     * @author Wildmess
     *
     */
    public class StringBadDemo {
    	public static void main(String[] args) {
    		String s = "a";
    		for(int i=0; i<1000000; i++) {
    			s += "a";
    		}
    		System.out.println("程序结束!");
    	}
    }
    

    这段程序中,每执行一次,都要在字符常量池中创建一个常量,如最开始创建"a",第一次"aa",第二次"aaa"……,依次类推,最终一定会把内存填满,报出异常。
    不过这里一般不会报出,因为Java自带的垃圾回收机制,暂时不会报出异常,最多就是编译时间过长。
    可以把s += “a”;换成s += s;几何速度增长下必定可以看到具体的报错异常。
    在这里插入图片描述

    StringBuilder的使用

    对频繁修改的字符串创建StringBuilder对象,进行检验
    如修改上述程序后为:

    package com.tedu.String;
    
    /**
     * 使用StringBuilder对象完成对字符串的频繁修改
     * @author Wildmess
     *
     */
    public class StringBuilderDemo {
    	public static void main(String[] args) {
    		StringBuilder sb = new StringBuilder("a");
    		for(int i=0; i<100000; i++) {
    			sb.append("a");
    		}
    		System.out.println("程序结束!");
    	}
    }
    
    展开全文
  • 实现可变长度字符串的类

    千次阅读 2015-11-11 17:30:51
    实现可变长度字符串的类
    struct mutableString
    {
        char ch[1];
    };
    
    int main(int argc, const char * argv[]) {    
        mutableString string;
        strcpy(string.ch, "hello world!");
        
        std::cout << string.ch << std::endl << strlen(string.ch) << std::endl;
        
        return 0;
    }


    mutableString可以存放可变长度的字符串


    展开全文
  • 本文描述的算法设计为在O(n)时间内对可变长度字符串进行排序。
  • 密码学 用于加密和解密可变长度字符串的简化类
  • 本文描述的算法设计为在O(n)时间内对可变长度字符串进行排序。
  • 基础场景见上面两个帖子,这里单独说明字符串和可变长度字符串的用法。 话不多说,开始今天的演(表)示(演) Profile和插件开发 添加一个string类型的属性: 在插件里添加一条数据上报消息:(已添加一个...

    基础篇

    基础场景见上面两个帖子,这里单独说明字符串和可变长度字符串的用法
    话不多说,开始今天的演(表)示(演)

    Profile和插件开发

    添加一个string类型的属性:

    在插件里添加一条数据上报消息:(已添加一个messageId,值为0x02

    再添加一个固定长度的字符串型字段,长度为6个字节

    与profile里的属性关联起来:

    再添加一条数据上报消息:(已添加一个messageId,值为0x03

    再添加一个长度字段:

    添加一个可变长度字符串,并关联长字段:

    与profile里的属性关联起来:

    最后部署插件即可。

    调测:

    注册一个新设备:

    使用NB设备模拟器,绑定后上报数据:此处上报了4条数据,都是02开头的码流

    查看设备历史数据:上报数据时,string字段使用ascii码进行解码(见本帖最后的总结)

    再上报03开头的码流:

    查看设备历史数据:

    总结:

    1)字符串类型的数据是按Ascii码进行编解码的,上报时将16进制码流转为对应字符(如21转为叹号!,31转为1,41转为A);下发命令时则反过来,把字符转为对应的16进制码流(如叹号!转为21,1转为31,A转为41)
    2)可变长度字符串要关联长度字段,长度字段必须为int型
    3)命令下发直接使用固定长度的字符串即可,下发的长度以实际下发数据为准
    4)ASCII码表直接百度即可找到,使用16进制的标准表,不在标准表里的无法编解码。解码时(数据上报)如果解析出来的字符无法使用具体字符表示,如标题开始、正文开始、正文结束等,则使用\u+2字节码流值表示(例如01转为\u0001,02转为\u0002);有具体字符的则使用具体字符,详见本总结第1条。

    附上部分ASCII码表:

    作者:Lily_w 

    展开全文
  • 演示如何将字符串的 MATLAB 元胞数组作为可变长度字符串写入/读取 HDF5 文件。 示例还演示了如何使用分块设置无限长度的数据集,以便它可以处理元胞数组中的任意数量的元素。 我还没有看到任何人这样做的证据。 我...
  • 可变字符串与不可变字符串

    千次阅读 2018-10-06 22:04:10
    字符串: java将字符串直接面向对象了,形成的类就是字符串类,表示方法:" " ...注意:可变字符串与不可变字符串的直接父类都是Object,他们之间是兄弟,没有任何关系. 不可变字符串本...

    字符串:

    • java将字符串直接面向对象了,形成的类就是字符串类,表示方法:" "

    • 分类:

      • 不可变字符串:String,这里说的是字符串本身没有发生变化,与引用无关.
      • 可变字符串:StringBuffer/StringBuilder,这里说的是字符串本身可以改变,与引用无关
        image
    • 注意:可变字符串与不可变字符串的直接父类都是Object,他们之间是兄弟,没有任何关系.

    • 不可变字符串本身可以认为是常量

    • 字符串常量的保存位置:常量区.可以任务字符串的常量区是堆区中一块儿特殊的区域.

    • 字符串常量的特点:同一个名字的字符串常量在内存中只允许存在一个.(只占用一块儿内存)

    image

    public class Demo3 {
    	public static void main(String[] args) {
    //		//创建的不可变字符串
    //		String  s = "hello";
    //		//创建的可变字符串
    //		StringBuffer stringBuffer = new StringBuffer("world");
    		
    		//先讲不可变字符串
    		/*
    		 * 当执行s1的时候,会到常量区找叫1000phone的字符串,如果有直接让s1保存他的地址,如果没有,会在常量区开辟一块儿
    		 * 空间存1000phone.
    		 * 执行s2是同理s1
    		 * 执行s3时,由于进行了new,一定会现在堆中开辟一块儿空间,而1000phone是作为参数传给了对象.保存在了对象的一个String
    		 * 类型的成员变量内,所以直接判断s1与s3不相同.
    		 * 执行s4同理s3
    		 * */
    		String s1 = "1000phone";
    		String s2 = "1000phone";
    		String s3 = new String("1000phone");
    		String s4 = new String("1000phone");
    		
    		System.out.println(s1 == s2);//true
    		System.out.println(s1 == s3);//false
    		System.out.println(s1 == s4);//false
    		
    		//说明字符串重写了equals方法,重新定义了比较的规则,规则变成:如果是直接的两个字符串比较,就比较地址
    		//如果是比较的字符串对象,就去比较对象内部的属性的地址.
    		System.out.println(s1.equals(s2));//true
    		System.out.println(s1.equals(s3));//true
    		
    		//综上:以后大家进行字符串比较的时候,尽量使用equals
    		
    	}
    }
    

    String:

    1. 判断:
    • 判断是否包含一个子字符串
      boolean contains(CharSequence s)
    • 判断两个字符串的内容是否相同
      boolean equals(Object anObject)
    • 忽略大小写判断两个字符串的内容是否相同
      boolean equalsIgnoreCase(String * otherString)
    • 判断是否以某字符串开头
      boolean startsWith(String prefix)
    • 判断是否以某字符串结尾
      boolean endsWith(String suffix)
    1. 转换:将字符数组转换成字符串

      1. 使用构造方法
        • String(char[] value)
        • String(char[] value, int offset, int * unt)
      2. 使用静态方法
        • static String copyValueOf(char[] data)
        • static String copyValueOf(char[] data, int * fset, int count)
      3. 将字符串转成字符数组
        • char[] toCharArray()
      4. 将字节数组转成字符串
        • String(byte[] bytes)
        • String(byte[] bytes, int offset, int * ngth)
        • String(byte[] bytes, String arsetName)//使用指定的编码将字节数组转换 * 符成
      5. 将字符串转成字节数组
        • byte[] getBytes()
      6. 将基本数据类型转换成字符串
        • String.valueOf()
    2. 替换:

      • String replace(char oldChar, char newChar
      • 获得子串:
        • String substring(int beginIndex)
        • String substring(int beginIndex, int endIndex) //包含起始位置,不包含结束位置, * 束位置的前一位
      • 转换,去除空格,比较:
      • 大小写转换
      • String toLowerCase()
      • String toUpperCase()
      • 将字符串两端的空格去掉
      • String trim()
      • 按字典顺序比较两个字符串
      • int compareTo(String anotherString)
        • 按照ASCII表比较当前的两个字符串,ASCII码大的被认为是大字符
        • 规则:从左边第一个字符开始比较
        • 如果当前的字符不相同,直接认为ASCII码大的字符串是大字符串,后面的字符停止比较.
        • 当前的字符比较的具体规则:使用前面的字符的ASCII-后面字符的ASCII,返回差值.如果是负数,说明前面的字符串<后面的,如果是0,说明两个字符串相等, 如果是正数,说明前面的字符串>后面的.
    3. 切割: String[] split(String)

    • 注意点:
      1. 在被切的字符串中刀要存在
      2. 刀不会被当做切后的内容
      3. 字符串中出现了并排的刀,切出的是空
      4. 使用空去切,得到的是所有单独的字符
    public class Demo4 {
        public static void main(String[] args) throws UnsupportedEncodingException {
        	String s = "1000phone";
        
        	System.out.println(s.contains("1000"));
    	 
        	System.out.println(s.equals("1000Phone"));//false
    	  
        	System.out.println(s.equalsIgnoreCase("1000Phone"));//true
    	    
        	System.out.println(s.startsWith("1000"));//true
    	
        	System.out.println(s.endsWith("phone"));//true
    		
    		
    	    //2.转换:将字符数组转换成字符串
        	char[] arr = {'a','d','y','g'};
    		//1:使用构造方法
    		//String(char[] value) 
        	String s2 = new String(arr);
        	System.out.println(s2);
    		//String(char[] value, int offset, int count) 将指定个数的字符转成字符串,offset:是起始点    count:是字符个数
        	String s3 = new String(arr, 0, 2);
        	System.out.println(s3);
    		//2:使用静态方法
    		//static String copyValueOf(char[] data) 
    		//static String copyValueOf(char[] data, int offset, int count) 
    		//将字符串转成字符数组
    	    //char[] toCharArray() 
        	char[] arr1 = s.toCharArray();
        	for (char c : arr1) {
    			System.out.println("value:"+c);
    		}
    		//将字节数组转成字符串
        	byte[] arr2 = {97,98,99,100};
    	    //String(byte[] bytes) 
        	String s4 = new String(arr2);
        	System.out.println(s4);
    	    //String(byte[] bytes, int offset, int length)
        	s4 = new String(arr2, 0, 2);
        	System.out.println(s4);
    	    //String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符串
        	byte[] arr3 = {-60,-29,-70,-61};
            s4 = new String(arr3,"GBK");
            System.out.println(s4);
    		//将字符串转成字节数组
    	    //byte[] getBytes() 
            byte[] arr4 = s4.getBytes();//这里使用的是默认字符集,现在是utf8,所以一个汉字对应3个字节
            for (byte b : arr4) {
    			System.out.print("value:"+b);//-28,-67,-96,-27,-91,-67
    		}
            System.out.println();
    		//将基本数据类型转换成字符串
    	    //String.valueOf()
    		String s5 = String.valueOf(12);
    		System.out.println(s5+1);
    		
    	    //3.替换:
    		//String replace(char oldChar, char newChar) 
    		String s6 = s.replace("1000", "****");
    		System.out.println(s6+"    "+s);//s的值还是1000phone,说明字符串是常量,本身不会发生改变
    		//子串:
    		//String substring(int beginIndex)  取值时包括当前的位置
    		System.out.println(s.substring(4));
    	    //String substring(int beginIndex, int endIndex) //包含起始位置,不包含结束位置,到结束位置的前一位
    		System.out.println(s.substring(4,6));
    		//转换,去除空格,比较:
    		//大小写转换
    	    //String toUpperCase()
    		String s7 = s.toUpperCase();
    		System.out.println(s7);
    		//String toLowerCase() 
    		s7 = s7.toLowerCase();
    		System.out.println(s7);
    	    //将字符串两端的空格去掉,注意:中间的空格不会去掉
    	    //String trim() 
    		String s8 = "   he  llo  ";
    		s8 = s8.trim();
    		System.out.println(s8+"ok");
    		//按字典顺序比较两个字符串
    		
    	    //int compareTo(String anotherString)
    		System.out.println(s.compareTo("9000ahone"));
    		
    		//4.切割: String[] split(String)
    	
    		String s9 = "s,t,u,d,,e,nt";
    		String[] strings = s9.split("");
    		for (String string : strings) {
    			System.out.println(string);
    		}
    	}
    }
    

    可变字符串:(字符串缓冲区)

    • StringBuffer(jdk1.0):是考虑线程安全的,因为他本身是线程安全的.
    • StringBuilder(jdk1.5):不需要考虑线程安全,因为他本身是线程不安全的.
    • 结论:在不考虑线程安全的前提下尽量使用StringBuilder,因为效率高,速度快

    StringBuff

    1. 存储:

      • StringBuffer append(boolean b) 从最后插入
      • StringBuffer insert(int offset, boolean b) 从指定位置插入
    2. 删除:

      • StringBuffer delete(int start, int end)
      • StringBuffer deleteCharAt(int index)
    3. 修改:

      • StringBuffer replace(int start, int end, String str换指定的子字符串
      • void setCharAt(int index, char ch) 修改一个字符
    4. 获取:

      • char charAt(int index)
      • int indexOf(String str)
      • int indexOf(String str, int fromIndex)
      • int lastIndexOf(String str)
        返回指定子字符串(从右边开始计数)在此字符串第一次出现时的索引
      • int lastIndexOf(String str, int fromIndex)
        返回指定子字符串(从右边开始计数,范围:当前指定的位置-0)在此字次出现时的索引
      • int length()
        返回长度(字符数)。
    5. 反转:

      • StringBuffer reverse()
    public class Demo5 {
        public static void main(String[] args) {
        	//创建空的可变字符串
        	StringBuffer stringBuffer1 = new StringBuffer();
        	//1.存储:
        	//StringBuffer append(boolean b)   从最后插入
        	stringBuffer1.append("1000");
        	stringBuffer1.append("phone");
        	System.out.println(stringBuffer1);
            //StringBuffer insert(int offset, boolean b)   从指定位置插入
        	System.out.println(stringBuffer1.insert(4, "bingbing"));
            //2.删除:
            //StringBuffer delete(int start, int end) 
        	System.out.println(stringBuffer1.delete(4, 12));
            //StringBuffer deleteCharAt(int index)
        	//System.out.println(stringBuffer1.deleteCharAt(0));
            //3.修改:
            //StringBuffer replace(int start, int end, String str)  替换指定的子字符串
        	System.out.println(stringBuffer1.replace(0, 4, "bingbing"));
            //void setCharAt(int index, char ch) 修改一个字符
    
            //4.获取:
            //char charAt(int index) 
        	System.out.println(stringBuffer1.charAt(0));
        	//int indexOf(String str)从左到右查
        	System.out.println(stringBuffer1.indexOf("phone"));
        	//int indexOf(String str, int fromIndex) 从指定的位置按照从左到右的顺序开始查
        	System.out.println(stringBuffer1.indexOf("bing",2));
        	//int lastIndexOf(String str) 
            //返回指定子字符串(从右边开始计数)在此字符串第一次出现时的索引
            //int lastIndexOf(String str, int fromIndex) 
            //返回指定子字符串(从右边开始计数,范围:当前指定的位置-0)在此字符串第一次出现时的索引 
            //int length() 
            //返回长度(字符数)。 
            System.out.println(stringBuffer1.length());
            //5.反转:
            //StringBuffer reverse()
            System.out.println(stringBuffer1.reverse());
    	}
    }
    

    实例:将一个字符串进行反转。

    将字符串中指定部分进行反转,“abcdefg”;abfedcg
    思路:

    1. 曾经学习过对数组的元素进行反转。
    2. 将字符串变成数组,对数组反转。
    3. 将反转后的数组变成字符串。
    4. 只要将或反转的部分的开始和结束位置作为参数传递即可。
    public class Demo6 {
    	public static void main(String[] args) {
    
    		String string = "aaaahellobbbbb";
    		String string2 = exchange(string, 4, 9);
    		System.out.println(string2);
    	}
    	
    	public static String exchange(String source,int begin,int end){//这里end作为下标的值不包含在反转范围内
    		//先将字符串转成字符数组
    		char[] arr = source.toCharArray();
    		for (int i = begin,j = end-1; i < j; i++,j--) {
    			char temp = arr[i];
    			arr[i] = arr[j];
    			arr[j] = temp;
    		}
    		
    		return new String(arr);
    	}
    }
    
    展开全文
  • 字符串:可变字符串与不可变字符串

    千次阅读 2016-04-23 00:01:35
    一 NSString是不可变字符串,所有它所有产生其他字符串方法都是生成一个新的字符串,而不会改变原来字符串 第一种:字面量,它是常量字符串,存储常量区 NSString *str = @"abc"; 第二种是通过 快捷的构造...
  • 本文主要探讨数据库可变字符串类型长度设计问题,最好的策略是只分配真正需要的空间,慷慨是不明智的。
  • ocaml-bitpath:有效的位字符串类型以及用于对可变长度字符串上的数据进行分区的容器
  • 字符串学习 定义:java将于字符串相关的类容面向的对象...1、不可变字符串 定义: String:说的是字符串本身没有发生变化,与引用无关- - -常量。 表示方法:String s1 = “1000phone”; 实例代码: public c...
  • 可变字符串

    千次阅读 2019-05-31 14:24:28
    可变字符串 :改变字符串,不会产生新的对象 StringBuffer:所有方法synchronized(锁),安全、效率低 StringBuilder:不安全、效率高 StringBuilder sb = new StringBuilder();// "" sb = new StringBuilder(...
  • 可变字符串 NSSMutableString 的使用

    千次阅读 2012-12-04 17:10:56
    // ******************* ...可变字符串的操作   //NSMutableString 是NSString的子类  NSMutableString * str4 = [[NSMutableString alloc] initWithCapacity:0];    //在已有字符串后面添加新的字符串
  • C++中字符数组处理可变字符串

    千次阅读 2015-09-04 10:16:46
    核心思路: 模拟c 中realloc()函数 , 但长度不够时, new 一个更大的数组, 老的数据拷贝过来, 老的空间释放掉, 老的指针指向新的空间 有一点要注意: 这里使用的输入是cin.get() ,因为直接cin>>temp 会将空格...
  • string s; //定义字符串变量 StringBuilder sb = new StringBuilder(); //创建可变字符串对象 sb.Append("北运"); //添加字符串 sb.Insert(1, "京奥");... //把可变字符串对象转化为字符串 s =
  • 为了巩固学习,脱离智能提示,不是在xcode中编辑,是在文本格式下创建 1.创建对象 NSString *str1 = [...//根据指定格式创建字符串对象 NSLog(@"%@",str1); NSString *str2 = [NSString stringWithFormat:@"%d",
  • printf 打印 指定长度 字符串

    千次阅读 2017-05-14 21:18:45
    printf 打印 指定长度 字符串 转载至:http://www.cnblogs.com/ai616818/archive/2012/05/31/2528472.html  原样输出字符串:  printf("%s", str); 2. 输出指定长度字符串, 超长时不截断, 不足时右...
  • NSString 是一个不可变字符串类,继承自 NSObject ,用NSString创建出来的字符串对象,一经创建就不能再修改了.我们可以对它执行查找或比较等操作,但是不能通过增加,删除它的字符来动态地改变它.  NSString主要的...
  • Java可变字符串

    千次阅读 2017-04-18 17:44:55
    java互助分享 2017-03-...当对字符串进行修改的时候,需要使用StringBuilder和StringBuffer。 StringBuilder和StringBuffer之间的不同点: 1.StringBuilder的方法是线程不安全的(不能同步访问), StringBuffer是线程安
  • 关于C语言字符串处理之可变字符串

    千次阅读 2016-01-25 12:39:36
    今天看到一个帖子,帖子内容大概就是用C语言实现把字符串中的小写字符修改成大写的字符,看到了感觉这还不简单,但是一直出现关于内存的问题。 void change(char *str){ char *p = str; while(*p!='\0'){ if(*p>...
  • 字符串长度

    千次阅读 2014-08-04 22:21:47
    我记得C#的面试题屡屡出现求字符串长度
  • 求已知字符串的最大回文字符串长度,并输出该字符串(不考虑数字) 输入示例:  Madam,I'm Adam. 输出示例:  Madam,I'm Adam. 题目分析: 输入分析:C语言的常用输入字符串函数scanf(),gets()都不适合本题,...
  • 可变字符串 可变字符串在追加、删除、修改、插入和拼接等操作不会产生新的对象。 StringBuffer 和StringBuilder Java 提供了两个可变字符串类StringBuffer 和 StringBuilder,中文翻译为“字符串缓冲区”。 ...
  • 在OC中,若想创建一个不可变字符串,我们可以通过多种方法来实现方法一:以 @“XXX”格式直接生成 这种方法生成的字符串,会存储在内存中的常量区,若两个字符串的内容相同,便会指向同一个地址 方法二:类...
  • StringBuffer和StringBuilder就是所谓的可变字符串类,共四个构造方法: StringBuffer() public StringBuffer(int paramInt) public StringBuffer(String paramString) public StringBuffer(CharSequence ...
  • 字符串 varchar varchar(255) 所占资源空间是你存储内容的长度 定长字符串 char char(8)不管你存储内容的长度是多少,它所占空间就是8,如果存储内容长度大于8,则会被截取 所以:varchar相较于char,更能节省...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 304,361
精华内容 121,744
关键字:

以下表示可变长度字符串