精华内容
下载资源
问答
  • 不可变字符串:String,这里说的是字符串本身没有发生变化,与引用无关. 可变字符串:StringBuffer/StringBuilder,这里说的是字符串本身可以改变,与引用无关 注意:可变字符串与不可变字符串的直接父类都是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);
    	}
    }
    
    展开全文
  • 来到教室后,我想到昨天遗留的一个问题,就是可变字符串和不可变字符串的区别用法是什么,然后和同学讨论寻求答案,最后得到的结论是: 首先创建一个新的可变和不可变字符串 可变:NSMutableString * n = ...

    可变:NSMutableString * n = [NSMutableString string];     空字符串

    可变非空:NSMutableString * n1 = [NSMutableString stringWithFormat:@"百"];​

    ​不可变:NSString * n2 = @"百";  

    不可变:NSString * n3 = @"度";​

    区别在于:

    1如果用到zifuc的拼接,想要拼成 百度 ,如果用

    可变和不可变拼接,如下

    [n appendString:n2];​    

    可变字符串是可以在其内部进行改动的。直接在n中拼接一个字符串n2;

    不可变和不可变拼接,如下

    NSString * n4= [n2 stringByAppendingString:n3];​

    可见不可变需要再新建一个字符串n4,然后将​n2和n3​拼接起来赋给n4,因为不可变字符串是不可以进行内部修改的。

    以上仅是个人理解,如有错误进行指正。

    展开全文
  • 字符串:可变字符串与不可变字符串

    千次阅读 2016-04-23 00:01:35
    一 NSString是不可变字符串,所有它所有产生其他字符串方法都是生成一个新的字符串,而不会改变原来字符串 第一种:字面量,它是常量字符串,存储常量区 NSString *str = @"abc"; 第二种是通过 快捷的构造...

    一 NSString是不可变字符串,所有它所有产生其他字符串方法都是生成一个新的字符串,而不会改变原来字符串

    第一种:字面量,它是常量字符串,存储常量区

    NSString *str = @"abc";

    第二种是通过 快捷的构造方法

    NSString stringWithFormat:

    第三种方式 初始化方法

    [NSString alloc] initWithFormat:

    二,字符串的获取

    1、获取字符长度

     NSString *str = @"www.itcast.cn";

    long length = str.length;

    2、获取子串

    从哪个索引开始截取到字符串的末尾(包含索引上字符)

    NSString *str2 = [str substringFromIndex:4];

    从字符开头开始截取到索引的位置(不包含索引上的字符)

    NSString *str3  = [str substringToIndex:3];

    从哪个位置开始截取,截取多长

    NSRange range = {4,6};

    NSString *str4 = [str substringWithRange:range];

    获取某个子串所在的区间

    NSRange range1 =  [str rangeOfString:@"itcast"];

    NSLog(@"%@",NSStringFromRange(range));

    NSRange range2 =  [str rangeOfString:@"icast"];

    if (range2.location == NSNotFound) {

            NSLog(@"没有这个子串");

    }

    3字符串以什么开头

    hasPrefix  前缀

    hasSuffix  后缀

    4、字符串的比较

    1)比较是内容,从前往后一个一个的比较

    NSComparisonResult result = [str1 compare:str2];

    NSOrderedAscending = -1L, str1 < str2

    NSOrderedSame,            str1 == str2

    NSOrderedDescending       str1 > str2

    - (NSComparisonResult)compare:(NSString *)string options:(NSStringCompareOptions)mask;

    NSCaseInsensitiveSearch 忽略大小写

    NSNumericSearch 用于数值类型的比较

    4、字符串大小写的转变

    uppercaseString  大写

    lowercaseString  小写

    字符转基本数据类型

    int i = intStr.intValue;

    double d = intStr.doubleValue;

    float f = intStr.floatValue;

    C语言字符串转换为OC字符串

    [NSString stringWithCString:"hehe" encoding:NSUTF8StringEncoding];

    OC语言字符串转换为C字符串

    const char *cStr = [str8 cStringUsingEncoding:NSUTF8StringEncoding];

    在原有字符串的末尾拼接另一个字符产生一个新的字符串

    stringByAppendingString:

    字符替换(去掉字符串中的空格)

    - (NSString *)stringByReplacingOccurrencesOfString:(NSString *)target withString:(NSString *)replacement

    使用某个字符串替换掉原来字符串中某个区间的字符串

    NSRange range = [str rangeOfString:@"itcast"];

    str1  = [str stringByReplacingCharactersInRange:range withString:@"传智播客"];

    删除原字符串中的所有指定的字符

    str1 =  [str stringByReplacingOccurrencesOfString:@"itcast" withString:@""];

    【掌握】去掉两头的空格

    str1 = [str stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];

    在原来的路径上拼接一个路径

    stringByAppendingPathComponent:

    删除原来文件路径的扩展名.xxx

    stringByDeletingPathExtension:

    为没有扩展名的文件路径添加扩展名

    stringByAppendingPathExtension:

     NSMutableString 可变字符,它是NSString子类 可以进行增改删的操作,一个字符串需要经常修改其中的内容,那么就使用NSMutableString

    Capacity 表示容量,可以容纳多少字符,如果你字符串超这个存储空间它扩展它

    stringWithCapacity

    - (void)insertString:(NSString *)aString atIndex:(NSUInteger)loc;展它插入字符串

    - (void)deleteCharactersInRange:(NSRange)range;删除range范围内的字符串

    - (void)appendString:(NSString *)aString;拼接字符串

    - (void)appendFormat:(NSString *)format, ... NS_FORMAT_FUNCTION(1,2);

    - (void)setString:(NSString *)aString;


    注意:可变字符串不能使用字面量的方式赋值,字面量定义的是一个不可以变字符串.例如下面所写错误

    NSMutableString *strMM = @"abc";

    


    展开全文
  • package 封装类; public class Stringbuild { public static void main(String[] args) { String a="abc";//不可变字符串 StringBuilder sb=new StringBuilder("ancd");//可变字符串 System.out.pri...

    package 封装类;

    public class Stringbuild {

        public static void main(String[] args) {
            String a="abc";//不可变字符串
            StringBuilder sb=new StringBuilder("ancd");//可变字符串
            System.out.println(sb.hashCode());//打印sb的地址


            sb.setCharAt(2,'M');//把sb第二个字符变成M
            System.out.println(sb);
        }

    }

    输出结果为:

    String类型的字符串其实就是把元素装进一个private final类型的数组里面,里面的值无法改变,下面是String的源码。

     

    展开全文
  • 在OC中,字符串有:不可变字符串(NSString)、可变字符串(NSMutableString)。 可变字符串的方法继承于不可变字符串。可变字符串1.初始化一个字符串对象(除以下方法外,还可以使用alloc init来初始化字符串)...
  • 字符串学习 定义:java将于字符串相关的类容面向的对象...1、不可变字符串 定义: String:说的是字符串本身没有发生变化,与引用无关- - -常量。 表示方法:String s1 = “1000phone”; 实例代码: public c...
  • 不可变字符串、可变字符串、可变数组的操作及OC中字符串的排序
  • 1. NSString(不可变字符串) 1.1 创建字符串对象, 只使用初始化方法和便利构造器 NSString *name = [[NSString alloc] initWithString:@"1234567890"]; 便利构造器NSString *name2 = [NSString stringWithString:@...
  • //  ...不可变字符串    // 1.初始化方法   // 初始化一个空的字符串  NSString *string = [[NSString alloc] init];  NSString *string1 = @"asds"; // 字面量  N
  • 一,不可变字符串(NSString); 1.直接赋值NSString *string1=@"nihao";2.先分配内存后赋值NSString *string2=[[NSString alloc]init]; string2=@"nihao";3.工厂方法制造对象NSString *string3=[NSString ...
  • String 不可变字符串

    2018-07-01 23:35:19
    Java文档中将String类对象称为不可变字符串,例如String str = "message"; -----&gt;&gt;&gt; str里的任何一个字符都是不能修改的。现在有以下声明的字符串:String str1 = "hello"...
  • 不可变字符串:NSString1.初始化一个字符串对象 NSString *string1 = @"Leee"; NSString *string2 = [NSString stringWithFormat:@"sb"]; //NSString *string3 = [NSString stringWithFormat:@"%@%@",@"sss",@"qqq...
  • 1、OC字符串的创建   //当编译器发现一个@""的时候就会自动的生成一个字符串对象,  //该字符串存放在只读数据段   NSString * str1 = @"hello world!";  //用一个现有的字符串str1创建一个新的...
  • 修改字符串 String类没有提供用于修改字符串的方法。如果希望将 greeting 的内容修改为“ Help!”, 能直接地将 greeting的最后两个位置的字符修改为 ‘ p’ 和 ‘ ! 。这对于 C 程序员来说,将会感到无从下手 。...
  • 创建一个字符串对象  ? 1 2 3 4 5 6 7 8 9 NSstring * str1 = @"hello"; NSString * str = [[NSString alloc]initWithString:@"hello world!"]; ...
  • 可变字符串继承与不可变字符串 不可变字符串中的所有方法,可变字符串都可以使用   ------------.可变 字符串的创建 —————————— NSMutableString *string1 = [NSMutableString stringWithString...
  • 小白在通过《Objective-C程序设计》学习处理字符串,书中说:NSString所设定的是不可变字符串,但是书中的事例程序又对这个字符串进行了诸如复制、裁剪、拼接等操作,既然可以对其进行修改,为什么要称之为常字符串...
  • 第一种方法 NSMutableString *str1 = [str mutableCopy]; 第二种方法 NSMtableString *str2 = [NSMutableString stringWithFormat:@"%@“,str];
  • 总结一下课上的基础知识,字符串和可变字符串的基础知识

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,198
精华内容 8,079
关键字:

不可变字符串