【Java学习】认识String类【详解篇16】

最新推荐文章于 2021-11-05 22:42:54 发布
最新推荐文章于 2021-11-05 22:42:54 发布
阅读量118 收藏
点赞数 2
分类专栏： java篇 编程语言基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59157222/article/details/120599371
版权
本文详细讲解了Java中的String类，包括定义字符串的不同方式、字符串常量池、比较和操作技巧（如首字母大写、字符串反转、连接与拆分）。深入理解字符串的不可变性，以及如何使用StringBuilder和 StringBuffer进行高效操作。
摘要由CSDN通过智能技术生成

【前言】代码的注释较多，因为还有很多细节的知识点大都写在代码的注释中，我觉得将知识点和代码结合起来可能会更容易理解，所以很多时候还是结合代码来看会更好。

文章目录

认识String类

C语言当中是没有字符串类型的，但是在Java当中是有字符串类型的。

如何定义一个字符串？

public static void main(String[] args) {
        String str1="hello";//写法一
        System.out.println(str1);
        String str2=new String("abcdef");//写法二：调用了带有一个参数的String构造方法，来构造String
        //对象，并赋值给str2
        System.out.println(str2);
        char[] val={'h','i','g','k','l','m'};//写法三
        String str3=new String(val);
        System.out.println(str3);
        //offset：起始位置的偏移量
        //定义字符串平常用的最多的就是这三种方式，这三种方式中用的最多的是第一种
        //△提醒：在真正的笔试面试过程当中，字符串、数组和单链表的题型是非常多的，建议多多练习刷题。
    }

字符串的比较

public static void main(String[] args) {
        //比较str1、str2、str3,判断是否相等？
        /*str1和str2是引用类型，引用类型放的是地址，所以等号两边比较的值是地址*/
        String str1="hello";
        String str2=new String("hello");
        System.out.println(str1==str2);//F

        String str3="hello";
        System.out.println(str1==str3);//T
    }

上述代码为false和true的原因：代码所对应的内存底层的位置如图所示

image-20210925220311231

image-20210925215328818

public static void main(String[] args) {
        String str1="hello";
        String str2="hel"+"lo";
        //双引号引起来的叫做字符串常量，常量有一个特点是:在编译时已经处理完了，也就是说常量在编译时就已经变成“hello"了
        System.out.println(str1==str2);//T
        String str3=new String("hel")+"lo";
        System.out.println(str3==str1);//F
    }

上述代码为false和true的原因：代码所对应的内存底层的位置如图所示

image-20210925222850099

字符串常量池

字符串常量池的特点：

1、在JDK1.7开始，这个常量池被挪到堆里面了

2、在常量池里面所存放的数据是不重复的

3、字符串常量池并不是用来放常量的，它只放字符串常量

代码示例：

public static void main4(String[] args) {
        //《字符串常量池》
        //修改str1，str2会改变吗？
        String str1="hello";
        String str2=str1;
        System.out.println(str1);
        System.out.println(str2);

        str1="AAA";
        System.out.println(str1);
        System.out.println(str2);
//引用的指向发生了改变，如果通过str1去修改其指向的内容，str2会发生改变，但是在java字符串是常量，常量是不能被修改的。
    }
 public static void func(String str,char[] array) {//定义一个方法，并传参
        str="aaaaaa";
        array[0]='g';
    }
    public static void main5(String[] args) {
        String str1="hello";
        char[] val={'a'};
        System.out.println(str1);
        System.out.println(Arrays.toString(val));
        func(str1,val);//调用func,并将str1和val的值传过去
        System.out.println(str1);//结果没变
        System.out.println(Arrays.toString(val));//结果变了
    }

image-20210926182917687

字符串比较相等

 public static void main6(String[] args) {
        String str1="hello";
        String str2=new String("hello");
        System.out.println(str1==str2);//这里比较的是引用
        System.out.println(str1.equals(str2));//这里比较的是字符串的内容
        //如果想要比较字符串的内容是否相同可以使用equals
        //一般情况下，如果调用equals,没有重写的话默认是调用Object的equals方法，他的实现是默认比较引用是否相同。
        String str3="hello";
        System.out.println(str1==str3);//
        System.out.println(str1.equals(str3));
    }
/*使用equals需要有一些注意事项：
     * equals点号前面不能是null,否则会报错出现空指针异常，但是equals后面的括号是可以为null的，所以一般情况下，
     * 使用写法1方式写比较好，避免出现空指针异常*/
    public static void main7(String[] args) {
        String str1=null;
        String str2=new String("hello");
        System.out.println(str2.equals(str1));//写法1
        System.out.println(str1.equals(str2));//写法2
    }
//写法1
public static void main8(String[] args) {
        String str1="hello";
        String str2=new String("hello");
        System.out.println(str1==str2);//打印结果：false
    }
//写法2
public static void main8(String[] args) {
        String str1="hello";
        String str2=new String("hello").intern();
        System.out.println(str1==str2);//打印结果：true
    }

为false的原因如图：

image-20210926183442563

为true的原因如图：

image-20210926183515356

理解字符串不可变

public static void main9(String[] args) {
        String str="hello";//str是常量，"hello"是变量,这里表示变量str所指向的是一个常量
        str=str+"world";//在编译的时候str和”world“是不会进行拼接的，因为str是常量，”world“是变量
        str+="!!!";
        System.out.println(str);//打印结果：helloworld!!!
        for(int i=0;i<1000;i++){
            str+=1;
        }
/*这种拼接字符串的方式不可取，因为虽然只要最后一次的结果，但是实质在堆中已经产生了大量的临时变量
所以不能这样拼接字符串，那该怎么拼接呢？后面会学习:StringBuffer、StringBuilder,通过这两个可以解决这个问题，但这里暂且先不说。
 注意：字符串在java中是一个常量，每次拼接都会产生一个新的对象
 字符串不可变就是只要拼接或者指向其他的，只会生成一个全新的而不会在原来的基础上进行修改。*/
    }
 public static void main11(String[] args) throws NoSuchFieldException, IllegalAccessException {
        String str="Hello";
        //如何以修改的方式将大写的H改成小写的h呢？
        //需要利用反射，反射就是java程序自省的过程，也可以认为是java程序的一个bug
        //反射一般用在框架当中，反射的特点是在类外不仅可以获得私有方法，所有的东西在类外都可以使用反射的达到。
        /*要反射一个类，第一步是要拿到这个类的class对象,通过.class就可以拿到*/
        Class cl=String.class;
        Field field = cl.getDeclaredField("value");//括号里的value并不是随便写的，而是指拿到String里面的value字段
        field.setAccessible(true);//设置为true相当于说原来是私有的，设置为true就可以修改它了（相当于把它的权限打开了），不设置为true的话，反射修改也修改不了。
        char[] value=(char[]) field.get(str);//把结果强转成一个char类型的数组,此时value里面就拿到了需要的value数据
        value[0]='h';//这时就可以通过修改0号下标进行修改了
        System.out.println(str);//打印结果：hello,这时就被修改了
//所以，通过反射可以去修改私有的东西
        /*对于反射只需要明白：什么是反射？反射可以做什么？就好了*/
        
    }
    public static void main10(String[] args) {
        String str = "Hello";
        str = "h" + str.substring(1);//substring(1)表示从字符串的1号位置进行提取，提取完之后就变成了ello,然后小写h
        //拼上赋值给str，再打印，但是在这个过程中并不是把原来的Hello修改成hello，而是又产生了一个新的hello对象
        System.out.println(str);
    }

总结:

1、当遇到字符串，要明白它的内存结构；

2、字符串的不可变是什么意思；

3、在函数的内修改它的指向并不会影响实参的指向。

字符、字节与字符串

字符与字符串

字符串内部包含一个字符数组，String 可以和 char[] 相互转换.。

下面是字符和字符串之间的相互转换用到的方法和代码示例

1️⃣将字符数组中的所有内容变为字符串:使用构造方法，public String（char value[]）

 public static void main1(String[] args) {
        /*String 有一个参数char value[]：将字符数组中的所有内容变为字符串*/
        char[] value={'q','w','e','r','t','y'};
        String str=new String(value);
        System.out.println(str);
    }
//打印结果：qwerty

2️⃣将部分字符数组中的内容变为字符串:使用构造方法public String（char value[]，int offset,int count）

public static void main(String[] args) {
        /*String 有两个参数char value[]，int offset,int count将部分字符数组中的内容变为字符串*/
        char[] value={'q','w','e','r','t','y'};
        String str=new String(value,1,3);//偏移量
        System.out.println(str);
    }
//打印结果：wer

3️⃣取得指定索引位置的字符，索引从0开始：使用普通方法 public char charAt(int index)

public static void main(String[] args) {
        //取得指定索引位置的字符，索引从0开始
        String str2="hello";
        char ch=str2.charAt(0);
        System.out.println(ch); 
    }
//打印结果：h

4️⃣将字符串变为字符串数组返回：使用普通方法 public char[] toCharArray()

  public static void main(String[] args) {
        //将字符串变为字符串数组返回
       String str2="hello";
       char[] value2= str2.toCharArray();
       System.out.println(Arrays.toString(value2));
    }
//打印结果：[h, e, l, l, o]

代码示例: 给定字符串一个字符串, 判断其是否全部由数字所组成.

思路: 将字符串变为字符数组而后判断每一位字符是否是" 0 “~”‘9’"之间的内容，如果是则为数字.

//给一个字符串, 判断其是否全部由数字所组成.
    public static boolean isNumber(String str) {//定义一个函数，将str传过去
        for(int i=0;i<str.length();i++){
            char ch=str.charAt(i);//通过charAt访问字符串下标
            if(ch<'0'||ch>'9'){
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String str="1234567";
        boolean flg=isNumber(str);//flg接收，类型为 boolean
        System.out.println(flg);
    }
//打印结果：true
字节与字符串

字节常用于数据传输以及编码转换的处理之中，String 也能方便的和 byte[] 相互转换。

字节与字符串的相互转换

1️⃣将字节数组变为字符串：使用构造函数，public String (byte bytes[])

public static void main(String[] args) {
        //通过字节数组构造字符串
        byte[] bytes={97,98,99,100};
        String str=new String(bytes);
        System.out.println(str);
    }
//打印结果：abcd

2️⃣将部分字节数组中的内容变为字符串：使用构造函数，public String (byte bytes[]，int offset,int length)

3️⃣将字符串以字节数组的形式返回：使用普通函数，public byte[] getBytes()

public static void main(String[] args) {
        String str1="abcdef";
        byte[] bytes1=str1.getBytes();
        System.out.println(Arrays.toString(bytes1));
    }
//打印结果：[97, 98, 99, 100, 101, 102]

4️⃣编码转换处理:使用普通方法，public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

 public static void main(String[] args) throws UnsupportedEncodingException {
        String str2="呵呵";
        byte[] bytes2=str2.getBytes("utf-8");
     System.out.println(Arrays.toString(bytes2));
    }
//打印结果：[-27, -111, -75, -27, -111, -75]

小结：

那么何时使用 byte[], 何时使用 char[] 呢?

  • byte[] 是把 String 按照一个字节一个字节的方式处理（如视频、音频）, 这种适合在网络传输, 数据存储这样的场景下使用（）. 更适合

针对二进制数据来操作.

  • char[] 是吧 String 按照一个字符一个字符的方式处理, 更适合针对文本数据来操作, 尤其是包含中文的时候。

回忆概念: 文本数据 vs 二进制数据

一个简单粗暴的区分方式就是用记事本打开能不能看懂里面的内容.

如果看的懂, 就是文本数据(例如 .java 文件), 如果看不懂, 就是二进制数据(例如 .class 文件

字符串常见操作

字符串比较

上面使用过String类提供的equals()方法，该方法本身是可以进行区分大小写的相等判断。除了这个方法之外，String类还提供有如下的比较操作：

NO方法名称类型描述
1public boolean equals(Object anObject)普通区分大小写比较
2public boolean equalsIanoreCase(String anotherString)普通不区分大小写比较
3public int compareTo(String anotherString)普通比较两个字符串的大小关系

代码示例：

public static void main(String[] args) {
        String str1="ABCDEF";
        String str2="abcdef";
    //(1)区分大小写比较
        System.out.println(str1.equals(str2));
    //(2)忽略大小写进行比较
        System.out.println(str1.equalsIgnoreCase(str2));
    //(3)compareTo方法比较两个字符串的大小关系
    
        String str3="abc";
        System.out.println(str3.compareTo(str2));
        //str3>str2    返回的是一个正数
        //str3<str2    返回的是一个负数
        //str3=str2    返回的是一个0
        System.out.println("巴".compareTo("王"));//java当中用的是unicode表，"巴"和"王"都是一个字符
        // 它们在unicode表中对应一个数字
    }
//打印结果：
false
true
-3
-5527

在String类中compareTo()方法是一个非常重要的方法，该方法返回一个整型，该数据会根据大小关系返回三类内容：

  1. 相等：返回0.
  2. 小于：返回内容小于0.
  3. 大于：返回内容大于0

compareTo()比较的代码示例：

System.out.println("A".compareTo("a")); // -32 
System.out.println("a".compareTo("A")); // 32 
System.out.println("A".compareTo("A")); // 0 
System.out.println("AB".compareTo("AC")); // -1 
System.out.println("刘".compareTo("杨"));

compareTo()是一个可以区分大小关系的方法，是String方法里是一个非常重要的方法。

字符串的比较大小规则, 总结成三个字 “字典序” 相当于判定两个字符串在一本词典的前面还是后面. 先比较第1个字符的大小(根据 unicode 的值来判定), 如果不分胜负, 就依次比较后面的内容.

字符串查找

从一个完整的字符串之中可以判断指定内容是否存在，对于查找方法有如下定义：

NO方法名称类型描述
1public boolean contains(CharSequence s)普通判断一个子字符串是否存在
2public int indexOf(String str)普通从头开始查找指定字符串的位置，查到了返回位置的开始索引，如果查不到返回-1
3public int indexOf(String str,int formIndex)普通从指定位置开始查找子字符串的位置
4public int lastIndexOf(String str)普通由后向前查找子字符串的位置
5public int lastIndexOf(String str,int fromIndex)普通从指定位置由后向前查找
6public boolean startsWith(String prefix)普通判断是否以指定字符串开头
7public boolean startsWith(String prefix,int toffset)普通从指定位置开始判断是否以指定字符串开头
8public boolean endWith(String suffix)普通判断是否以指定字符串结尾

1️⃣contains()方法：判断一个子字符串是否存在

public static void main(String[] args) {
        //《字符串查找》
        //contains()方法：判断一个子字符串是否存在
        String str="aaabbbcccddd";
        boolean flg= str.contains("abc");//contain的返回值是boolean类型,判断是否包含字符串
        System.out.println(flg);
        boolean flg1= str.contains("aaa");
        System.out.println(flg1);
    }
//打印结果：true

boolean flg= str.contains(“abc”)这里，为什么可以传字符串呢？

因为contains的返回值是boolean类型，参数是CharSequence

image-20210927082523956

而String的源码实现了CharSequence 接口，所以可以这样写！

image-20210927082236367

2️⃣indexOf（）方法

//indexOf()方法:传一个参数，从头开始查找指定字符串的位置，查到了返回位置的开始索引，如果查不到返回-1
        String str1="aaabcabcabcd";
        int ret1=str1.indexOf("abc");//indexOf的返回值是int类型
        System.out.println(ret1);
//indexOf()方法:传两个参数，从指定位置开始查找子字符串的位置
        String str2="aaabcabcabcd";
        int ret2=str2.indexOf("abc",6);
        System.out.println(ret2);
//打印结果：
2
8

3️⃣lastIndexOf()方法

// lastIndexOf()方法：传一个参数，由后向前查找子字符串的位置
        String str3="abbcabcabcd";
        int index=str3.lastIndexOf("abc");
        System.out.println(index);
// lastIndexOf()方法：传两个参数，从指定位置由后向前查找
        int index1=str3.lastIndexOf("bc",3);//指定从某个位置开始找，但是要匹配的话
        //是可以跳过的
        System.out.println(index1);
//打印结果：
7
2

4️⃣startsWith()方法

//startsWith()方法:一个参数，判断是否以指定字符串开头
        String str4="abbcabcabcd";
        boolean ret3=str4.startsWith("ab");
        System.out.println(ret3);
        boolean ret4=str4.startsWith("abc");
        System.out.println(ret4);
//startsWith()方法:两个参数，从指定位置开始判断是否以指定字符串开头
        boolean ret5=str4.startsWith("abc",1);
        System.out.println(ret5);
        boolean ret6=str4.startsWith("abc",4);
        System.out.println(ret6);
//打印结果：
true
false
false
true

5️⃣endsWith()方法：判断是否以指定字符串结尾，它只能有一个参数。

        String str5="abbcabcabcd";
        boolean ret7=str4.endsWith("ab");
        System.out.println(ret7);
        boolean ret8=str4.endsWith("cd");
        System.out.println(ret8);
//打印结果：
false
true

面试问题：在主串当中查找子串。把这个东西叫做字符串匹配/查找算法。

他有两种算法：朴素算法和KMP算法

如果让你自己实现一个indexof方法，你该如何实现？

这个问题考的就是这两种算法，自己研究这两种算法并写出代码。

字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

NO方法名称类型描述
1public String replaceAll(String regex,String replacement)普通替换所有的指定内容
2public String replaceFirst(String regex,String replacement)普通替换首个内容

image-20210927073953918

 public static void main(String[] args) {
        //《字符串替换》
        //（1）替换字符
        String str1="ababcabcd";
        String ret=str1.replace('a','A');//把原来的'a'字符换成'A'字符,返回值是String
        //返回的是一个新的对象
        System.out.println(ret);
        //(2)替换所有的指定内容
        String ret1=str1.replaceAll("ab","AB");
        System.out.println(ret1);
        //(3)替换首个内容,即替换第一次出现的字符串
        String ret2=str1.replaceFirst("ab","WW");
        System.out.println(ret2);
    }

注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

字符串拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

可用方法如下：

NO方法名称类型描述
1public String[] split(String regex)普通将字符串全部拆分
2public String[] split(String regex,int limit)普通将字符串部分拆分，该数组长度就是limit极限

split这个方法的返回值是一个数组，所以需要拿数组来接收。

image-20210927092719635

public static void main(String[] args) {
//split()方法：一个参数时，将字符串全部拆分
        String str="abc de f";
        //split这个方法的返回值是一个数组，所以需要拿数组来接收
        String[] strings= str.split(" ");//按照空格拆分
        for (String s:strings) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }
//split()方法：两个参数时，将字符串部分拆分，该数组长度就是limit极限
        String str1="abc de f";
        String[] strings1= str.split(" ",2);//拆分成两组
        for (String s:strings1) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }
    }
//打印结果：
abc
de
f
abc
de f

//拆分IP地址
        String str2="192.168.1.1";
        String[] strings2=str2.split("");//如果给一个空，不按照任何方式来拆分，就会默认将一个一个字符都拆开
        for (String s:strings2) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }
        String[] strings3=str2.split( " ");//如果给一个不匹配的字符，就不会拆开
        for (String s:strings3) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }
//打印结果：
1
9
2
.
1
6
8
.
1
.
1
192.168.1.1

错误拆分代码示例：如果直接以点号拆分，在这里是错误的，会什么也不打印,为什么呢？

 String str2="192.168.1.1";  
 String[] strings4=str2.split( ".");
        for (String s:strings4) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }

通过split的源码可知，对于这些特殊的符号的处理，需要加双斜杠才可以进行字符串拆分。

image-20210927094440515

//拆分IP地址
        String str2="192.168.1.1";
        String[] strings5=str2.split( "\\.");//以点号拆分，加双斜杠才可以
        for (String s:strings5) {//使用for each遍历数组，打印数组里面的元素
            System.out.println(s);
        }
        String str3="192\\168\\1\\1";
        String[] strings6=str3.split( "\\\\");//用斜杠拆分，也要加双斜杠才可以
        for (String s:strings6) {
            System.out.println(s);
        }
        String str4="192*168*1*1";
        String[] strings7=str4.split( "\\*");//用*拆分，也要加双斜杠才可以
        for (String s:strings7) {
            System.out.println(s);
        }
//打印结果：
192
168
1
1
192
168
1
1
192
168
1
1

如何分割多次？

public static void main(String[] args) {
        //如何分割多次?
        String str = "name=zhangsan&age=18";
        String[] strings1 = str.split("&");//第一次分割：先以&进行分割
        for (String s1 : strings1) {
            String[] strings2 = s1.split("=");//第二次分割：让s1以=进行分割
            for (String s2 : strings2) {//遍历并打印s2
                System.out.println(s2);
            }
        }
    }
//打印结果：
name
zhangsan
age
18

△练习题：字符串连接

题目描述：借用任何字符串库函数实现无冗余的接受两个字符串，然后把他们无冗余的连接起来。

输入描述：每一行包括两个字符串，长度不超过100.

输出描述：可能有多组测试数据，对于每组数据，借用任何字符串库函数实现无冗余的接受两个字符串，然后把他们无冗余的连接起来。输出连接后的字符串。

import java.util.Scanner;
public class Main{
    public static String func(String str){//传参
        String[] strings=str.split(" ");//根据空格分割 
        String ret="";//将字符串拼接起来并放到ret中 
        for(String s:strings){//遍历数组
            ret+=s;
        }
        return ret;
    }
   public static void main(String[] args ){
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext()){//加while可以实现读下一个
        String str=scan.nextLine();//这句代码每次只能读一行，把它放在循环里面，可以实现读下一个
        String ret=func(str);
        System.out.println(ret);
       }
   }
}
//打印结果：
abc de
abcde
字符串截取

从一个完整的字符串之中截取出部分内容。可用方法如下

NO方法名称类型描述
1public String substring(int beginIndex)普通从指定索取截取到结尾
2public String substring(int beginIndex,int endIndex)普通截取部分内容

查看帮助手册搜索String：image-20210927080622431

  public static void main(String[] args) {
        String str1="ababcabcd";
        //从指定索取截取到结尾,即给一个参数代表从这个位置开始截取到结束位置
        String ret= str1.substring(1);//substring的返回值是字符串,所以需要拿字符串来接收,1表示从1号位置开始截取
        System.out.println(ret);
        //截取部分内容
        String ret1=str1.substring(1,4);//左闭右开：[1,4)
        System.out.println(ret1);
    }

注意事项:

1.索引从0开始.

2.注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标.

其他操作方法
NO方法名称类型描述
1public String trim()普通去掉字符串中的左右空格，保留中间空格
2public String toUpperCase()普通字符串转大写
3public String toLowerCase()普通字符串转小写
4public native String intern()普通字符串入池操作
5public String concat(String str)普通字符串连接，等同于”+“，不入池
6public int length()普通取得字符串长度
7public boolean isEmpty()普通判断是否为空字符串，但不是null,而是长度为0

1️⃣trim()方法，去掉字符串中的左右空格，保留中间空格

public static void main(String[] args) {
        String str1="   aba   bacbcd     ";
        String ret= str1.trim();//trim的返回值是字符串,所以需要拿字符串来接收
        System.out.println(ret);
    }

2️⃣toUpperCase()方法，将字符串转大写

​ toLowerCase方法，将字符串转小写

代码示例：这两个方法只对字母有效

public static void main(String[] args) {
// toLowerCase()方法，将字符串转小写
        String str2="aBcDef巴";
        String ret1=str2.toLowerCase();
        System.out.println(ret1);
//toUpperCase()方法，将字符串转大写
        String ret2=str2.toUpperCase();
        System.out.println(ret2);
}
//打印结果：
abcdef巴
ABCDEF巴

3️⃣intern()方法，字符串入池操作

5️⃣ length()方法，取得字符串长度

public static void main(String[] args) { 
    String str2="aBcDef巴";
    String ret2=str2.toUpperCase();
    System.out.println(ret2.length());//注意：对于ret2来说，length()是方法
    int[] array={1,2,3,4,5};
    System.out.println(array.length);//注意：对于array来说，length是属性
    }

注意两个length的区别,数组长度使用数组名称.length属性，而String中使用的是length()方法

image-20210927170041740

6️⃣isEmpty()方法，判断是否为空字符串，但不是null,而是长度为0

 String string1="";//空串:表示里面什么都没有
 String string2=null;//表示指向了null对象
练习题1：首字母大写

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

代码示例:

 public static void main(String[] args) {
        System.out.println(fistUpper("yuisama"));
        System.out.println(fistUpper(""));
        System.out.println(fistUpper("a"));
    }
    public static String fistUpper(String str) {
        if ("".equals(str)||str==null) {
            return str ;
        }
        if (str.length()>1) {
            return str.substring(0, 1).toUpperCase()+str.substring(1) ;
        }
        return str.toUpperCase() ;
    }
//打印结果：
Yuisama

A
练习题2：实现字符串逆置

库里面是没有让字符串逆置的方法的，需要自己手动实现。

代码示例：

 public static String reverse(String str,int begin,int end){//定义一个开始和结束参数
        char[]  value=str.toCharArray(); //先把字符串转换成字符数组
        while(begin<end){
            char tmp=value[begin];
            value[begin]=value[end];
            value[end]=tmp;
            begin++;
            end--;
        }
        //return new String(value);//第一种返回方式
        return String.copyValueOf(value);//第二种返回方式，将value数组变成是string类型了。
    }
    public static void main(String[] args) {
        String str="abcdefg";
        String ret= reverse(str,0,str.length()-1);//调用reverse,它的返回值是String,ret去接收
        System.out.println(ret);
    }
//打印结果：
gfedcba
练习题3：翻转字符串

题目描述：给一个字符类型的数组chas和一个整数size,请把大小为size的左半区整体右移到右半区，右半区整体移动到左边。

输入描述：输入两行，第一行一个整数，代表size，第二行一个字符串，代表chas

输出描述：输出一行字符串，代表翻转后的字符串。

输入

3

abcdefg

输出

defgabc

逻辑分析如图：

image-20210927210439737

代码示例：

import java.util.Scanner;
public class TestDemo3 {
    //逆置函数
    public static String reverse(String str, int begin, int end) {//定义一个开始和结束参数
        char[] value = str.toCharArray(); //先把字符串转换成字符数组
        while (begin < end) {
            char tmp = value[begin];
            value[begin] = value[end];
            value[end] = tmp;
            begin++;
            end--;
        }
        //return new String(value);//第一种返回方式
        return String.copyValueOf(value);//第二种返回方式，将value数组变成是string类型了。
    }
    public static String  func(String str, int n) {
        if(str==null || n<=0 || n>=str.length()){//判断参数不满足条件是，返回null
            return null;
        }
        str = reverse(str, 0, n - 1);//调用逆置函数reverse，第一次逆置（前半部分逆置）：从0号位置开始到n-1号位置结束，保存到新的str
        str = reverse(str, n, str.length() - 1);//第二次逆置：在第一次逆置之后的结果上，逆置后半部分:从n号位置到str.length() - 1位置结束，并保存新的到str
        str = reverse(str, 0, str.length() - 1);//第三次逆置：最后进行整体的逆置，从0号位置开始到str.length() - 1位置结束，并保存新的到str
        return str;//返回值类型为String
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String str = scanner.next();//nextInt()和nextLine()不能同时出现，所以只能写next()
        String ret = func(str, n);//调用func,返回值是String ,使ret接收
        System.out.println(ret);
    }
}
//打印结果：
4
abcdefghi
efghiabcd
StringBuffer 和 StringBuilder

首先来回顾下String类的特点：

  • 任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。
  • 通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供了StringBuffer和StringBuilder类。
  • StringBuffer 和 StringBuilder 大部分功能是相同的，这里主要介绍 StringBuffer
  • 在String中使用"+"来进行字符串连接，但是这个操作在StringBuffer类中需要更改为append()方法：
public static void main(String[] args) {
        //String的拼接用加号拼接，但会产生大量的临时对象（变量）
        String str="";
        for(int i=0;i<10;i++){
            str+='a';
        }
        System.out.println(str);
    }
 public static void main(String[] args) {
        //StringBuffer stringBuffer=new StringBuffer();//它是一个类
        StringBuilder stringBuilder=new StringBuilder();//它是一个类
        stringBuilder.append("abcd");
        stringBuilder.append("1234").append("cdef");
        //append返回的是this,即当前对象（stringBuffer）的引用。
        // stringBuilder的拼接用append()拼接，不会产生大量的临时对象（变量），它只维护了一份
    }

image-20210927232849825

 public static void main(String[] args) 
StringBuffer sb1=new StringBuffer();
        sb1.append("hello");
        sb1.reverse();
        System.out.println(sb1);

        StringBuffer sb2=new StringBuffer();
        sb1.append("hello");
        StringBuffer stringBuffer=sb2.reverse();
        System.out.println(stringBuffer);
}
//打印结果：
olleh
olleh

Stringbuilder和Stringbuffer的区别？

image-20210927232927359
面试题：请解释String、StringBuffer、StringBilder的区别?

String的内容不可修改，StringBuffffer与StringBuilder的内容可以修改.

StringBuffffer与StringBuilder大部分功能是相似的。

像风一样~~
关注
专栏目录
Java中ZonedDateTime使用详解
06-14
Java中的`ZonedDateTime`类是Java 8引入的一个新特性，用于处理带有时区的日期和时间。这个类提供了一种高效且灵活的方式来管理和转换不同时区的时间。下面是对`ZonedDateTime`的详细讲解。 ## 1. 带时区的日期和...
Java开发详解.zip
09-02
000000_【课程介绍 —— 写在前面的话】_Java学习概述笔记.pdf 010101_【第1章：JAVA概述及开发环境搭建】_JAVA发展概述笔记.pdf 010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2...
Java软件开发实战 Java基础与案例开发详解 10-2 认识异常 共5页.pdf
最新发布
07-07
通过本章的学习，我们可以了解到Java中的异常处理机制是非常强大的，它不仅能够帮助我们捕获和处理运行时的错误，还能通过自定义异常来扩展异常处理的能力。在实际开发中，合理地使用异常处理机制能够让我们的程序...
Android 逆向学习详解及实例
01-20
断断续续的总算的把android开发和逆向的这两本书看完了，虽然没有java，和android开发的基础，但总体感觉起来还是比较能接收的，毕竟都是触类旁通的。当然要深入的话还需要对这门语言的细节特性和奇技淫巧进行挖掘。...
Java软件开发实战 Java基础与案例开发详解 3-2 数据的分类 共9页.pdf
07-07
### Java软件开发实战：Java基础与案例开发详解 ...通过以上内容的学习，读者能够对Java中的数据分类有一个全面的认识，并能够在实际编程中灵活运用这些知识。这对于构建复杂的应用程序来说是非常必要的。
【MySQL】数据库基本操作（基础）
m0_59157222的博客
10-31 3696
文章目录1.数据库的基本操作1.1查看数据库1.2创建数据库1.3 使用数据库1.4 删除数据库2.常用数据类型2.1数值类型2.2字符串类型2.3日期类型3.数据表的基本操作3.1 创建表3.2 查看指定表（结构)3.3 查看当前有哪些表3.4 删除表【练习】 1.数据库的基本操作 1.1查看数据库 show databases; 1.2创建数据库 create database 数据库名; 【注意】 数据库名只能是数字、字母、下划线，不能有其他特殊符号。 SQL中是不区分大小写的。
【MySQL】数据库的增、删、查、改（基础）（重要）
m0_59157222的博客
11-02 2470
文章目录MySQL表的增删改查（CURD）（基础）1.CURD2.新增（Create）2.1 插入数据2.1.1单行数据+全列插入2.1.2 指定列插入数据2.1.3 一次插入多条记录3 .查询（Retrieve）3.1全列查询3.2查找指定列3.3查询的列为表达式3.4将查询字段指定别名3.5将查到的结果去重（distinct）3.6排序的几个基本用法：order by3.7条件查询：where(关键字)（重要）3.8分页查找（limit）4.修改（update）5.删除（Delete）6.总结6.1新增
【Java练习】图书管理系统【详解篇15+完整代码】
m0_59157222的博客
10-03 1969
文章目录要求介绍核心需求类的设计1、创建图书相关的类2、创建操作相关的类实现提供的接口，完成每一个操作AddOperation的实现BorrowOperation的实现DelOperation的实现DisplayOperation的实现ExitOperation的实现FindOperation的实现IOperation的实现ReturnOperation的实现3、创建用户相关的类4、一个程序的主函数(TestMain) 要求介绍 利用前面所学知识：使用类和对象、继承、封装、多态、抽象类、接口、顺序表进行一个
java 程序逻辑控制+猜数字游戏+程序调试【详解篇4】
m0_59157222的博客
08-08 856
【前言】：本篇主要以代码举例的形式来讲解顺序结构、分支结构、循环结构以及输入输出的方式，最后写了一个猜数字游戏，并用画图的方式简单说了一下idea的调试方式，旁观者清，如发现有错误，请及时评论或私信指正，欢迎来访！！！ 文章目录顺序结构分支结构if 语句代码示例1：判断一个数是奇数还是偶数代码示例2：判段某一年份是否是闰年代码示例3：判断一个数字是正数还是负数switch语句代码示例4: 根据 day 的值输出星期循环结构while循环代码示例5：打印1~9的数字代码示例6：计算1~100的和代码示例7：计
java中方法的使用和递归(三个维度讲递归)+递归练习【详解篇5】
m0_59157222的博客
08-13 673
文章目录方法什么是方法？方法定义的语法方法调用的执行过程实参和形参的关系没有返回值的方法方法的重载重载的规则递归从第一个维度来看递归:当n=3时从第二个维度来看递归：当n=4时从第三个维度来看递归：当n=4时：递归练习题练习1：递归求 N 的阶乘练习2：按顺序打印一个数字的每一位练习3：递归求 1 + 2 + 3 + ... + 10练习4：写一个递归方法，输入一个非负整数，返回组成它的数字之和.练习5：求斐波那契数列的第N项练习6：青蛙跳台阶问题练习7：汉诺塔问题 方法 什么是方法？ 方法就是一个代码片
【MySQL】 数据库的增、删、改、查（进阶）（重要）
m0_59157222的博客
11-03 599
文章目录MySQL表的增删改查（进阶）1.数据库约束1.1约束的类型1.2 not null约束1.3 unique 唯一约束1.4 default 默认值约束1.5 primary key 主键约束1.6 foreign key 外键约束1.7 CHECK 约束（了解）2.表的设计三大范式2.1 一对一关系2.2 一对多关系2.3 多对多关系3.新增4.查询4.1聚合查询4.1.1聚合函数4.1.2 GROUP BY子句4.1.3 having4.2联合查询（多表查询）（难点+重点）4.2.1 内连接（
【MySQL】数据库编程JDBC (很重要)
m0_59157222的博客
11-05 598
文章目录数据库编程（JDBC）1.数据库编程：JDBC2.数据库编程的必备条件3.JDBC工作原理4.JDBC优势5.下载jar包的方式6.JDBC的使用(jar包的导入)7. JDBC使用步骤7.1 通过JDBC执行插入操作7.2 通过JDBC执行查找操作7.3 通过JDBC执行删除操作7.4 通过JDBC执行修改操作8.JDBC编程中主要用到的类/对象9.JDBC使用步骤总结 数据库编程（JDBC） 1.数据库编程：JDBC JDBC，即Java Database Connectivity，java数
java的八种数据类型和一种引用类型及变量【详解篇2】
m0_59157222的博客
07-31 570
文章目录数据类型1.整型变量什么是字节?2.长整型变量3.双精度浮点型变量4.单精度浮点型变量5. 字符类型变量6.字节类型变量7.短整型变量8.布尔类型变量引用类型字符串类型变量(重点）变量变量的作用域变量的命名规则常量1.字面值常量2. final 关键字修饰的常量理解类型转换理解数值提升 数据类型 变量指的是程序运行时可变的量. 相当于开辟一块内存空间来保存一些数据. 类型则是对变量的种类进行了划分, 不同的类型的变量具有不同的特性. 我们所讨论的 “变量” 主要和我们的 “内存” 这样的硬件设备密
java 一维数组的基本用法【详解篇6】
m0_59157222的博客
08-16 551
文章目录什么是数组？如何创建数组？数组的使用Java中打印数组的方式初识 JVM 内存区域划分数组作为方法的参数理解引用类型认识null数组作为方法的返回值数组练习练习1：数组转字符串接练习1：实现一个自己版本的数组转字符串练习2:数组的四种拷贝方式（遍历数组元素，拷贝到另外一个新的数组）方式1：使用for循环进实现数组拷贝方式2：使用数组工具类Arrays.copyOf()实现数组拷贝方式3：借助System.arraycopy()进行拷贝方式4：调用对象的clone克隆方法画图理解是深拷贝、浅拷贝？练习
【C语言学习】指针【初阶详解篇10】
m0_59157222的博客
07-11 513
指针 指针是什么？ 在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。 指针是一个变量，存放内存单元的地址（编号） 对应到代码大概是这样的： #include<stdio.h> int main() { int a = 10;//a占4个字节 int *pa = &
【C语言学习】自定义类型：结构体、枚举、联合 【进阶详解篇17】
m0_59157222的博客
08-27 463
文章目录自定义类型：结构体、枚举、联合结构体结构类型的声明结构的基础知识：结构的声明：结构体类型举例特殊的声明结构的自引用结构体变量的定义和初始化结构体内存对齐结构体内存大小的计算结构体内存规则：为什么存在内存对齐 ?百度笔试题：结构体传参结构体实现位段的能力——位段位段的内存分配:位段的应用枚举含义生活举例枚举类型的定义为什么使用枚举？枚举的优点联合联合类型的声明联合变量的定义通过代码来理解联合的特点联合体怎么初始化？联合体的作用联合大小的计算 自定义类型：结构体、枚举、联合 结构体 结构类型的声明 结构
【Java学习及数据结构初识】顺序表和链表【详解篇10】
m0_59157222的博客
09-02 383
文章目录一、线性表二、顺序表概念及结构接口实现顺序表接口的实现代码顺序表接口的测试代码测试打印结果三、链表什么是链表？带头结点的单向非循环链表带头节点的单向循环链表不带头节点的单向非循环列表如何产生一个节点？△头插法addFirst方法△尾插法addLast方法△任意位置插入addIndex方法查找是否包含关键字key是否在单链表当中 contains方法△删除第一次出现关键字为key的节点 remove方法△删除所有值为key的节点removeAllKey方法得到单链表的长度 size方法打印单链表dis
【从0到1学习C】之初识C语言2【初阶详解篇2】
m0_59157222的博客
06-22 380
变量的作用域和生命周期 作用域概念：通俗来讲就是这个变量在哪里可以使用，哪里就是它的作用域。 eg1: #include <stdio.h> int main() { printf("hehe\n"); int a = 10; printf("a=%d\n", a);//a这个变量在这个函数体中可以使用,因此，这个函数体就是它的作用域 return 0; } eg2: #include <stdio.h> int mai
Java概述及初识【详解篇1】
m0_59157222的博客
07-30 296
初识java1.java祖师爷：高斯林 2.写java代码的时候要注意： ①文件名需要和类名一样 ②每次写完代码，都需要保存，重新编译再运行 ③双引号引起来的是字符串 ④方法和函数是同一个概念，在java中，函数被叫为方法。 ⑤C语言没有字符串类型，但Java有字符串类型，叫String ⑥注意java大括号的书写风格 ⑦代码自己的编码格式是UTF-8,但是java的编译平台(javac)的默认编码是GBK, 所以在命令行编译代码的时候可以输入javac -encoding utf-8 文件名，进行解
Java URL类构造方法详解与Java语言发展历程
在Java基础学习中，URL类是Java提供的一个核心类，用于处理统一资源定位符（Uniform Resource Locator），它是网络应用程序的重要组成部分。URL类有两个主要的构造方法： 1. `public URL(String spec) throws ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值