31.String

最新推荐文章于 2024-09-14 21:48:00 发布

weixin_30500105

最新推荐文章于 2024-09-14 21:48:00 发布

阅读量61

点赞数

文章标签： java php

原文链接：http://www.cnblogs.com/syj1993/p/8324970.html

版权

public class String_01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1="abc";  //s1是一个类类型变量，"abc"是一个对象
                          //字符串最大特点，一旦被初始化就不可以被改变。
        
        String s2=new String("abc");
        
        //s1 s2有什么区别？
        //s1在内存中有一个对象，s2在内存中有两个对象，"abc"和new 
        
        System.out.println(s1==s2); //false
        System.out.println(s1.equals(s2)); //true  String类复写了Object类中equals方法，用于判断字符串(内容)是否相同
    }

}

String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些？
    1.获取
        1.1字符串中的包含的字符数，也就是字符串的长度。
            int length():获取长度
        1.2根据位置获取位置上的字符
            char charAt(int index)
        1.3根据字符获取该字符在字符串中位置。
            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在字符串中出现的位置。
            
            int lastIndexOf(int ch):反向索引
    2.判断
        2.1字符串中是否包含某一个子串。
            boolean contains()
            特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示该str不在字符串中存在。
                所以，也可以用于对指定判断是否包含。
                if(str.indexOf("aa")!=-1),而且该方法既可以判断，又可以获取出现的位置。
        2.2字符串中是否有内容
            boolean isEmpty():原理是判断长度是否为0    ""对象   null指向空
        2.3字符串是否以指定内容开头
            boolean startsWith(str)
        2.4字符串是否以指定内容结尾
            boolean endsWith(str)
        2.5判断字符串的内容是否相同,复写了Object类中的equals方法
            boolean equals()
        2.6判断内容是否相同，并忽略大小写比较
            boolean equalsIgnoreCase()
    3.转换
        3.1将字符数组转成字符串
            构造函数：String(char[])
                   String(char[],offset,count):将字符数组中的一部分转成字符串,offset起始位置，count个数
                   
                   静态方法：static String copyValueOf(char[]):返回指定数组中表示该字符序列的字符串
                   static String copyValueOf(char[],int offset,int count)
                   
                   static String valueOf(char[]) 返回 char 数组参数的字符串表示形式
        3.2将字符串转成字符数组 **
            chra toCharArray()
        3.3将字节数组转成字符串
            String(byte[])
            String(byte[],offset,count)
        3.4将字符串转成字节字节数组
            byte[] getBytes()
        3.5将基本数据类型转成字符串
            static String valueOf(int) 
            static String valueOf(double)
            
            3+"" == String.valueOf(3)
            
            特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
    4.替换
        String replace(oldchar,newchar)
    5.切割
        String []split(regex)
    6.子串  获取字符串中的一部分
        String substring(begin)
        String substring(begin,end) 包含头，不包含尾
    7.转换、去除空格、比较
        7.1将字符串转成大写或小写
            String toUpperCase()
            String toLowerCase()
        7.2将字符串两端的多个空格去除
            String trim()
        7.3对两个字符串进行自然顺序的比较
            int compareTo(string)
        
 */
public class String_02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //method_equals();
        
        //method_get();
        
        //method_is();
        
        //trans();
        
        //method_replace();
        
        //method_split();
        
        //method_sub();
        
        method_7();
    }
    
    //相等比较
    public static void method_equals(){
        String s1="abc";
        String s2=new String("abc");
        String s3="abc";
        
        System.out.println(s1==s2);
        System.out.println(s1==s3);//s3创建的时候发现常量池中已经存在abc，不会继续创建，s1 s3指向同一个对象  
    }
    
    //判断
    public static void method_get(){
        String str="abcdeakpf";
        
        //长度
        sop(str.length());
        
        //根据索引获取字符
        sop(str.charAt(4)); //访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException
        
        //根据字符获取索引
        sop(str.indexOf('m',3)); //如果没有找到，返回-1
        
        sop(str.indexOf("e"));
        
        //反向索引一个字符出现的位置(最后一次出现时的索引，索引值跟正向数相同)
        sop(str.lastIndexOf('a'));
    }
    
    //获取
    public static void method_is(){
        String str="ArrayDemo.java";
        
        sop(str.startsWith("Array"));
        sop(str.endsWith(".java"));
        sop(str.contains("Demo"));
        
    }
    
    //转换
    public static void trans(){
        char [] arr={'a','b','c','d','e','f'};
        
        String str=new String(arr);
        String str1=new String(arr,1,4); //起始位置，个数
        
        sop(str);
        sop(str1);
        sop(str.copyValueOf(arr));
        
        String str2="zxcvbnm";
        
        char[] chs=str2.toCharArray();
        for(int i=0;i<chs.length;i++){
            System.out.print(chs[i]+",");
        }
    }

    //替换
    public static void method_replace(){
        String str="hello java";
        
        String str1=str.replace('a', 'n'); //如果被替换的字符不存在，则返回原来的字符串
        String str2=str.replace("java","php");
        
        sop(str); //hello java
        sop(str1);//hello jnvn
        sop(str2);//hello php
    }
    
    //子串
    public static void method_sub(){
        String s="abcdefg";
            
        sop(s.substring(2)); //cdefg
        sop(s.substring(2, 4)); //cd
    }
        
    //切割
    public static void method_split(){
        String str="zhangsan,lisi,wangwu";
            
        String[] str1=str.split(",");
            
        for(int i=0;i<str1.length;i++){
            sop(str1[i]);
        }
    }
    
    //转换、空格、比较
    public static void method_7(){
        String str="  Hello Java  ";
        
        sop(str.toLowerCase());//带空格     hello java
        sop(str.toUpperCase());
        sop(str.trim());
        
        String str1="acc";
        String str2="aaa";
        
        sop(str1.compareTo(str2)); //1
        //如果参数字符串等于此字符串，则返回 0 值；如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值。
    }
    
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

StringBuffer 是字符串缓冲区
可以对字符串进行增删
是一个容器
特点：
　　1.可变长度
　　2.可以直接操作多个数据类型
　　3.最终会通过toString()方法变成字符串

1.存储
　　StringBuffer append():将制定数据作为参数添加到已有数据结尾处
　　StringBuffer insert(index,string):可以字符串插入到指定位置
2.删除
　　StringBuffer delete(start,end):删除缓冲区中的数据，包括start，不包括end
　　StringBuffer deleteCharAt(int):删除指定位置的字符
3.获取
　　char charAt(int index)
　　int indexOf(String str)
　　int lastIndexOf(String str)
　　int length()
　　String substring(int start,int end)
4.修改
　　StringBuffer replace(int start,int end,String str)
　　void setCharAt(int,char)
5.反转
　　reverse()

JDK1.5版本后出现了StringBuilder
StringBuffer是线程同步的，安全
StringBuilder是线程不同步的，不安全，但快捷

升级三个因素：
　　1.提高效率
　　2.提高书写
　　3.提高安全性

public class StringBuffer_04 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //add();
        
        //delete();
        
        update();
        
    }

    public static void add(){
        StringBuffer sb=new StringBuffer();
        StringBuffer sb1=sb.append(34);
        
        sop((sb==sb1)+"");//true sb为容器，添加了东西，仍然还是那个容器
        sop(sb.toString());
        sop(sb1.toString());
        
        sb.insert(1, "qq");
        System.out.println(sb.toString());
    }
    
    public static void delete(){
        StringBuffer sb=new StringBuffer("abcde");
        
        sb.delete(1, 3);
        sop(sb.toString());
        
        //删除一个字符
        sb.deleteCharAt(2);
        sop(sb.toString());
        
        //清空缓冲区
        sb.delete(0,sb.length());
        sop(sb.toString()+"...");
    }
    
    public static void update(){
        StringBuffer sb=new StringBuffer("abcde");
        
        sb.replace(1, 4, "java");
        
        sb.setCharAt(2,'k');
        
        sop(sb.toString());
    }
    
    public static void sop(String str){
        System.out.println(str);
    }
}

包装类

基本数据类型对象包装类
基本数据类型引用数据类型
byte　　Byte
short 　 Short
int 　　 Integer
long　 Long
boolean Boolean
float 　 Float
double Double
char 　 Character

基本数据类型包装类最常用的作用：
用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串
基本数据类型+"　"
基本数据类型.toString(基本数据类型值)
如：Integer.toString(34); //将34整数变成"34"
字符串转成基本数据类型
xxx a=XXX.parseXXX(String str)
int a=Integer.parseInt("123");
boolean b=Boolean.parseBoolean("true");

Integer i=new Integer("123");
int num=i.intValue();
十进制转成其他进制
toBinaryString()
toHexString()
其他进制转成十进制
parseInt(String,int radix)

JDK1.5以后出现的新特性

public class BaoZhuang_05 {

    public static void main(String[] args) {
        
        //整数类型的最大值
        sop("int max:"+Integer.MAX_VALUE);
        
        //将一个字符串转成整数
        int num=Integer.parseInt("123");
        long x=Long.parseLong("2222");
        sop("num="+num);
        sop("x="+x);
        
        boolean y=Boolean.parseBoolean("true");
        sop("y="+y);
        
        //进制转换
        sop(Integer.toBinaryString(6)); //110
        sop(Integer.toHexString(60)); //3c
        
        int xx=Integer.parseInt("110",10);
        sop("xx="+xx);
        
        
        Integer in1=new Integer("123");
        Integer in2=new Integer(123);
        sop("in1 equals in2:"+(in1.equals(in2))); //重写equals方法，比较数值是否相同
        sop("in1==in2:"+(in1==in2));
        
        Integer in3=new Integer(4);
        Integer in4=4;  //简化，自动装箱
        
        in4=in4+2; //in4+2:进行了自动拆箱，变成int类型，和2进行加法运算，再将和进行装箱赋给in4
        
    }
    
    public static void sop(String str){
        System.out.println(str);
    }

}