• JAVA字符串String、StringBuffer、StringBuilder、基本数据类型包装


    String 字符串:

    Java中用String类进行描述。对字符串进行了对象封装,这样的好处是可以对字符串这种常见数据进行方便的操作。

    字符串String一旦被初始化就不可变,储存位置在内存方法区的常量池里。如果想要改变需要用StringBuffer函数

    构造字符串的两种方法:

    [java] view plaincopy
     
    1. String s1 = "abc";//s1指向的内存(方法区的常量池)中只有一个对象abc  
    2. String s2 = new String("abc");//两个对象,一个是常量池中的abc一个是new对象  
    3. System.out.println(s1==s2);//false,==是用来判断地址值的  
    4. System.out.println(s1.equals(s2));//true,equals是用来判断其值的  

    对于String类,有许多的API方法来调用,因为我们对于String类的要求必须熟练所以我就把经常用的API进行归纳

    获取 

    int length();获取长度
    char charAt(int index)根据位置获取位置上的某个字符
    int indexof(int ch);放回的是ch在字符串中第一次出现的位置
    int indexof(int ch,int fromIndex)从fromindex指定的 位置开始,获取ch在字符串中出现的位置
    int indexof(string str);放回的是str在字符串中第一次出现的位置
    int indexof(string str ,int fromIndex)从fromindex指定的 位置开始,获取str在字符串中出现的位置  

    判断

    boolean contains(str);字符串中是否包含某一个子串
    特殊之处:indexof(str):可以索引str第一次出现位置,如果返回-1,表示该str不在字符串中存在,所以,也可以用于对指定字符串的判断是否包含If(str.indexOf(“aa”)!=-1)
    而且该方法既可以判断,又可以获取出现的位置。
    boolean isEmpty();字符中是否有内容1.6版,原理就是判断长度是否为0,“”,null有区别。
    boolean startsWith(str);字符串是否是以指定内容开头
    boolean endsWith(str);字符串是否是以指定内容结尾
    boolean equals(str);判断字符串内容是否相同,复写了object类中的equals方法
    boolean equalsIgnoreCase();判断内容是否相同,并忽略大小写

    转换

    构造函数:
    string(char[])将字符数组转成字符串
    String(char[] ,offset,count);将字符数组中的一部分转成字符串。
    静态方法  
    Static string  copyValueof(char[]);将字符数组中的一部分转成字符串。
    Static string  copyValueof(char[] data,int offset,int count);将字符数组中的一部分转成字符串。
    Static string  Valueof(char[]);将字符数组中的一部分转成字符串。
    Char[]toCharArray();将字符串转成字符数组***
    String(byte[]);将字符数组转成字符串
    String(byte[] ,offset,count);将字节数组中的一部分转成字符串。
    Byte[] getBytes();将字符串转成字节数组

    Static string valueOf(int);将基本数据类型转成字符串
    Static string valueOf(double);将基本数据类型转成字符串
    3+””;//string.valueOf(3);将基本数据类型转成字符串
    字符串和字节数组在转换过程中,是可以指定编码表的。

    替换  

    String replace(oldchar,newchar);

    切割        

    String[] split(regex);
    子串,获取字符串中的一部分         
    String substring(begin,end);

    转换,去除空格,比较

    String toUpperCase();将字符串转成大写
    String toLowerCase();将字符串转成小写
    String trim();将字符串两端的多个空格去除
    Int compareTo(string);对两个字符串进行自然顺序的比较

    ----------------------------------------------------------

    StringBuffer字符串缓冲区

    StringBuffer:构造一个其中不带字符的字符串缓冲区,初始容量为16个字符,

    StringBuffer与String的不同之处就是它的内容是可变的,所以StringBuffer是一个容器,大小可以控制,容器内可以储存任意类型的数据,最后才变陈个字符串

    正因为是可变容器,那它就有了对容器内有了增删查改的功能了

    存储
          StringBuffer append():将指定数据作为参数添加到已有数据结尾处
          StringBuffer insert(index, 数据);可以将数据插入到指定位置
    删除
          StringBuffer delete(int start,int end);删除缓冲区中的数据,包括头不包括尾。
          StringBuffer deleteCharAt(index);删除指定位置的字符。
    获取
          char charAt(int index)
          int indexOf(String str)
          int lastindexOf(String str)
          int length()
          String substring(int start,int end)
    修改
         StringBuffer replace(int start,int end,String str)替换一部分
         void setCharAt(int index,char ch)替换一个字符
    反转
         StringBuffer reverse();这个功能能将字符串内的字符位置互换,比较常用
    将缓冲区中指定数据存储到指定字符数组中。
          void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)

    -----------------------------------------------------------------------------------

    StringBuilder字符串缓冲区(JDK1.5新特性)

    在JDK1.5的新特性里出现了StringBuilder,它的功能和StringBuffer一样,但只有一点是不一样的:
     

    StringBuilder与StringBuffer不同之处:

    1,StringBuilder线程不同步不安全,它是不加锁的并发接口

    2,单线程里StringBuilder效率高.

    [java] view plaincopy
     
    1. StringBuilder sb = new StringBuilder("abcdefg");//使用缓冲区先要建立对象  
    2.         sb.append("ak");  //abcdefgak  
    3.         sb.insert(1,"et");//aetbcdefg  
    4.         sb.deleteCharAt(2);//abdefg  
    5.         sb.delete(2,4);//abefg  
    6.         sb.setLength(4);//abcd  
    7.         sb.setCharAt(0,'k');//kbcdefg  
    8.         sb.replace(0,2,"hhhh");//hhhhcdefg  
    [java] view plaincopy
     
    1. class  Test{  
    2.     public static void main(String[] args) {  
    3.         String s1 = "java";  
    4.         String s2 = "hello";  
    5.         method_1(s1,s2);  
    6.         System.out.println(s1+"...."+s2); //java....hello  
    7.          
    8.         StringBuilder s11 = new StringBuilder("java");  
    9.         StringBuilder s22 = new StringBuilder("hello");  
    10.         method_2(s11,s22);  
    11.         System.out.println(s11+"-----"+s22); //javahello-----hello  
    12.     }  
    13.     public static void method_1(String s1,String s2){  
    14.         s1.replace('a','k');  
    15.         s1 = s2;  
    16.     }  
    17.     public static void method_2(StringBuilder s1,StringBuilder s2){  
    18.         s1.append(s2);  
    19.         s1 = s2;  
    20.     }  
    21. }  

    ------------------------------------------------------------------------------------

    基本数据类型包装

    根据JAVA面向对象的死I系那个将基本数据类型对象包装成对象

    关键字(基本数据类型)对应的类名(引用数据类型)

    byte  Byte

    short  short

    int  Integer

    long  Long

    boolean  Boolean

    float  Float

    double  Double

    char  Character

    基本数据类型对象包装类都有XXX parseXXX方法

    作用:基本数据类型和字符串类型之间的转换

    基本数据类型转为字符串.

    方式一:基本数据类型+" "

    方式二:基本数据类型.toString(基本数据类型值)

    字符串转为基本数据类型

    [java] view plaincopy
     
    1. xxx a = Xxx.parseXxx(string);  
    2. int a = Integer.parselnt(string);//这是静态调用(必须是数据格式的字符串)  
    3. int num = (new Integer("123").intValue);//非静态调用  

    好处:提供方法来进行自由转换,有了对象可以提高效率

    例如:十进制转其他进制:toBinarySting();其他进制转为十进制:parselnt(string,radix);

    JDK1.5版本之后,对基本数据类型对象包装类进行升级.例如:

    Integer i = 4;//自动装箱,隐式升级

    i= i+5;//先将i转为int类型再相加,这是隐式的转换

    [java] view plaincopy
     
      1. public class IntegerDemo1 {    
      2.     public static void main(String[] args) {    
      3.         System.out.println(Integer.MAX_VALUE);    
      4.         //Integer x=new Integer(4);    
      5.         Integer x=4;//自动装箱。1.5中可以这样写。//4等同于new Integer(4);null为空时,亦抛出异常    
      6.         x=x+2;/ *拆箱原理:x.intValue()*///x+2:x进行了自动拆箱,变成了int类型,和2进行加法运算,再将和进行装箱赋给x    
      7.         Integer m=128;    
      8.         Integer n=128;    
      9.         sop("m==n:"+(m==n));//结果:false    
      10.         Integer a=127;    
      11.         Integer b=127;    
      12.         sop("a==b:"+(a==b));//结果:true。因为a和b指向了同一个Integer对象    
      13.           //因为当数值在byte范围-128-127内容,对于新特性,如果该数值已经存在,则不会在开辟新的空间。    
      14.     }    
      15.     public static void method()    
      16.     {Integer x=new Integer("123");    
      17.     Integer y=new Integer(123);    
      18.     sop("x==y"+(x==y));    
      19.     sop("x.equals(y):"+x.equals(y));    
      20.     }    
      21.     public static void sop(String str)    
      22.     {    
      23.         System.out.println(str);    
      24.     }    
      25. }   
  • 相关阅读:
    有效的字母异位词---简单
    字符串中的第一个唯一字符---简单
    整数反转---简单
    使用httpServlet方法开发
    servlet生命周期
    tomcat_user文件的1配置
    selvlet入门自己部署(sevlet接口实现)
    数据库mysql实战
    tomcat的熟悉目录结构
    虚拟主机
  • 原文地址:https://www.cnblogs.com/hxj914103719/p/4372110.html
Copyright © 2020-2023  润新知