API

API

1.API(Application Programming Interface):应用程序编程接口

Java API：指的是jdk中提供的各种功能的Java类。

这些类将底层的实现封装起来，帮助文档了解API的使用

 

API文档：如何使用？

注意：调用方法的时候，如果方法有明确的返回值，我们用变量接收，

可以手动完成，也可以快捷键完成(ctr+Alt+v).

1. String

string类在java.lang包下，所以不用导包。Java程序中所有的双引号字符串，都是String 类的对象。

字符串特点：

l 字符串不可变，它的值在创建后不能被更改。

l 虽然String值不可变，但是可以被共享。

l 字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[])

1. String构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含
public String(char[])	根据字符数组内容，创建字符串对象
public String(byte[])	根据字节数组内容，创建字符串对象
String s=”abc”;	直接赋值的方式创建字符串对象，内容abc.(推荐使用)

 

/*public String()
public String(char[])
public String(byte[])
String s=”abc”;推荐使用直接赋值
*/
public class StringDemo {
    public static void main(String[] args) {
//        public String()
        String s1 = new String();        //创建一个字符串对象
        System.out.println("s1:" + s1);
//        public String(char[])
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);              //创建一个字符串对象
        System.out.println("s2:"+s2);
//        public String(byte[])
        byte[] by = {97, 98, 99};
        String s3 = new String(by);          //创建一个字符串对象
        System.out.println("s3:"+s3);
//           String s=”abc”;
        String s4="abc";
        System.out.println(s4);
    }
}

 

1. String两种方法得到对象特点：

l 通过new创建字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但地址不同。

String s1 = new String();    

String s2 = new String(chs);

这里的两个对象的地址值是不同的s1=001  s2=002

l 直接赋值得到

String s3="abc";

String s4="abc";

这里s3和s4的地址值是相同的都是004

 

 

String字符串的比较

使用==作比较

l 基本类型：比较的是数据值是否相同

l 引用类型：比较地址值是否相同

 

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

l Public boolean equals(Object anObject):将此字符串与指定对象比较。因为我们比较的是字符串对象，所以参数直接传递一个字符串

//equals方法比较对象内容是否相同。
public class StringDemo {
    public static void main(String[] args) {
        //构造方法的到对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        String s3 = new String(chs);

        //直接赋值得到对象
        String s4 = "abc";
        String s5 = "abc";
        String s6 = "abc";

        //比较字符串地址值是否相同
        System.out.println(s4 == s5 && s5 == s6);       //直接赋值得到地址值相同
        System.out.println(s2 == s3);              //构造方法创建对象地址值不同
        System.out.println(s2 == s4);
        System.out.println(s3 == s5);

        //比较字符串内容是否相同。
        System.out.println(s2.equals(s3));  //true 说明s2和s3内容是相同的，都是abc
        System.out.println(s3.equals(s4)); //true 说明s3和s4内容是相同的，都是abc
        System.out.println(s4.equals(s5)); //true
        System.out.println(s5.equals(s6)); //true
    }
}

 

 

 

 

 

String：用户登录

/*
已知用户名和密码，程序实现模拟登录。总共给3次机会。
已知：用户名密码、键盘输入要登陆的用户名和密码。
比较键盘录入的密码用户名和已知的进行比较。
循环实现多次机会for(){},break结束
*/
public class StringDemo {
    public static void main(String[] args) {
        //   循环实现3次机会for(){},break结束
        for(int i=1;i<4;i++){

//        已知：用户名密码
            String usename = "murongkang";
            String password = "123456";
//        键盘输入要登陆的用户名和密码。
            Scanner name = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String line = name.nextLine();     //输入用户名
            System.out.println("输入用户名是：" + line);
            Scanner pw = new Scanner(System.in);
            System.out.println("请输入密码：");
            String mi = pw.nextLine();             //输入密码
            System.out.println("输入密码是：" + mi);
            //判断内容 比较键盘录入的密码用户名和已知的进行比较。
            if (line.equals(usename) && mi.equals(password)) {
                System.out.println("登录成功");
                break;        //如果成功就直接结束循环
            } else {
                if(3-i==0){
                    System.out.println("您的账户被锁定，请联系管理员");
                }else{
                //2、1、0 机会
                //i的值 1、2、3
                System.out.println("登录失败，您还有"+(3-i)+"次机会");
                }
            }
        }
    }
}

String

遍历字符串：

charAt( int index):返回指定索引处的char值，字符串的索引也是从0开始的。 //对象名.charAt(索引位置)获取指定字符

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

字符串长度：字符串对象.length()

import java.util.Scanner;

/**
 * @author murongkang
 * @date 2019-08-18 14:35
 */
//键盘录入一个字符串，使用程序在控制台遍历该字符串。
public class StringArray {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();//键盘录入字符串
      /*  System.out.println(line.charAt(0));   //对象名.charAt(索引位置)获取指定字符
        System.out.println(line.charAt(1));
        System.out.println(line.charAt(2));*/
        for (int i = 0; i <line.length() ; i++) {          //for循环遍历字符串的每个字符
            System.out.println(line.charAt(i));              //对象名.charAt(索引位置)获取指定字符
        }
    }
}

 

 

 

 

 

统计字符次数

import java.util.Scanner;
/**
 * @author murongkang
 * @date 2019-08-18 15:21
 */
/*需求：键盘录入字符串，统计大写字母次数，小写字母字数，数字出现字数。（不考虑其他字符）
 统计三种字符的字符个数，需要定义三个统计变量。
    如何判断：大写字母：ch>='A'&&ch<'Z'
             小写字母：ch>='a'&&ch<'z'
             数字：ch>='0'&&ch<'9'*/
public class StringCi {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        int countA = 0;             //大写字母计数
        int counta = 0;              //小写字母计数
        int count1 = 0;              //数字计数
        for (int i = 0; i < line.length(); i++) {     //遍历字符串
            char ch = line.charAt(i);     // 把每个字符赋值给变量c
            if ( ch >= 'A' && ch < 'Z'){
              countA++;                    //计数器
            }else if(ch>='a'&&ch<'z'){
                counta++;
            }else if(ch>='0'&&ch<'9'){
                count1++;
            }
        }
        //输出次数
        System.out.println("大字字母出现字数"+countA);
        System.out.println("小写字母出现次数："+counta);
        System.out.println("数字出现次数："+count1);
    }
}

请输入一个字符串：

SJHsdf123

大字字母出现字数3

小写字母出现次数：3

数字出现次数：3

 

字符串拼接：

拼接字符串：
需求：定义一个方法，把数组int[]arr={1,2,3};执行方法后的输出结果为：[1,2,3];
*/
public class String1 {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        String st = StringDemo(arr);
        System.out.println("把数组拼接后效果："+st);
    }
    //定义一个方法，两个明确
    public  static String  StringDemo(int[] arr ){
        String s="";                   //定义一个变量字符串  s是一个空格
        s+="[";                        //s=s+[
        for (int i = 0; i <arr.length ; i++) {
            if(i==arr.length-1){                 //如果是最后一个元素
                s+=arr[i];                      //就s=s+arr[i];把最后一个元素赋值给字符串
            }else{
                s+=arr[i];               //[ 1
                s+=',';                  //[ 1,  拼接一个，
            }
        }
        s+="]";
        return s;
    }
}

把数组拼接后效果：[1,2,3]

 

 

 

 

 

 

字符串反转：

import java.util.Scanner;

/*需求：定义一个方法，实现字符串反转，键盘录入一个字符串，调用方法输出。
如：键盘录入abc   输出cba*/
public class String2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        String demo = StringDemo(line);
        System.out.println(demo);
    }
    //定义一个方法：两个明确  返回String类型，参数 string s
    public static String StringDemo(String s){
        String ss="";           //定义一个空字符串，怎么把值返回到空字符串里
        for (int i = s.length()-1; i >=0; i--) {       //s.length()-1指的是字符串的长度-1，也就是从最后一个元素开始，倒序执行
            ss+=s.charAt(i);         //把最后一个指定元素值赋值给字符串ss
        }
        return ss;
    }
}

 

 

帮助文档查看String方法

方法名	说明
Public boolean equals()	比较字符串内容，区分大小写(用户名密码)
..charAt(索引值)	指定索引处值
Public int length()	返回字符串长度

 

StringBuilder概述:

StringBuilder是一个可变的字符串类，相当于一个容器，可变指的是StringBuilder对象中的内容是可变的。

String和StringBuild 的区别

String:内容是不可变的

StringBuilder：内容可变的

 

StringBuilder构造方法:

l Public StringBuild() 创建一个空白可变字符串对象，不含任何内容

l Public StringBuild(String  a) 根据字符串内容创建可变字符串对象

package com.ithema;
//StringBuild构造方法
/**
 * @author murongkang
 * @date 2019-08-18 18:58
 */
/*lPublic StringBuild() 创建一个空白可变字符串对象，不含任何内容
  lPublic StringBuild(String  a) 根据字符串内容创建可变字符串对象*/

public class String3 {
    public static void main(String[] args) {
//        Public StringBuild() 创建一个空白可变字符串对象，不含任何内容
        StringBuilder sc = new StringBuilder();
        System.out.println("sc:" + sc);           //sc:
        System.out.println(sc.length());            //0    长度为0，就是空字符串，相当于容器

//        Public StringBuild(String  a) 根据字符串内容创建可变字符串对象
        StringBuilder sb=new StringBuilder("hello");      //给hello参数放进容器
        System.out.println("sb:"+sb);                //sb:hello
        System.out.println("sb.length():"+sb.length());    //sb.length():5

    }
}

sc:

0

sb:hello

sb.length():5

 

---------------------------------------------

 

StringBuilder的添加和反转

 

StringBuilder  append(任意类型)	添加数据，并返回本身
StringBuilder  reverse()	返回相反的字符序列--反转

package com.ithema;
/**
 * @author murongkang
 * @date 2019-08-18 19:18
 */
//StringBuilder  append(任意类型)              添加数据，并返回本身
//StringBuilder  reverse()                     返回相反的字符序列

public class String4 {
    public static void main(String[] args) {
        StringBuilder sc = new StringBuilder();
        //StringBuilder  append(任意类型)              添加数据，并返回本身
    /*    StringBuilder sc1 = sc.append("Hello");
        System.out.println(sc);
        System.out.println(sc1);
        System.out.println(sc == sc1);        //true  */

        /*sc.append("hello");
        sc.append("world");
        sc.append("java");
        sc.append(100);
        System.out.println("sc:"+sc);*/

        //链式编程
        sc.append("hello").append("world").append("java").append(100);
        System.out.println(sc);                  //helloworldjava100

        //StringBuilder  reverse()                     返回相反的字符序列
        sc.reverse();
        System.out.println(sc);                  //001avajdlrowolleh  直接把结果反过来输出
    }
}

 

helloworldjava100

001avajdlrowolleh

 

StringBuild和String相互转换

 

1. 通过tostring()把StringBuild转换为String
2. Public StringBuilder(String s)：通过构造方法把string转换StringBuild

package com.ithema;

/**
 * @author murongkang
 * @date 2019-08-18 19:59
 */
public class String5 {
    public static void main(String[] args) {

        //    1.通过tostring()把StringBuild转换为String
      /*  StringBuilder sc = new StringBuilder();
        sc.append("hello");
        String ss = sc.toString();
        System.out.println(ss);*/

        //   2.Public StringBuilder(String s)：通过构造方法把string转换StringBuild
        String s = "hello";
        StringBuilder sc = new StringBuilder(s);
        System.out.println(s);

    }
        }

 

 

字符串拼接StringBuild

/**
 * @author murongkang
 * @date 2019-08-18 20:12
 */
/*需求:定义一个方法，把int数组拼接成一个字符串，调用方法输出，要求用StrinBuild
如int[] arr={1,2,3}    输出：[1,2,3]*/
public class String6 {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        String c=StringDemo(arr);
        System.out.println(c);
    }
    public  static  String StringDemo(int[] arr){
        StringBuilder sc=new StringBuilder();
        sc.append("[");
        for (int i = 0; i <arr.length ; i++) {
           if(i==arr.length-1){
               sc.append(arr[i]);       //把最后一个元素添加上去
           }else{
               sc.append(arr[i]).append(",");       //前面的元素加上去,在拼接一个，
           }
        }
        sc.append("]");
        String s1 = sc.toString();           //转换成string类型
        return  s1;

    }
}

[1,2,3]

package com.ithema;
/*字符串反转        StringBuild
abc  输出cba*/

import java.util.Scanner;

/**
 * @author murongkang
 * @date 2019-08-18 20:34
 */
public class String7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        String s3 = StringDemo1(line);
        System.out.println(s3);

    }

    public static String StringDemo1(String s) {
        //String---StringBuild---reverse--string
        StringBuilder sc = new StringBuilder(s);  //把String 转换成StringBuild
        sc.reverse();         //反转
        String s1 = sc.toString();    //转String 类型
        return s1;

    }

}