API和String

1.API

1.1API概述

1.2API使用练习

注意：调用方法的时候，如果方法有明确的返回值，我们用变量接受，可以手动完成，也可以使用快捷键的方式完成（Ctrl+Alt+V）

2.String

2.1String概述

2.2 String构造方法

package com.szy005;

public class StringDemo {
    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','d'};
        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="abcdef";直接赋值的方式创建字符串对象，内容就是abcdef
        String s4="abcdef";
        System.out.println("s4:"+s4);
        //推荐使用直接赋值的方式得到字符串对象
    }
}

2.3 String对象的特点

通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同
```
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
```
上面的代码中，JVM首先会创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过s1和s2参考的字符串内容是相同的。

以""方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都智慧建立一个String对象，并在字符串池中维护。

String s3="abc";
String s4="abc";
//在上面的代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；第二行则让s4直接参考字符串池中的String对象，也就是说它们本质上是同一对象。

2.4字符串的比较

使用==做比较：

基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫equals()

public boolean equals(Object anObject):将此字符串与指定对象进行比较，由于我们比较的是字符串对象，所以参数直接传递一个字符串。

package com.szy005;

public class StringDemo2 {
    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));
    }

}

结果是：

false
false

true

true
true
true

案例1：用户登录

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

package com.szy005;
import java.util.Scanner;//导包
public class UserLogin {
    public static void main(String[] args) {
        //创建对象
        Scanner sc=new Scanner(System.in);
        String userName;
        String userName0="abcd";
        String password;
        String password0="123";

        for(int i=0;i<3;i++){
            System.out.println("请输入用户名：");
            userName=sc.nextLine();
            System.out.println("请输入密码：");
            password=sc.nextLine();
            if(userName.equals(userName0)&&password.equals(password0)){
                System.out.println("登录成功！");
                break;
            }else if(2-i==0){
                System.out.println("你的账户被锁定，请与管理员联系！");
            }
            else{
                System.out.println("输入错误信息！你还有"+(2-i)+"次机会");
            }
        }
    }
}

案例2：遍历字符串

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

分析：

遍历字符串首先能获取到字符串中的每一个字符，可以用：

public char charAt(int index):返回指定索引处的char值，字符串的索引也是从0开始的。
遍历字符串其次要能获取到字符串的长度，可以用：

public int length():返回此字符串的长度
- 数组的长度：数组名.length()
- 字符串的长度：字符串对象.length()
遍历字符串的通用格式：

for(int i;i<s.length();i++){

s.charAt(i);//指定索引处的字符值

}

package com.szy005;
import java.util.Scanner;
public class TraversalString {
    public static void main(String[] args) {
        //创建对象
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入字符串：");
        String s=sc.nextLine();//输入字符串
        System.out.println("字符串长度是："+s.length());
        System.out.println("字符串分别是：");
        for(int i=0;i<s.length();i++){
            System.out.println("["+i+"]:"+s.charAt(i));
        }
    }
}

案例3：统计字符次数

需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）

package com.szy005;
import java.util.Scanner;//导包
public class StringNum {
    public static void main(String[] args) {
        int count1=0;//大写字符个数
        int count2=0;//小写字符个数
        int count3=0;//数字字符个数
        int count4=0;//其他字符
        //创建对象
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();//接收输入的字符串
        for(int i =0; i<s.length(); i++){//遍历字符串
            if(s.charAt(i)>='A'&&s.charAt(i)<='Z'){
                count1++;
            }
            else if(s.charAt(i)>='a'&&s.charAt(i)<='z'){
                count2++;
            }else if(s.charAt(i)>='0'&&s.charAt(i)<='9'){//注意判断数字字符范围时要给数字加上引号
                count3++;
            }else{
                count4++;
            }
        }
        System.out.println("大写字符共："+count1+"个");
        System.out.println("小写字符共："+count2+"个");
        System.out.println("数字字符共："+count3+"个");
        System.out.println("其他字符共："+count4+"个");

    }
}

案例4：拼接字符串

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

package com.szy005;

public class SplicingString {
    public static void main(String[] args) {
        int[] array={1,2,4,5};
        String s1=splicingString(array);
        System.out.println(s1);
    }
    public static String splicingString(int[] arr){
        String s="";//定义s为空串
        s+="[";
        for(int i=0;i<arr.length;i++){
            if(i!=arr.length-1) {
                s += arr[i] + ",";
            }else{
                s+=arr[i];
            }
        }
        s+="]";
        return s;
    }

}

案例5:字符串反转

需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。例如：键盘录入abc,输出结果cba

package com.szy005;
import java.util.Scanner;
public class ReverseString {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//创建对象
        String s1=sc.nextLine();//接收数据
        s1=reverse(s1);//反转
        System.out.println(s1);
    }
    public static String reverse(String s1){
        String s2="";
        for(int i=0;i<s1.length();i++){//遍历s1
            s2=s1.charAt(i)+s2;
        }
        return s2;
    }
}

2.5 使用帮助文档查看String的使用方法

3.StringBuilder

3.1StringBuilder概述

如果对字符串进行拼接操作，每次拼接都会构建一个新的String对象，既耗时又浪费内存空间，而这种操作还不可避免，那么有没有一种比较好的方式可以解决这个问题呢？答案是肯定的，我们可以通过Java提供的StringBuilder类来解决这个问题。

StringBuilder：是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的。

String和StringBuilder的区别：

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

3.2StringBuilder构造方法

package com.szy005;
/*
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());
    }
}

3.3StringBuilder的添加和反转方法

package com.szy005;
/*
StringBuilder 的添加和反转方法
public StringBuilder append(任意类型):添加数据，并返回对象本身
public StringBuilder reverse():返回相反的字符序列
 */
public class StringBuilderDemo02 {
    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);
        System.out.println("sb:"+sb);

        //链式编程
        sb.append("big").append("small").append("hen").append(120);
        System.out.println("sb:"+sb);

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

3.4StringBuilder和String相互转换

StringBuilder转换为String

public StringtoString():通过toString()就可以实现把StringBuilder转换为String
String转换为StringBuilder

public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder

package com.szy005;
/*
   public String toString():通过toString()就可以实现把StringBuilder转换为String
   public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
 */
public class StringBuilderDemo03 {
    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 s1="hello000";
        //StringBuilder sb1=s1;//这是错误的做法
        //public StringBuilder(String s1):通过构造方法就可以实现把String转换为StringBuilder
        StringBuilder sb1=new StringBuilder(s1);
        System.out.println(sb1);

    }
}

案例：改进拼接字符串

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

package com.szy005;
/*
使用toString方法来拼接，可以节省空间，效率也会提升很多
 */
public class SplicingString2 {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        String s1=Splicing2(arr);
        System.out.println(s1);
    }
    public static String Splicing2(int[] arr){
        StringBuilder sb=new StringBuilder();//创建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]+"]");
            }

        }
        String s=sb.toString();//把sb转化为s
        return s;
    }
}

案例：改进字符串反转

//法1
package com.szy005;
import java.util.Scanner;
public class ReverseString2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//创建对象
        String s=sc.nextLine();//接收数据
        StringBuilder sb=new StringBuilder(s);//将s转化为StringBuilder类型的sb
        sb.reverse();//将sb里的反转
        s=sb.toString();//将sb转换为String类型
        System.out.println(s);//输出字符串
    }
}

package com.szy005;
import java.util.Scanner;
public class ReverseString3 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//创建变量
        String s=sc.nextLine();//接收变量
        s=myReverse(s);
        System.out.println(s);
    }
    public static String myReverse(String s){
        /*
        //法2
        StringBuilder sb=new StringBuilder(s);
        sb.reverse();
        String s1=sb.toString();
        return s1;
         */
        //法3
      return  (new StringBuilder(s).reverse().toString());

    }
}

3.5使用帮助文档查看StringBuilder的使用

相关阅读:
第11组团队Git现场编程实战
 团队项目-需求分析报告
 团队项目-选题报告
 第10组 Alpha事后诸葛亮
 第10组 Alpha冲刺（6/6）
第10组 Alpha冲刺（5/6）
第10组 Alpha冲刺（4/6）
第10组 Alpha冲刺（3/6）
第10组 Alpha冲刺（2/6）
第10组 Alpha冲刺（1/6）
原文地址：https://www.cnblogs.com/SZYJY/p/16078162.html