JavaSE_String

于 2014-01-07 12:06:52 发布
阅读量855 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # JavaSE 文章标签： javase string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pre_eminent/article/details/17955919

StringDemo

package uncommitted;
import org.junit.Test;
public class StringDemo {
   @Test
   public void stringDemo2() {
      //在常量池中创建1个对象
      String s1="abc";
      //在堆内存中创建两个对象
      String s2=new String("abc");
      
      System.out.println(s1==s2);//false 比较的是地址
      System.out.println(s1.equals(s2));//true!!!
      //String类复写了Object的equals方法,
      //不再是用==比较地址了,
      //而是比较字符串的内容了!      
   }
   @Test
   public void stringDemo1() {
      /* 字符串常量池，池中没有就创建，池中若有就直接拿来用！*/
      String s1="abc";
      String s2="abc";
      String s3=new String("abc");
      System.out.println(s1==s2);
      //true,地址相同,都指向了常量池中的固定地址
      System.out.println(s1+"..."+s2);
      //abc...abc
      System.out.println(s3);
      //abc
   }
}


StringMethod

package uncommitted;
import org.junit.Test;
public class StringMethod {
   @Test
   public void method10() {
      /** StringBuffer方法集合*/
      StringBuffer sb=new StringBuffer("abcde");
      sb.delete(1, 3);//从下标1开始删除3-1=2个字符
      System.out.println("sb: "+sb);
      //sb: ade
      //清空字符缓冲区
      sb.delete(0, sb.length());
      //把盆子都扔掉了,指向重新开辟的空间
      sb=new StringBuffer();
      System.out.println("new sb: "+sb);
      //new sb: 
      sb.append("abdcde");
      System.out.println(sb.charAt(3));
      //c  查下标为3的字符 下标从0开始~
      System.out.println(sb.indexOf("d"));
      //2   查d第一次出现的位置,下标从0开始~
      System.out.println(sb.lastIndexOf("d"));
      //4   倒查d所在的下标,即最后一次出现的位置
      System.out.println(sb.replace(2, 5, "zzzzz"));
      //abzzzzze,前闭后开替换成新字符串
      sb.setCharAt(3, 'o');//方法无返回值(VOID)
      System.out.println("sb: "+sb);
      //abzozzze
      sb.setLength(5);
      //设置长度,方法无返回值(VOID)
      //若新字符串变短了,相当于取文本左边,
      //若新字符串变长了,用空字符填充
      System.out.println("sb: "+sb);
      //abzoz
      sb.setLength(9);//返回值为VOID,设置长度,添加空字符
      System.out.println("sb: "+sb);//abzoz空空空空
      sb.setLength(0);//返回值为VOID,设置长度0,等于清空缓冲区
      System.out.println("sb: "+sb);//空    
      StringBuffer sb1=new StringBuffer();
      StringBuffer sb2=sb1.append(4);
      System.out.println("sb2: "+sb2);
      //sb2: 4    
      System.out.println(sb1==sb2);
      //true指向同一内存空间
      sb2.setLength(0);//清空缓冲区
      sb2.append("红").append("楼").append("梦苑");
      //www.sgycw.com
      System.out.println(sb2);
      //红楼梦苑
      System.out.println(sb2.insert(3, "weixi"));
      //红楼梦weixi苑 为啥汉字也是占一个索引?!
   }
   @Test
   public void method9() {
      /* 用StringBuffer将1个整型数组变成字符串
       *+号会在字符串池中产生新的字符串
       *而append就不会 */
      String str="[";
      int[] arr={2,0,1,4,5,2,6,7};
      for (int i = 0; i < arr.length; i++) {
         if(i!=(arr.length-1)){
         str+=arr[i]+",";            
         }else
            str+=arr[i]+"]";
      }      
      System.out.println(str);
      //[2,0,1,4,5,2,6,7]
      //用StringBuffer append不会产生新的字符串
      StringBuffer sb=new StringBuffer();
      sb.append("[");
      int[] arr1={2,0,1,4,5,2,6,7};
      for (int i = 0; i < arr1.length; i++) {
         if(i!=(arr1.length-1)){
         sb.append(arr1[i]+",");//不会产生新的字符串
         }else
            sb.append(arr1[i]+"]");
      }      
      System.out.println(sb);
      //[2,0,1,4,5,2,6,7]
      System.out.println("反转:  "+sb.reverse());//反转
      //反转:  ]7,6,2,5,4,1,0,2[
   }
   @Test
   public void method8() {
      System.out.println("abc".compareTo("zxb"));
      //a是97,z是122,相减是-25
      System.out.println("zbc".compareTo("axb"));
      //z是122,a是97,相减是25
      System.out.println("zbc".equalsIgnoreCase("ZbC"));
      //不区分大小写 true
      
      String ss="abcde.java";
      System.out.println(ss.contains("de"));//true
      System.out.println(ss.startsWith("abc"));//true
      System.out.println(ss.endsWith(".java"));//true
   }
   @Test
   public void method7() {
      /*难点~ intern()方法的介绍; 
返回字符串对象的规范化表示形式。 
一个初始为空的字符串池，它由类 String 私有地维护。 
当调用 intern 方法时，
如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），
则返回池中的字符串。
否则，将此 String 对象添加到池中，
并返回此 String 对象的引用。 
它遵循以下规则：对于任意两个字符串 s 和 t，
当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。 
所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。
返回：一个字符串，内容与此字符串相同，
但一定取自具有唯一字符串的池。*/
      String s1=new String("胡笳十八拍");
      //s1是在堆内存中维护一个字符串
      String s2="胡笳十八拍";
      //s2是在字符串池中的~
      String s3=s1.intern();
      /*s3的意思是:
       * 如果池中已有和s1对象内容相同的字符串,
       * 那么就返回池中的字符串;
      如果没有,则会在字符串常量池中,
      创建一个s1对象相同内容的字符串,
      并且返回池中的字符串;
      所以:s3的字符串是池中的,是公共的~
      s3的这一句,功能和s2这一句完全一样~*/
      System.out.println(s3==s1);//无论常量池中有没有,都是false
      System.out.println(s3.equals(s1));
      //true;String重写了Object的equals方法,比较的是内容
   }
   @Test
   public void method6() {
       /* 对一个全是英文单词的数组进行字典排序
       * 选择排序,两层for嵌套,对象.compareTo比较>0;交换;*/
      String[] arr={"String","Array","Integer","Long","Double"};
      //排序前先打印一遍
      System.out.print("[");
      for (int i = 0; i < arr.length; i++) {
         if(i!=arr.length-1){
            System.out.print(arr[i]+",");
         }else{
            System.out.print(arr[i]+"]");
         }
      }
      //[String,Array,Integer,Long,Double]
      //下面开始排序
      for (int i = 0; i < arr.length-1; i++) {
         for (int j = i+1; j < arr.length; j++) {
            //z>a
            if(arr[i].compareTo(arr[j])>0){
               String temp=arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
            }
         }
      }
      //排序完再打印一遍
      System.out.print("\n[");
      for (int i = 0; i < arr.length; i++) {
         if(i!=arr.length-1){
            System.out.print(arr[i]+",");
         }else{
            System.out.print(arr[i]+"]");
         }
      }
   }
   @Test
   public void method5() {
       /* 查找key字符串在str字符串出现的次数
       * 用subString,或者指针偏移*/
      String str="nbaiiiinbaoooonba";
      String key="nba";
      int count=0;//计数用的
      int index=0;//出现的下标
      while((index=str.indexOf(key))!=-1){
         //每找到一次截取余下的字符串
         str=str.substring(index+key.length());
         System.out.println(str);
         count++;
      }
      System.out.println(count);
      //方法2,用指针偏移
      String str1="nbaiiiinbaoooonba";
      int count1=0;//计数
      int index1=0;
      //出现的下标0 ,7 ,14
      while((index1=str1.indexOf(key,index1))!=-1){
         //从str1的指定位置开始查找key,并返回key在str1的索引位置
         System.out.println("index1:"+index1);
         //每找到一次key,指针偏移至key后面的字符串
         index1=index1+key.length();
         count1++;
      }
      System.out.println(count1);
   }
   @Test
   public void method4() {
       /* 求两个字符串中最大的相同的子串,
        * 提示从短的字符串分析
       * 第1步,先看较短的字符串是否在另1个的里面
       * 第2步,短的字符串减去1位,看看它们是否在长的里面...*/
      String s1="qwerabcdtyuiop";
      String s2="xcabcdvbn";
      String sub=null;
      String longStr=null;//长的字符串
      String shortStr=null;//短的字符串
      longStr=(s1.length()>s2.length())?s1:s2;
      shortStr=(longStr.equals(s1))?s2:s1;
      Lable1:for (int i = 0; i < shortStr.length(); i++) {
         for (int j = 0,k=shortStr.length()-i; k!=shortStr.length()+1; j++,k++) {
            sub=shortStr.substring(j, k);
            //System.out.println("sub__"+sub);
            if(longStr.contains(sub)){
               //因短的依次减少,如果存在包含,
               //即最大子串,跳出最外层循环
               break Lable1;
            }
         }         
      }
      System.out.println("长的字符串是:"+longStr);
      System.out.println("短的字符串是:"+shortStr);
      System.out.println("最大相同子串是:"+sub);
   }
   @Test
   public void method3() {
       /* 去掉字符串两端的空白(注意特殊情况:全是空白)*/
      String s="   ab   c   ";
      //长度12,a的下标为3,c的下标为8,共6个有效字符
      int start=0,end=s.length()-1;
      while(start<=end&&s.charAt(start)==' '){         
         start++;
      }
      while(start<=end&&s.charAt(end)==' '){
         end--;
      }
      System.out.println("长度: "+s.length()+" start: "+start+"  end : "+end);
      //长度: 12 start: 3  end : 8
      s=s.substring(start, end+1);
      //start为3,end为8,共计6个字符
      System.out.println("-"+s+"-");
      //-ab   c-
   }
   @Test
   public void method2() {
      String s1="原,应,叹,息";
      String s2="宝.黛.钗";
      String[] s3=s1.split(",");
      //分割后是个字符串数组
      String[] s4=s2.split("\\.");
      //点在正则代表人任意字符,需要转义,
      //第1次转反斜杠,第2次才转点号
      char[] chs=s1.toCharArray();//转成单个文本即字符数组
      for (int i = 0; i < chs.length; i++) {
         System.out.print(chs[i]);
      }      
      //原,应,叹,息
      
      
      
      String str="abc你好中国";
      byte[] bt=str.getBytes();//转成字节型存放在数组里
      for (int i = 0; i < bt.length; i++) {
         System.out.print(bt[i]);
      }
      //97  98  99  -60-29-70-61-42-48-71-6
      System.out.println("sgycw".toUpperCase());//转成大写
      System.out.println("SGYCW".toLowerCase());//转成小写
      System.out.println("SGYCW.cc".replace('C','d'));
      //旧char换成新char,区分大小写,只找大写的C换
      System.out.println("SGYCW.COM".replace('k','d'));
      //找不到k,替换失败,返回原字符串
      System.out.println("SGYCW.COM".replace("SG","weixi"));
      // 旧string换成新string 区分大小写
      System.out.println("-"+"    SG    YC     ".trim()+"-");
      //去首尾空(易语言),常用账号密码登录
      System.out.println("abc".concat("123"));
      //字符串连接(对象的思维)
      System.out.println("abc"+"123");
      //生成新的字符串
      System.out.println(String.valueOf(123)+4);
      //1234 将整数变字符串,然后相连接
   }
   @Test
   public void method1() {
      //注意:一个汉字,在String里长度为1
      String s="红楼梦";
      System.out.println(s.length());
      //红楼梦  长度为3
      s="abcdefgabcdefg";
      System.out.println(""+s.length());//14
      System.out.println(""+s.charAt(3));
      //d 下标从0开始算
      System.out.println(""+s.indexOf('e'));//4
      System.out.println(""+s.indexOf('k'));//找不到返回-1
      System.out.println(""+s.indexOf("fg"));
      //5  返回fg首次出现的位置
      System.out.println(""+s.substring(2));
      //取下标2开始到最后cdefgabcdefg
      System.out.println(""+s.substring(2,5));
      //取下标2开始取5-2=3个字符cde
   }
}


StringConstructorDemo

package uncommitted;
import org.junit.Test;
public class StringConstructorDemo {
   @Test
   public void stringConstructorDemo2() {
      char[] arr={'s','g','y','c','w'};
      String s1=new String(arr);//将字节数组变字符串
      String s2=new String(arr,1,3);//从1下标开始取3个
      System.out.println(s1);//sgycw
      System.out.println(s2);//gyc
   }
   @Test
   public void stringConstructorDemo1() {
      String s1=new String();
      String s2="";
      System.out.println(s1+"|");
      //|
      System.out.println(s2+"|");
      //|
      //上面两者等效,都是空字符串对象;
      String s3=null;
      System.out.println(s3+"|");
      //null|
      byte[] arr={65,66,67,68};
      String s4=new String(arr);
      //将字节数组变字符串
      System.out.println(s4);//ABCD
   }
}


Details

package uncommitted;
import java.io.FileReader;
import java.io.IOException;

import org.junit.Test;

public class Details {
   @Test
   public void method12() {
      int[] arr={1,3,4};
      sop(arr.length+"");
      //数组的长度是:属性
      String s1="abc";
      sop(s1.length()+"");
      //字符串的求长度是:方法()
   }
   @Test
   public void method11() {
      // String覆盖了equals方法和hashCode方法，即比较的是内容~
      sop(new String("abc").equals(new String("abc"))+"");//true
      //StringBuffer没有覆盖equals方法和hashCode方法,即比较的是对象内存地址~
      sop(new StringBuffer("abc").equals(new StringBuffer("abc"))+"");//false
   }
   @Test
   public void method10() {
      // 再说一次:ceil是数轴正方向,floor是数轴负方向,round是floor(a+0.5)
      System.out.println(Math.ceil(11.3));//12.0
      System.out.println(Math.ceil(-11.3));//-11.0
      System.out.println(Math.floor(11.6));//11.0
      System.out.println(Math.floor(-11.6));//-12.0
      System.out.println(Math.round(-11.4));//-11.0
      System.out.println(Math.round(-11.5));//-11.0
      System.out.println(Math.round(-11.51));//-12.0
      System.out.println(Math.round(-11.6));//-12.0
   }
   @Test
   public void method9() {
      String a=new String("foo");
      String b=new String("foo");
      System.out.println((a==b));
      //false 连等于 比较的是对象在内存中的地址
      System.out.println(a.equals(b));
      //true String覆盖了Object的equals方法,所以比较的是字符串的内容
   }
   @Test
   public void method8() {
/*   使用final关键字修饰一个变量时，是指该引用变量不能变，
      即,不能再被重新指派,指向其他的内存空间了!
      而引用变量所指向的对象的内容还是可以改变的。*/
      final StringBuilder sb=new StringBuilder("可叹停机德，堪怜咏絮才。");
      sb.append("玉带林中挂，金簪雪里埋。");
      System.out.println(sb);
      //可叹停机德，堪怜咏絮才。玉带林中挂，金簪雪里埋。
//      sb=new StringBuilder();//sb已被final修饰,不能再另外指派空间地址
      //The final local variable sb cannot be assigned.
   }
   @Test
   public void method7() {
      //char型变量中能存储一个中文汉字!
      //Unicode编码中,每个汉字占两个字节 即2^16=65536
      //char的范围是 0~65535,如果超过就报错:cannot convert from int to char
      char ch='国';
      System.out.println(ch);//国
      ch=22269;  
      System.out.println(ch);//国
   }
   @Test
   public void method6() {
       /*为什么说下面这句是对的!
      因为+=是Java自己定义好的运算符,
      当计算结果还在byte的范围内,JVM底层会自动强制截取~
      如果计算结果超过byte的范围,会计算出错误的结果,如下面所示~*/
      byte s1 = 1; 
      s1 += 126;
      System.out.println(s1);//127
      s1+=1;
      System.out.println(s1);//-128
   }
   public void method5() {
      // 说出下面这句代码的错误之处!
      //因为Java是强类型语言,整数的默认类型是int
      short s1 = 1; 
      //s1 = s1 + 1;
      //不能自动将等式右边的int向下转换到short 会损失精度!
   }
   public void method4() {
      // switch(exp)仅限于int类型和String,enum类型!即char byte short int!
//      char ch='/';
      String key="a";
      //只能说高版本的可以,低版本的不支持字符串类型~
      /*switch (key) {
      case "a":
         System.out.println("a");
         break;
      default:
         break;
      }*/
   }
   @Test
   public void method3() {
      // 双重循环,在二维数组中查找到某个数字
      int arr[][] ={{1,2,3},{4,5,6,7,8},{9}};
      boolean found = false;
      for(int i=0;i<arr.length&& !found;i++){
              for(int j=0;j<arr[i].length;j++){
                  System.out.println("i=" + i +",j=" + j+"..."+arr[i][j]);
                     if(arr[i][j]  ==5) {
                            found = true;
                            break;
                     }
              }
      }
   }
   @Test
   public void method2() {
      // 在JAVA中如何跳出当前的多重嵌套循环!标记的使用~
      ok:for(int i=0;i<10;i++)     {
            for(int j=0;j<10;j++)            {
                  System.out.println("i=" + i +",j=" + j);
                  if(j == 5) break ok;
           }
      }
   }
   //自定义打印方法
   public void sop(String string) {
      System.out.println(string);
   }
}


Tools

package uncommitted;
public class Tools {
	private Object obj;
	public Object getObj(){
		return obj;
	}
	public void setObj(Object obj){
		this.obj=obj;
	}
}











评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值