DAY02_常用API&Scanner&String&StringBuilder

最新推荐文章于 2024-07-04 09:24:51 发布
最新推荐文章于 2024-07-04 09:24:51 发布
阅读量50 收藏
点赞数
分类专栏： 2.JavaSE进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/129126266
版权

目录

1 API

1.1 API概述-帮助文档的使用

  • 什么是API
    • API (Application Programming Interface) ：应用程序编程接口
  • java中的API
    • 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
  • 如何使用API帮助文档 :
    • 打开帮助文档
    • 找到索引选项卡中的输入框
    • 在输入框中输入Random
    • 看类在哪个包下
    • 看类的描述
    • 看构造方法
    • 看成员方法

1.2 键盘录入字符串

  • Scanner类 :
    • next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键
    • nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符
import java.util.Scanner;

public class Demo1Scanner {
    public static void main(String[] args) {
    /*
        next() : 遇到了空格, 就不再录入数据了
                 结束标记: 空格, tab键
        nextLine() : 可以将数据完整的接收过来
                    结束标记: 回车换行符
    */
        // 1. 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        // 2. 调用nextLine方法接收字符串
        // ctrl + alt + v : 快速生成方法的返回值
        String s = sc.nextLine();
        System.out.println(s);
    }
}
  • nextInt和nextLine方法配合使用的时候,nextLine方法就没有键盘录入的机会了（会直接录入回车）
  • 建议:
    • 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接受字符串.
import java.util.Scanner;
public class Demo2Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入整数:");
        int num = sc.nextInt(); // 10 + 回车换行
        System.out.println("请输入字符串:");
        String s = sc.next();
        System.out.println(num);
        System.out.println(s);
    }
}

2 String类

2.1 String概述

  1. String 类在 java.lang 包下，所以使用的时候不需要导包
  2. String类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是说，Java程序中所有的双引号字符串，都是 String 类的对象
  3. 字符串不可变，它们的值在创建后不能被更改

2.2 String类的构造方法

常用的构造方法
在这里插入图片描述

public class Demo2StringConstructor {
    /*
        String类常见构造方法:
            public String() : 创建一个空白字符串对象，不含有任何内容
            public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
            public String(String original) : 根据传入的字符串内容，来创建字符串对象
            String s = “abc”;  直接赋值的方式创建字符串对象，内容就是abc

         注意:
                String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
                而是该对象所记录的真实内容.

                面向对象-继承, Object类
     */
    public static void main(String[] args) {
        // public String() : 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println(s1);

        // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println(s2);

        // public String(String original) : 根据传入的字符串内容，来创建字符串对象
        String s3 = new String("123");
        System.out.println(s3);
    }
}

2.3 创建字符串对象的区别对比

  • 构造方法能创建对象，双引号也能创建字符串对象，有什么区别么？
    • 通过构造方法创建
      • 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
    • 直接赋值方式创建
      • 以“ ”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

2.4 字符串的比较

  • 使用“==”作比较：
    • 基本类型：比较的是数据值是否相同
    • 引用类型：比较的是地址值是否相同
  • 字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方式叫：equals()
    • public boolean equals(Object anObject)：将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串，比较两个字符串内容是否相同、区分大小写
public class Demo1Equals {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABC";
        String s3 = "abc";

        // equals : 比较字符串内容, 区分大小写
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s3));//true

        // equalsIgnoreCase : 比较字符串内容, 忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));//true
    }
}

2.5 用户登录案例【应用】

案例需求 :
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
实现步骤 :

  • 已知用户名和密码，定义两个字符串表示即可
  • 键盘录入要登录的用户名和密码，用 Scanner 实现
  • 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
  • 字符串的内容比较，用equals() 方法实现
  • 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循
import java.util.Scanner;

public class Test1 {
    /*
        需求：已知用户名和密码，请用程序实现模拟用户登录。
              总共给三次机会，登录之后，给出相应的提示

        思路：
        1. 已知用户名和密码，定义两个字符串表示即可
        2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            字符串的内容比较，用equals() 方法实现
        4. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环

     */
    public static void main(String[] args) {
        // 1. 已知用户名和密码，定义两个字符串表示即可
        String username = "admin";
        String password = "123456";
        // 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        // 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
        for (int i = 1; i <= 3; i++) {
            System.out.println("请输入用户名:");
            String scUsername = sc.nextLine();
            System.out.println("请输入密码:");
            String scPassword = sc.nextLine();
            // 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            if (username.equals(scUsername) && password.equals(scPassword)) {
                System.out.println("登录成功");
                break;
            } else {
                if (i == 3) {
                    System.out.println("您的登录次数已达到今日上限, 请明天再来");
                } else {
                    System.out.println("登录失败,您还剩余" + (3 - i) + "次机会");
                }

            }
        }
    }
}

2.6 遍历字符串案例一【应用】

案例需求 :
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
实现步骤 :

  • 键盘录入一个字符串，用 Scanner 实现
  • 遍历字符串，首先要能够获取到字符串中的每一个字符
    • public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
  • 遍历字符串，其次要能够获取到字符串的长度
    • public int length()：返回此字符串的长度
    • 数组的长度：数组名.length
    • 字符串的长度：字符串对象.length()
  • 遍历打印
import java.util.Scanner;

public class Test2 {
    /*
        需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 遍历字符串，首先要能够获取到字符串中的每一个字符
             public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
        3. 遍历字符串，其次要能够获取到字符串的长度
             public int length()：返回此字符串的长度
        4. 遍历打印
*/
    public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
        for (int i = 0; i < s.length(); i++) {
            // i : 字符串的每一个索引
            char c = s.charAt(i);
            System.out.println(c);
        }
    }
}

2.7 遍历字符串案例二【应用】

案例需求 :
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
实现步骤 :

  • 键盘录入一个字符串，用 Scanner 实现
  • 将字符串拆分为字符数组
    • public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
  • 遍历字符数
import java.util.Scanner;

public class Test3 {
    /*
    需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

    思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 将字符串拆分为字符数组
         public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
    3. 遍历字符数组
*/
    public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 将字符串拆分为字符数组
        char[] chars = s.toCharArray();
        // 3. 遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }
}

2.8 统计字符次数案例【应用】

案例需求：
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
实现步骤：

  • 键盘录入一个字符串，用 Scanner 实现
  • 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
  • 遍历字符串，得到每一个字符
  • 判断该字符属于哪种类型，然后对应类型的统计变量+1
    • 假如ch是一个字符，我要判断它属于大写字母小写字母还是数字，直接判断该字符是否在对应的范围即可
      • 大写字母：ch>=‘A’ && ch<=‘Z’
      • 小写字母： ch>=‘a’ && ch<=‘z’
      • 数字： ch>=‘0’ && ch<=‘9’
  • 输出三种类型的字符个数
import java.util.Scanner;

public class Test4 {
    /*
        需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        3. 遍历字符串，得到每一个字符
        4. 判断该字符属于哪种类型，然后对应类型的统计变量+1
                假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
                大写字母：ch>='A' && ch<='Z'
                小写字母： ch>='a' && ch<='z'
                数字： ch>='0' && ch<='9'
        5. 输出三种类型的字符个数
     */
    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numCount = 0;
        // 3. 遍历字符串，得到每一个字符
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            // 4. 判断该字符属于哪种类型，然后对应类型的统计变量+1
            if (c >= 'A' && c <= 'Z') {
                bigCount++;
            } else if (c >= 'a' && c <= 'z') {
                smallCount++;
            } else if (c >= '0' && c <= '9') {
                numCount++;
            }
        }

        // 5. 输出三种类型的字符个数
        System.out.println("大写字母字符:" + bigCount);
        System.out.println("小写字母字符:" + smallCount);
        System.out.println("数字字母字符:" + numCount);
    }
}

2.9 手机号屏蔽-字符串截取

案例需求 :
以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽 最终效果为：1561234
实现步骤 :

  • 键盘录入一个字符串，用 Scanner 实现
  • 截取字符串前三位
  • 截取字符串后四位
    • public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）
  • 将截取后的两个字符串，中间加上进行拼接，输出结果
import java.util.Scanner;

public class Test5 {
    /*
        需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：156****1234

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 截取字符串前三位
        3. 截取字符串后四位
        4. 将截取后的两个字符串，中间加上****进行拼接，输出结果

     */
    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String telString = sc.nextLine();
        // 2. 截取字符串前三位
        String start = telString.substring(0, 3);
        // 3. 截取字符串后四位
        String end = telString.substring(7);
        // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
        System.out.println(start + "****" + end);
    }
}

2.10 敏感词替换-字符串替换

案例需求 :
键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
实现步骤 :

  • 键盘录入一个字符串，用 Scanner 实现
  • 替换敏感词
    • String replace(CharSequence target, CharSequence replacement)将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
  • 输出结果
import java.util.Scanner;

public class Test6 {
    /*
        需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 替换敏感词
                String replace(CharSequence target, CharSequence replacement)
                将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
        3. 输出结果

     */
    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 替换敏感词
        String result = s.replace("TMD", "***");
        // 3. 输出结果
        System.out.println(result);
    }
}

2.11 切割字符串

案例需求 :
以字符串的形式从键盘录入学生信息，例如：“张三 , 23”，从该字符串中切割出有效数据,封装为Student学生对象
实现步骤 :

  • 编写Student类，用于封装数据
  • 键盘录入一个字符串，用 Scanner 实现
  • 根据逗号切割字符串，得到（张三）（23）
    • String[] split(String regex) ：根据传入的字符串作为规则进行切割 将切割后的内容存入字符串数组中，并将字符串数组返回
  • 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
  • 调用对象getXxx方法，取出数据并打印。
public class Student {
   private String name;
   private String age;

    public Student() {
    }

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

import com.itheima.domain.Student;

import java.util.Scanner;

public class Test7 {
    /*
         需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”
                从该字符串中切割出有效数据,封装为Student学生对象
         思路：
            1. 编写Student类，用于封装数据
            2. 键盘录入一个字符串，用 Scanner 实现
            3. 根据逗号切割字符串，得到（张三）（23）
                    String[] split(String regex) ：根据传入的字符串作为规则进行切割
                    将切割后的内容存入字符串数组中，并将字符串数组返回
            4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
            5. 调用对象getXxx方法，取出数据并打印。

     */
    public static void main(String[] args) {
        // 2. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息:");
        String stuInfo = sc.nextLine();
        // stuInfo = "张三,23";
        // 3. 根据逗号切割字符串，得到（张三）（23）
        String[] sArr = stuInfo.split(",");

//        System.out.println(sArr[0]);//张三
//        System.out.println(sArr[1]);//23

        // 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        Student stu = new Student(sArr[0],sArr[1]);

        // 5. 调用对象getXxx方法，取出数据并打印。
        System.out.println(stu.getName() + "..." + stu.getAge());
    }
}

2.12 String方法小结

String类的常用方法 :

  • public boolean equals(Object anObject)
    • 比较字符串的内容，严格区分大小写
  • public boolean equalsIgnoreCase(String anotherString)
    • 比较字符串的内容，忽略大小写
  • public int length()
    • 返回此字符串的长度
  • public char charAt(int index)
    • 返回指定索引处的 char 值
  • public char[] toCharArray()
    • 将字符串拆分为字符数组后返回
  • public String substring(int beginIndex, int endIndex)
    • 根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）
  • public String substring(int beginIndex)
    • 从传入的索引处截取，截取到末尾，得到新的字符串
  • public String replace(CharSequence target, CharSequence replacement)
    • 使用新值，将字符串中的旧值替换，得到新的字符串
  • public String[] split(String regex)
    • 根据传入的规则切割字符串，得到字符串数组

3 StringBuilder类

3.1 StringBuilder类概述

  • 概述 :
    • StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder对象中的内容是可变的
  • 作用：
    • 提高字符串的操作效率
public class Demo1StringBuilder {
    public static void main(String[] args) {
        method();//2939
        method2();//7
    }

    public static void method() {
        long start = System.currentTimeMillis();//获取1970年1月1日 0时0分0秒 到当前时间所经历过的毫秒值
        String s = "";
        for (int i = 1; i <= 50000; i++) {
            s += i;
        }
        System.out.println(s);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void method2() {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 50000; i++) {
            sb.append(i);
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

3.2 StringBuilder类和String类的区别

  • String类： 内容是不可变的
  • StringBuilder类： 内容是可变的

3.3StringBuilder类的构造方法

常用的构造方法

方法名说明
public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
public class Demo2StringBuilder {
    /*
        StringBuilder : 可变的字符串, 可以看作为是一个容器

        构造方法:
              public StringBuilder() : 创建一个空白可变字符串对象，不含有任何内容
              public StringBuilder(String str) : 根据字符串的内容，来创建可变字符串对象
     */
    public static void main(String[] args) {
        // public StringBuilder() : 创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);

        // public StringBuilder(String str) : 根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2);
    }
}

3.4 StringBuilder常用的成员方法

方法名说明
public StringBuilder append(任意类型)添加数据，并返回对象本身
public StringBuilder reverse()返回相反的字符序列
public int length()返回长度（字符出现的个数）

3.5StringBuilder和String相互转换【应用】

  • StringBuilder转换为String
    • public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
  • String转换为StringBuilder
    • public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
public class Demo3StringBuilder {
    /*
        成员方法:
              public StringBuilder append(任意类型) : 添加数据，并返回对象本身
              public StringBuilder reverse() : 返回相反的字符序列
              public int length() : 返回长度 (字符出现的个数)
              public String toString() : 通过toString()就可以实现把StringBuilder转换为String
     */
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
//        sb.append("红色");
//        System.out.println(sb);
//        sb.append("蓝色");
//        System.out.println(sb);
//        sb.append("绿色");
//        System.out.println(sb);

//        StringBuilder sb2 = sb.append("红色");
//        StringBuilder sb3 = sb2.append("蓝色");
//        sb3.append("绿色");

        // 链式编程: 如果一个方法返回的是对象类型, 对象就可以继续向下调用方法.
        sb.append("红色").append("蓝色").append("绿色");

        System.out.println("反转前:" + sb);

        sb.reverse();

        System.out.println("反转后:" + sb);

        System.out.println("sb中字符的个数为:" + sb.length());

        // public String toString() : 通过toString()就可以实现把StringBuilder转换为String
        String s = sb.toString();
        System.out.println(s);
    }
}

3.6 对称字符串案例

  • 需求：
  • 键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
    • 对称字符串：123321、111
    • 非对称字符串：123123
  • 思路：
    • 键盘录入一个字符串，用 Scanner 实现
    • 将键盘录入的字符串反转
    • 使用反转后的字符串，和原字符串进行比对
    • 如果相同，则输出是对称字符串，反之输出不是对称字符串
import java.util.Scanner;

public class Test8 {
    /*
        需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
            对称字符串：123321、111
            非对称字符串：123123

        思路：
            1. 键盘录入一个字符串，用 Scanner 实现
            2. 将键盘录入的字符串反转
            3. 使用反转后的字符串，和原字符串进行比对
            4. 如果相同，则输出是对称字符串，反之输出不是对称字符串

     */
    public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对称字符串:");
        String s = sc.nextLine();
        // 2. 将键盘录入的字符串反转
        // 将字符串封装为StringBuilder对象, 目的是为了掉用其反转的方法
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String reverseStr = sb.toString();
        // s : String
        // sb : StringBuilder
        // 3. 使用反转后的字符串，和原字符串进行比对
        if(s.equals(reverseStr)){
            System.out.println("是对称字符串");
        }else{
            System.out.println("不是对称字符串");
        }
    }
}

3.7 StringBuilder拼接字符串案例

案例需求 :
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
实现步骤 :

  • 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
  • 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
  • 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
  • 调用方法，用一个变量接收结果
  • 输出结果
public class Test9 {
    /*
        需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回
            调用该方法，并在控制台输出结果。
            例如，数组为int[] arr = {1,2,3};
            执行方法后的输出结果为：[1, 2, 3]

        思路：
            1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
            2. 定义一个方法，返回值类型 String，参数列表 int[] arr
            3. 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
            4. 调用方法，用一个变量接收结果
            5. 输出结果
     */
    public static void main(String[] args) {
        // 1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};
        // 4. 调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        // 5. 输出结果
        System.out.println(s);
    }

    // 2. 定义一个方法，返回值类型 String，参数列表 int[] arr
    public static String arrayToString(int[] arr){
        // 3. 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder("[");

        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length -1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(", ");
            }
        }
        return sb.toString();
    }
}
_-Mr-sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类型转换_运算符_API_Scanner
09-26
类型转换_运算符_API_Scanner
day09【API、String类、StringBuilder类】.pdf
11-02
day09【API、String类、StringBuilder类】 本节课程主要介绍了 API、String 类和 StringBuilder 类的相关知识点。 API 概述 API（Application Programming Interface）即应用程序编程接口，提供了一种访问底层...
day08 常用API&String类&StringBuilder类
SUIT THUG!的博客
06-27 361
1.API 1.1 API概述-帮助文档的使用 什么是API ​ API (Application Programming Interface) ：应用程序编程接口 java中的API ​ 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。 如何使用API帮助文档 : 打开帮助文档 找到索引选项卡中的输入框 在输入框中输入Random 看类在
day13-常用API&异常
at10090的博客
06-27 202
1.包装类 1.1基本类型包装类（记忆） 基本类型包装类的作用 ​ 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 ​ 常用的操作之一：用于基本数据类型与字符串之间的转换 基本类型对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float ...
day08-API文档&字符串&StringBuilder
at10090的博客
06-19 300
1.API 1.1API概述 什么是API ​ API (Application Programming Interface) ：应用程序编程接口 java中的API ​ 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。 1.2如何使用API帮助...
day13常用API&异常
allselects
12-09 62
1.包装类 1.1基本类型包装类（记忆） 基本类型包装类的作用 ​ 将基本数据类型封装成对象的好处: 可以在对象中定义更多的功能方法操作该数据 ​ 常用的操作之一：用于基本数据类型与字符串之间的转换 基本类型对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 1.2
Java基础day12 ：常用API&异常
待定
11-06 74
1.包装类 1.1基本类型包装类（记忆） 基本类型包装类的作用 ​ 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 ​ 常用的操作之一：用于基本数据类型与字符串之间的转换 基本类型对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float ...
day13 常用API&异常
你是人间四月天
01-20 71
1.包装类 1.1基本类型包装类（记忆） 基本类型包装类的作用 ​ 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 ​ 常用的操作之一：用于基本数据类型与字符串之间的转换 基本类型对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 1.2
【Java入门】Day08-常用API&字符串
weixin_45876487的博客
11-25 158
1.API 1.1API概述【理解】 什么是API ​ API (Application Programming Interface) ：应用程序编程接口 java中的API ​ 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。 1.2如何使用A...
Java_Day_14_常用Api_总结
weixin_49650305的博客
01-16 165
java. lang. String : 是字符串类底层就是一个fina|修 饰的char数组,所以String很多特性就是数组的特性,比如一旦确定,长度不能更改 1字符串一旦创建，这个字符串对象不能更改,池子中的值不能改 2为了提高访问和存储效率，java虚 拟机缓存机制，把字符串都保存在了字符串常量池(静态区) 3在程序执行过程中,假如要用到一个字符串a String s1 = "a"; 先去字符串常量池中检索是否有a,如果没有就创建一份 假如有了String s2 = "a";就不再创建，把已有的这
2021-07-31 复习 java进阶 day04-常用API&异常
小虫虫的博客
07-31 135
复习 java进阶 day04-常用API&异常1.包装类1.1基本类型包装类（记忆）1.2Integer类（应用）1.3int和String类型的相互转换（记忆）1.4字符串数据排序案例（应用）1.5自动拆箱和自动装箱（理解）2.时间日期类2.1Date类（应用）2.2Date类常用方法（应用）2.3SimpleDateFormat类（应用）2.4日期工具类案例（应用）2.5Calendar类（应用）2.6二月天案例（应用）3.异常3.1异常（记忆）3.2JVM默认处理异常的方式（理解）3.3tr
浅析Java常用API(Scanner，Random)匿名对象
08-26
Java常用API(Scanner、Random)匿名对象详解 Java中封装了许多API供用户使用，Scanner和Random便是其中之一。API实际就是类，我们只需按照其语法编写即可，无需了解其根本源代码。 Scanner类 Scanner类是Java中的...
Mastino Pid Dumper & Scanner v 1.0-开源
05-07
《Mastino Pid Dumper & Scanner v 1.0：开源系统管理的得力助手》 Mastino Pid Dumper & Scanner v 1.0是一款专为系统管理员设计的开源工具，集进程ID（PID）dump和扫描功能于一体，旨在提供高效且灵活的系统监控...
基于TWAIN接口程序.zip_Scanner _camera scanner_twain_摄像头_视频
09-22
标题中的“基于TWAIN接口程序.zip_Scanner _camera scanner_twain_摄像头_视频”表明这是一个关于使用TWAIN接口进行摄像头扫描仪视频图像采集的项目。TWAIN（Technology Without An Interesting Name，没有有趣名字...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 523
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 647
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 337
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 222
maven配置使用nexus仓库
scanner 中 如何获取String
07-13
String inputString = scanner.next(); // 打印输入的字符串 System.out.println("您输入的字符串是：" + inputString); // 关闭 Scanner 对象 scanner.close(); } } ``` 运行上述代码后，程序会提示用户...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值