关于java:JAVA基础系列-第8篇-API

5次阅读

共计 10021 个字符，预计需要花费 26 分钟才能阅读完成。

API
String 类
StringBuilder 类

什么是 API
API (Application Programming Interface)：应用程序编程接口
java 中的 API
指的就是 JDK 中提供的各种性能的 Java 类，这些类将底层的实现封装了起来，咱们不须要关怀这些类是如何实现的，只须要学习这些类如何应用即可，咱们能够通过帮忙文档来学习这些 API 如何应用。

关上帮忙文档
找到索引选项卡中的输入框
在输入框中输出 String
看类在哪个包下
看类的形容
看构造方法
看成员办法

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以应用的时候不须要导包！

字符串不可变，它们的值在创立后不能被更改
尽管 String 的值是不可变的，然而它们能够被共享
字符串成果上相当于字符数组 (char[] )，然而底层原理是字节数组 (byte[] )

罕用的构造方法
| 办法名 | 阐明 |

| ————————— | —————————————– |

| public String() | 创立一个空白字符串对象，不含有任何内容 |

| public String(char[] chs) | 依据字符数组的内容，来创立字符串对象 |

| public String(byte[] bys) | 依据字节数组的内容，来创立字符串对象 |

| String s =“abc”; | 间接赋值的形式创立字符串对象，内容就是 abc |
示例代码

public class StringDemo01 {public static void main(String[] args) {//public String()：创立一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

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

        //public String(byte[] bys)：依据字节数组的内容，来创立字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s =“abc”;    间接赋值的形式创立字符串对象，内容就是 abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

通过构造方法创立
通过 new 创立的字符串对象，每一次 new 都会申请一个内存空间，尽管内容雷同，然而地址值不同
间接赋值形式创立
以“”形式给出的字符串，只有字符序列雷同 (程序和大小写)，无论在程序代码中呈现几次，JVM 都只会建设一个 String 对象，并在字符串池中保护

2.5.1== 号的作用

比拟根本数据类型：比拟的是具体的值
比拟援用数据类型：比拟的是对象地址值

2.5.2equals 办法的作用

办法介绍

public boolean equals(String s)     比拟两个字符串内容是否雷同、辨别大小写

示例代码

public class StringDemo02 {public static void main(String[] args) {
        // 构造方法的形式失去对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        // 间接赋值的形式失去对象
        String s3 = "abc";
        String s4 = "abc";

        // 比拟字符串对象地址是否雷同
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println("--------");

        // 比拟字符串内容是否雷同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
    }
}

2.6.1 案例需要

已知用户名和明码，请用程序实现模仿用户登录。总共给三次机会，登录之后，给出相应的提醒

2.6.2 代码实现

/*
    思路：1: 已知用户名和明码，定义两个字符串示意即可
        2: 键盘录入要登录的用户名和明码，用 Scanner 实现
        3: 拿键盘录入的用户名、明码和已知的用户名、明码进行比拟，给出相应的提醒。字符串的内容比拟，用 equals() 办法实现
        4: 用循环实现屡次机会，这里的次数明确，采纳 for 循环实现，并在登录胜利的时候，应用 break 完结循环
 */
public class StringTest01 {public static void main(String[] args) {
        // 已知用户名和明码，定义两个字符串示意即可
        String username = "itheima";
        String password = "czbk";

        // 用循环实现屡次机会，这里的次数明确，采纳 for 循环实现，并在登录胜利的时候，应用 break 完结循环
        for(int i=0; i<3; i++) {

            // 键盘录入要登录的用户名和明码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输出用户名：");
            String name = sc.nextLine();

            System.out.println("请输出明码：");
            String pwd = sc.nextLine();

            // 拿键盘录入的用户名、明码和已知的用户名、明码进行比拟，给出相应的提醒。字符串的内容比拟，用 equals() 办法实现
            if (name.equals(username) && pwd.equals(password)) {System.out.println("登录胜利");
                break;
            } else {if(2-i == 0) {System.out.println("你的账户被锁定，请与管理员分割");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

2.7.1 案例需要

键盘录入一个字符串，应用程序实现在控制台遍历该字符串

2.7.2 代码实现

/*
    思路：1: 键盘录入一个字符串，用 Scanner 实现
        2: 遍历字符串，首先要可能获取到字符串中的每一个字符
            public char charAt(int index)：返回指定索引处的 char 值，字符串的索引也是从 0 开始的
        3: 遍历字符串，其次要可能获取到字符串的长度
            public int length()：返回此字符串的长度
            数组的长度：数组名.length
            字符串的长度：字符串对象.length()
        4: 遍历字符串的通用格局
 */
public class StringTest02 {public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输出一个字符串：");
        String line = sc.nextLine();

        for(int i=0; i<line.length(); i++) {System.out.println(line.charAt(i));
        }
    }
}

2.8.1 案例需要

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符呈现的次数 (不思考其余字符)

2.8.2 代码实现

/*
  思路：1: 键盘录入一个字符串，用 Scanner 实现
        2: 要统计三种类型的字符个数，需定义三个统计变量，初始值都为 0
        3: 遍历字符串，失去每一个字符
        4: 判断该字符属于哪种类型，而后对应类型的统计变量 +1
            如果 ch 是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范畴即可
            大写字母：ch>='A' && ch<='Z'
            小写字母：ch>='a' && ch<='z'
            数字：ch>='0' && ch<='9'
        5: 输入三种类型的字符个数
 */
public class StringTest03 {public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输出一个字符串：");
        String line = sc.nextLine();

        // 要统计三种类型的字符个数，需定义三个统计变量，初始值都为 0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 遍历字符串，失去每一个字符
        for(int i=0; i<line.length(); i++) {char ch = line.charAt(i);

            // 判断该字符属于哪种类型，而后对应类型的统计变量 +1
            if(ch>='A' && ch<='Z') {bigCount++;} else if(ch>='a' && ch<='z') {smallCount++;} else if(ch>='0' && ch<='9') {numberCount++;}
        }

        // 输入三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}

2.9.1 案例需要

定义一个办法，把 int 数组中的数据依照指定的格局拼接成一个字符串返回，调用该办法，

并在控制台输入后果。例如，数组为 int[] arr = {1,2,3};，执行办法后的输入后果为：[1, 2, 3]

2.9.2 代码实现

/*
    思路：1: 定义一个 int 类型的数组，用动态初始化实现数组元素的初始化
        2: 定义一个办法，用于把 int 数组中的数据依照指定格局拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
        3: 在办法中遍历数组，依照要求进行拼接
        4: 调用办法，用一个变量接管后果
        5: 输入后果
 */
public class StringTest04 {public static void main(String[] args) {
        // 定义一个 int 类型的数组，用动态初始化实现数组元素的初始化
        int[] arr = {1, 2, 3};

        // 调用办法，用一个变量接管后果
        String s = arrayToString(arr);

        // 输入后果
        System.out.println("s:" + s);
    }

    // 定义一个办法，用于把 int 数组中的数据依照指定格局拼接成一个字符串返回
    /*
        两个明确：返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 在办法中遍历数组，依照要求进行拼接
        String s = "";

        s += "[";

        for(int i=0; i<arr.length; i++) {if(i==arr.length-1) {s += arr[i];
            } else {s += arr[i];
                s += ",";
            }
        }

        s += "]";

        return s;
    }
}

2.10.1 案例需要

定义一个办法，实现字符串反转。键盘录入一个字符串，调用该办法后，在控制台输入后果

例如，键盘录入 abc，输入后果 cba

2.10.2 代码实现

/*
    思路：1: 键盘录入一个字符串，用 Scanner 实现
        2: 定义一个办法，实现字符串反转。返回值类型 String，参数 String s
        3: 在办法中把字符串倒着遍历，而后把每一个失去的字符拼接成一个字符串并返回
        4: 调用办法，用一个变量接管后果
        5: 输入后果
 */
public class StringTest05 {public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输出一个字符串：");
        String line = sc.nextLine();

        // 调用办法，用一个变量接管后果
        String s = reverse(line);

        // 输入后果
        System.out.println("s:" + s);
    }

    // 定义一个办法，实现字符串反转
    /*
        两个明确：返回值类型：String
            参数：String s
     */
    public static String reverse(String s) {
        // 在办法中把字符串倒着遍历，而后把每一个失去的字符拼接成一个字符串并返回
        String ss = "";

        for(int i=s.length()-1; i>=0; i--) {ss += s.charAt(i);
        }

        return ss;
    }
}

| 办法名 | 阐明 |

| —————————————- | ———————————————- |

| public boolean equals(Object anObject) | 比拟字符串的内容，严格辨别大小写 (用户名和明码) |

| public char charAt(int index) | 返回指定索引处的 char 值 |

| public int length() | 返回此字符串的长度 |

StringBuilder 是一个可变的字符串类，咱们能够把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

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

罕用的构造方法
| 办法名 | 阐明 |

| ———————————- | —————————————— |

| public StringBuilder() | 创立一个空白可变字符串对象，不含有任何内容 |

| public StringBuilder(String str) | 依据字符串的内容，来创立可变字符串对象 |
示例代码

public class StringBuilderDemo01 {public static void main(String[] args) {//public StringBuilder()：创立一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：依据字符串的内容，来创立可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

增加和反转办法
| 办法名 | 阐明 |

| ————————————— | ———————— |

| public StringBuilder append(任意类型) | 增加数据，并返回对象自身 |

| public StringBuilder reverse() | 返回相同的字符序列 |
示例代码

public class StringBuilderDemo01 {public static void main(String[] args) {
        // 创建对象
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型)：增加数据，并返回对象自身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        // 链式编程
        sb.append("hello").append("world").append("java").append(100);

        System.out.println("sb:" + sb);

        //public StringBuilder reverse()：返回相同的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

StringBuilder 转换为 String
public String toString()：通过 toString() 就能够实现把 StringBuilder 转换为 String
String 转换为 StringBuilder
public StringBuilder(String s)：通过构造方法就能够实现把 String 转换为 StringBuilder
示例代码

public class StringBuilderDemo02 {public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        //String s = sb; // 这个是谬误的做法

        //public String toString()：通过 toString() 就能够实现把 StringBuilder 转换为 String
        String s = sb.toString();
        System.out.println(s);
        */

        //String 转换为 StringBuilder
        String s = "hello";

        //StringBuilder sb = s; // 这个是谬误的做法

        //public StringBuilder(String s)：通过构造方法就能够实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);

        System.out.println(sb);
    }
}

3.6.1 案例需要

定义一个办法，把 int 数组中的数据依照指定的格局拼接成一个字符串返回，调用该办法，

并在控制台输入后果。例如，数组为 int[] arr = {1,2,3};，执行办法后的输入后果为：[1, 2, 3]

3.6.2 代码实现

/*
    思路：1: 定义一个 int 类型的数组，用动态初始化实现数组元素的初始化
        2: 定义一个办法，用于把 int 数组中的数据依照指定格局拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
        3: 在办法中用 StringBuilder 依照要求进行拼接，并把后果转成 String 返回
        4: 调用办法，用一个变量接管后果
        5: 输入后果
 */
public class StringBuilderTest01 {public static void main(String[] args) {
        // 定义一个 int 类型的数组，用动态初始化实现数组元素的初始化
        int[] arr = {1, 2, 3};
        // 调用办法，用一个变量接管后果
        String s = arrayToString(arr);
        // 输入后果
        System.out.println("s:" + s);
    }

    // 定义一个办法，用于把 int 数组中的数据依照指定格局拼接成一个字符串返回
    /*
        两个明确：返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 在办法中用 StringBuilder 依照要求进行拼接，并把后果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i=0; i<arr.length; i++) {if(i == arr.length-1) {sb.append(arr[i]);
            } else {sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return  s;
    }
}

3.7.1 案例需要

定义一个办法，实现字符串反转。键盘录入一个字符串，调用该办法后，在控制台输入后果

例如，键盘录入 abc，输入后果 cba

3.7.2 代码实现

/*
    思路：1: 键盘录入一个字符串，用 Scanner 实现
        2: 定义一个办法，实现字符串反转。返回值类型 String，参数 String s
        3: 在办法中用 StringBuilder 实现字符串的反转，并把后果转成 String 返回
        4: 调用办法，用一个变量接管后果
        5: 输入后果
 */
public class StringBuilderTest02 {public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输出一个字符串：");
        String line = sc.nextLine();

        // 调用办法，用一个变量接管后果
        String s = myReverse(line);

        // 输入后果
        System.out.println("s:" + s);
    }

    // 定义一个办法，实现字符串反转。返回值类型 String，参数 String s
    /*
        两个明确：返回值类型：String
            参数：String s
     */
    public static String myReverse(String s) {
        // 在办法中用 StringBuilder 实现字符串的反转，并把后果转成 String 返回
        //String --- StringBuilder --- reverse() --- String
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;

       return new StringBuilder(s).reverse().toString();
    }
}

办法名	阐明
public StringBuilder append (任意类型)	增加数据，并返回对象自身
public StringBuilder reverse()	返回相同的字符序列
public int length()	返回长度，理论存储值
public String toString()	通过 toString() 就能够实现把 StringBuilder 转换为 String

这里有我收集的计算机类电子书籍，也有 Java 学习线路对应的教程视频，小伙伴们有趣味的能够自取哦，能够给个 start 的话就更好了~
https://github.com/unidentifi…
https://github.com/unidentifi…
本文由博客群发一文多发等经营工具平台 OpenWrite 公布

正文完

java

发表至： java

2021-02-05

0

力扣(LeetCode)763

关于java:虚拟机系列-执行引擎和垃圾回收

关于java:给-IDEA-换个酷炫的主题吧这个有点哇塞啊

关于java:Java-IO

关于java:京淘项目前端实现

关于java:JAVA基础系列-第8篇-API

学习指标

内容

1.API

1.1API 概述

1.2 如何应用 API 帮忙文档

2.String 类

2.1String 类概述

2.2String 类的特点

2.3String 类的构造方法

2.4 创立字符串对象两种形式的区别

2.5 字符串的比拟

2.5.1== 号的作用

2.5.2equals 办法的作用

2.6 用户登录案例

2.6.1 案例需要

2.6.2 代码实现

2.7 遍历字符串案例

2.7.1 案例需要

2.7.2 代码实现

2.8 统计字符次数案例

2.8.1 案例需要

2.8.2 代码实现

2.9 字符串拼接案例

2.9.1 案例需要

2.9.2 代码实现

2.10 字符串反转案例

2.10.1 案例需要

2.10.2 代码实现

2.11 帮忙文档查看 String 罕用办法

3.StringBuilder 类

3.1StringBuilder 类概述

3.2StringBuilder 类和 String 类的区别

3.3StringBuilder 类的构造方法

3.4StringBuilder 类增加和反转办法

3.5StringBuilder 和 String 互相转换

3.6 字符串拼接升级版案例

3.6.1 案例需要

3.6.2 代码实现

3.7 字符串反转升级版案例

3.7.1 案例需要

3.7.2 代码实现

3.8 帮忙文档查看 StringBuilder 罕用办法

站内搜索