精华内容
下载资源
问答
  • String 类的常用方法

    千次阅读 2019-04-18 13:58:42
    String 类的常用方法 equals 字符串是否相同 equalsIgnoreCase 忽略大小写后字符串是否相同 compareTo 根据字符串中每个字符的Unicode编码进行比较 compareToIgnoreCase 根据字符串中每个字符的...

    String 类的常用方法

    equals 字符串是否相同
    equalsIgnoreCase 忽略大小写后字符串是否相同
    compareTo 根据字符串中每个字符的Unicode编码进行比较
    compareToIgnoreCase 根据字符串中每个字符的Unicode编码进行忽略大小写比较
    indexOf 目标字符或字符串在源字符串中位置下标
    lastIndexOf 目标字符或字符串在源字符串中最后一次出现的位置下标
    valueOf 其他类型转字符串
    charAt 获取指定下标位置的字符
    codePointAt 指定下标的字符的Unicode编码
    concat 追加字符串到当前字符串
    isEmpty 字符串长度是否为0
    contains 是否包含目标字符串
    startsWith 是否以目标字符串开头
    endsWith 是否以目标字符串结束
    format 格式化字符串
    getBytes 获取字符串的字节数组
    getChars 获取字符串的指定长度字符数组
    toCharArray 获取字符串的字符数组
    join 以某字符串,连接某字符串数组
    length 字符串字符数
    matches 字符串是否匹配正则表达式
    replace 字符串替换
    replaceAll 带正则字符串替换
    replaceFirst 替换第一个出现的目标字符串
    split 以某正则表达式分割字符串
    substring 截取字符串
    toLowerCase 字符串转小写
    toUpperCase 字符串转大写
    trim 去字符串首尾空格

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • String类的常用方法

    2020-12-12 20:03:54
    String类的常用方法 1. String类的两种实例化方式 1 . 直接赋值,在堆上分配空间。 String str = "hello"; 2 . 传统方法。通过构造方法实例化String类对象 String str1 = new String("Hello"); 2.采用String...

    String类的常用方法

    1. String类的两种实例化方式

    • 1 . 直接赋值,在堆上分配空间。
    String str = "hello";
    
    • 2 . 传统方法。通过构造方法实例化String类对象
    String str1 = new String("Hello");
    
    

    2.采用String类提供的equals方法。

    public boolean equals(String anotherString):成员方法
    				str1.equals(anotherString);
    eg:
    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = "hello";
            System.out.println(str1==str2);
        }
    }
    运行结果:true
    eg:
    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = new String("hello");
            System.out.println(str1==str2);
        }
    }
    运行结果:false
    eg:
    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = new String("hello");
            System.out.println(str1.equals(str2));
        }
    }
    运行结果:true
    1234567891011121314151617181920212223242526272829
    

    3.== he和equals方法区别

    1. ”==”:进行的数值比较,比较的是两个字符串对象的内存地址数值。
    2. “equals()”:可以进行字符串内容的比较

    4.字符串常量(“ “)是String的匿名对象

    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            System.out.println("hello".equals(str1));
        }
    }
    如果能够运行成功,说明字符串“hello”是String的匿名对象
    运行结果:true
    12345678
    

    小tips:以后开发中,如果要判断用户输入的字符串是否等同于特定字符串,一定要将特定字符串(String常量)写在前面,避免空指针异常(NullPointerException)。

    System.out.println(str1.equals(“hello”)); 错误

    System.out.println(“hello”.equals(str1)); 正确

    5.字符串共享问题

    JVM底层会自动维护一个字符串的对象池(对象数组),如果现在采用直接赋值的形式进行String的对象实例化,该对象会自动保存在这个对象池中。如果下次继续使用直接赋值的模式声明String对象,此时对象池中若有指定内容,则直接引用;如果没有,则开辟新的堆空间后将其保存在对象池中供下次使用。

    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = "hello";
            String str3 = "hello";
    
            System.out.println(str1==str2);
            System.out.println(str2==str3);
            System.out.println(str1==str3);
        }
    }
    运行结果:
    true
    true
    true
    
    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = new String("hello");
            System.out.println(str1==str2);
        }
    }
    new新开辟了空间
    运行结果:false
    12345678910111213141516171819202122232425
    

    手工入池(本地方法):

    public native String intern();
    eg:
    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            String str2 = new String("hello").intern();
            System.out.println(str1==str2);
        }
    }
    运行结果:true
    12345678910
    
    1. 直接赋值:只会开辟一块堆内存空间,并且该字符串对象可以自动保存在对象池中以供下次使用。
    2. 构造方法:会开辟两块堆内存空间,其中一块成为垃圾空间,不会自动保存在对象池中,可以使用intern()方法手工入池。
      因此,我们一般会采取第一种方式即直接赋值。

    6.字符串一旦定义后不可变。

    public class Demo2{
        public static void main(String[] args){
            String str1 = "hello";
            str1 += " world";
            str1 += "!!!";
            System.out.println(str1);
        }
    }
    运行结果:hello world!!!
    其实字符串没有变化,是字符串的引用一直在改变,而且会形成大量的垃圾空间。
    12345678910
    

    原则:

    1. 字符串使用就采用直接赋值。
    2. 字符串比较就使用equals()实现。
    3. 字符串别改变太多。(字符串”+“操作,不超过三次)。

    7.字符与字符串的相互转换

    a.将字符数组转为字符串 -> String

    --public String(char[] value) //将数组中的全部字符转换成字符串
    eg:
    public class Demo2{
        public static void main(String[] args){
            char[] data = new char[]{'h','e','l','l','o'};
            String str = new String(data);
            System.out.println(str);
        }
    }
    运行结果:hello
    
    --public String(char[] value,int offset,int count) //将数组中的部分字符转换成字符串
    eg:
    public class Demo2{
        public static void main(String[] args){
            char[] data = new char[]{'h','e','l','l','o'};
            String str = new String(data,2,3);
            System.out.println(str);
        }
    }
    运行结果:llo
    123456789101112131415161718192021
    

    b.将字符串转为单个字符

    public char charAt(int index):
    eg:
    public class Demo2{
        public static void main(String[] args){
            char c = "hello".charAt(4);
            System.out.println(c);
        }
    }
    运行结果:o
    123456789
    

    c.将字符串变为字符数组:String -> char[]

    --public char[] tocharArray();
    eg:
    public class Demo2{
        public static void main(String[] args){
            char[] c = "hello".toCharArray();
            System.out.println(c);
            System.out.println("hello".length()); //字符串是方法
            System.out.println(c.length);   //数组是属性
        }
    }
    运行结果:
    hello
    5
    5
    1234567891011121314
    

    8.取得字符串长度:public int length();

    //判断一个字符串是否由数字组成
    public class Demo2{
        public static void main(String[] args){
            System.out.println(isNumber("123"));
        }
        public static boolean isNumber(String str){
            char[] data = str.toCharArray();
            for(int i=0;i<data.length;i++){
                if(data[i]<'0' || data[i]>'9'){
                    return false;
                }
            }
            return true;
        }  
    }
    运行结果:
    true
    1234567891011121314151617
    

    9.字节(Byte)与字符串

    a.将字节数组转换为字符串(重点)

    byte[] ->String
    
    public String(byte[]  value)
    eg:
    public class Demo2{
        public static void main(String[] args){
            byte[] data = new byte[]{1,2,3,4,5};
            String str = new String(data);
            System.out.println(str);
        }
    }
    
    public String(byte[]  value,int offset,int count)//将字节数组的指定字节转换成字符串
    123456789101112131415
    

    b.将字符串转为字节数组 (重点)

    String->byte[]
    
    public byte[] getBytes();
    eg:
    public class Demo2{
        public static void main(String[] args){
            String str = "hello";
            byte[] data = str.getBytes();
            for(byte b:data){
                System.out.print(b+"、");
            }
        }
    }
    运行结果:
    104、101、108、108、111、
    123456789101112131415
    

    c.将字符串按指定编码转为字节数组

    public byte[] getBytes(String charsetName);
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str = "你好世界";
            byte[] data = str.getBytes("gbk");
            for(byte b: data){
                System.out.print(b+"、");
            }
            System.out.print(new String(data));
        }
    }
    (根据编码的不同,结果也相应不同)
    运行结果:
    -60、-29、-70、-61、-54、-64、-67、-25、你好世界
    123456789101112131415
    

    10.字符串比较

    a.不区分大小写相等比较

    public boolean equalsIgnoreCase(String anotherString)
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str = "hello";
            System.out.println("Hello".equalsIgnoreCase(str));
        }
    }
    运行结果:true
    123456789
    

    b. 比较两个字符串大小

    public int compareTo(String anotherString)
    
    I.返回大于0:表示大于比较对象
    
    II.返回等于0:两者相等
    
    III.返回小于0:表示小于比较对象
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "Hello";
            String str2 = "hellO";
            System.out.println(str1.compareTo(str2));
        }
    }
    只要遇到第一个不同的进行比较。
    运行结果:
    -32
    【支持中文】
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "张";
            String str2 = "李";
            System.out.println(str1.compareTo(str2));
        }
    }
    运行结果:
    -2094
    12345678910111213141516171819202122232425262728
    

    11.字符串查找(重点)

    1. 判断str在本字符串中是否存在
        public boolean contains(String str) :判断str在本字符串中是否存在
        eg:
        public class Demo2{
            public static void main(String[] args) throws Exception{
                String str1 = "he";
                String str2 = "hello";
                System.out.println(str2.contains(str1));
            }
        }
        运行结果:true
    12345678910
    
    1. 判断是否以指定字符串开头
     public boolean startsWith(String str) : 判断是否以指定字符串开头
        eg:
        public class Demo2{
            public static void main(String[] args) throws Exception{
                String str1 = "he";
                String str2 = "hello";
                System.out.println(str2.startsWith(str1));
            }
        }
        运行结果:true
    12345678910
    
    1. 从指定位置判断是否以指定字符串开头
      public boolean startsWith(String str,int index) : 从指定位置判断是否以指定字符串开头
        eg:
        public class Demo2{
            public static void main(String[] args) throws Exception{
                String str1 = "ll";
                String str2 = "hello";
                System.out.println(str2.startsWith(str1,2));
            }
        }
        运行结果:true
    12345678910
    
    1. 判断是否以指定字符串结尾
     public boolean endsWith(String str) : 判断是否以指定字符串结尾
        eg:
        public class Demo2{
            public static void main(String[] args) throws Exception{
                String str1 = "lo";
                String str2 = "hello";
                System.out.println(str2.endsWith(str1));
            }
        }
        运行结果:true
    
    1234567891011
    

    12.字符串替换

    public String replaceAll(String regex,String replacement) :替换所有指定内容
    public String replaceFirst(String regex,String replacement) :替换首个内容
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str = "hello world";
            System.out.println(str.replaceAll("l","-"));//替换所有指定内容
            System.out.println(str.replaceFirst("l","-"));//替换首个内容
        }
    }
    运行结果:he--o wor-d
    运行结果:he-lo world
    123456789101112
    

    13.字符串拆分

    ——public String[] split(String regex) :将字符串按照指定格式全部拆分
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "hello world hello java";
            String[] result = str1.split(" ");
            for(String str:result){
                System.out.println(str);
            }
        }
    }
    运行结果:
    hello
    world
    hello
    java
    
    ——public String[] split(String regex,int limit) : 将字符串部分拆分,数组长度为limit
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "hello world hello java";
            String[] result = str1.split(" ",2);
            for(String str:result){
                System.out.println(str);
            }
        }
    }
    运行结果:
    hello
    world hello java
    
    //拆分地址
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "196.168.1.1";
            String[] result = str1.split("\\."); //注意这里有转义字符
            for(String str:result){
                System.out.println(str);
            }
        }
    }
    运行结果:
    196
    168
    1
    1
    1234567891011121314151617181920212223242526272829303132333435363738394041424344454647
    

    15.字符串截取

    public String substring(int beginIndex):[ 从指定位置截取到字符串的结尾
    public String substring(int beginIndex,int endIndex):[) 截取部分内容
    
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "helloworld";
            String result1 = str1.substring(3);//从指定位置截取到字符串的结尾
            String result2 = str1.substring(3,6);//截取部分内容
            System.out.println(result1);
            System.out.println(result2);
        }
    }
    运行结果:
    loworld
    low
    12345678910111213141516
    

    16.String 类其他方法

    a.去掉左右空格

    public String trim();
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = " hello world ";
            String result = str1.trim();
            System.out.print(result);
        }
    }
    运行结果:
     hello world
    1234567891011
    

    b.转大小写

    public String toUpperCase(); //小写转大写
    public String toLowerCase(); //大写转小写
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "hello world";
            String str2 = "HELLO WORLD";
            String result1 = str1.toUpperCase();
            System.out.println(result1);
            System.out.println(str2.toLowerCase());
        }
    }
    运行结果:
    HELLO WORLD
    hello world
    123456789101112131415
    

    String类并没有提供首字母大写操作,需要自己实现。

    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str = "hello";
            System.out.print(firstCase(str));
        }
        public static String firstCase(String str){
            return str.substring(0,1).toUpperCase() + str.substring(1);
        }
    }
    运行结果:
    Hello
    1234567891011
    

    c.判断字符串是否为空(只能判断是否为空字符串,而不是null;

    public boolean isEmpty();
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
            String str1 = "";
            String str2 = "haha";
            System.out.println(str1.isEmpty());
            System.out.println(str2.isEmpty());
        }
    }
    运行结果:
    true
    false
    
    if(str == null || str.isEmpty())  //完整的空字符串的方法
    123456789101112131415
    

    StringBuffer

    StringBuilder

    a.字符串修改

    public StringBuffer append(各种数据类型)
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer();
           sb.append("hello").append("world").append(10);
           System.out.println(sb);
        }
    }
    运行结果:
    helloworld10
    1234567891011
    

    b.StringBuffer <->String

    I.String -> StringBuffer
    调用StringBuffer的构造方法或append()
    
    II.StringBuffer.toString();
     StringBuffer.toString();
     
     eg:
     public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer("hello");
           String result = sb.toString();
           System.out.println(result.isEmpty());
        }
    }
    运行结果:
    false
    12345678910111213141516
    

    c.字符串反转

    public StringBuffer reverse();
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer("helloworld");
           sb.reverse();
           System.out.println(sb);
        }
    }
    运行结果:
    dlrowolleh
    
    【支持中文】
    public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer("你好");
           sb.reverse();
           System.out.println(sb);
        }
    }
    运行结果:
    好你
    12345678910111213141516171819202122
    

    d.删除指定范围的数据

    public StringBuffer delete(int start,int end);
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer("hello world");
           sb.delete(0,4);
           System.out.println(sb);
        }
    }
    运行结果:
    o world
    1234567891011
    

    e.插入数据

    public StringBuffer insert(int offset,各种数据类型)
    eg:
    public class Demo2{
        public static void main(String[] args) throws Exception{
           StringBuffer sb = new StringBuffer("hello world");;
           System.out.println(sb.insert(5,"(你好)"));
        }
    }
    运行结果:
    hello(你好) world
    12345678910
    

    I.string的内容不可修改,而两只sb可以修改内容(append)
    II.StringBuffer 采用同步处理,线程安全,效率较低。

    StringBuilder采用异步处理,线程不安全,效率较高,String"+"底层会将String -> StringBulider

    展开全文
  • string类的常用方法

    2019-07-26 09:22:18
    java把String类声明final类,不能有类。String类对象创建后不能修改,由0或多个字符组成,包含在一对双引号之间。 二、String类对象创建 字符串声明:String stringName; 字符串创建:stringName = new String...

    一、String类

    String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象。java把String类声明的final类,不能有类。String类对象创建后不能修改,由0或多个字符组成,包含在一对双引号之间。

    二、String类对象的创建

    字符串声明:String stringName;

    字符串创建:stringName = new String(字符串常量);或stringName = 字符串常量;

    三、String类常用方法

    1.int length():获取字符串的长度

    2.char charAt(int index):获取指定的索引处的字符串

    3.int indexOf(String str):获取str在字符串对象中第一次出现的索引

    4.String substring(int start):从start开始截取字符串

    5.String substring(int start,int end):从start开始截取字符,到end结束截取字符

    6.char[ ] toCharArray():把字符串转换为字符数组;

    7.String toLowerCase():把字符串转换为小写字符串

    8.String toUpperCase():把字符串转换为小写字符串

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,021
精华内容 4,808
关键字:

string类的常用方法