常用API（String、ArrayList）

API（应用程序接口）
Java写好的技术（功能代码），可以直接调用

String概述
    java.lang.String类代表字符串，String类定义的变量可以用于
    指向字符串对象，然后操作该字符串
    Java程序中的所有字符串文字（例如：“abc”）都为此类的对象
String类的特点详解
    String其实常被称为不可变字符串类型，它的对象在创建后不能被更改

public class Test {
    public static void main(String[] args) {
        String ch = "早上";
        ch += "中午";
        ch += "晚上";
        System.out.println(ch);//早上中午晚上
    }
}

从上述代码可以看出字符串变量ch指向的字符串对象，为何还要说字符串不可变呢？
字符串对象存在哪里？
    以""方式给出的字符串对象，在字符串常量池中存储
String不可变字符串的原因？
    String变量每次的修改其实都是产生并指向了新的字符串对象
    原来的字符串对象都是没有改变的，所以称为不可变字符串

创建字符串对象的两种方式
    方式一：直接使用""定义（推荐方式）
    String name = "紫霞";
    方式二：通过String类的构造器创建对象

构造器	说明
public String()	创建一个空白字符对象，不含任何内容
public String(String original)	根据传入的字符内串容，来创建字符串对象
public String(char[ ] ch)	根据字符数组的内容，来创建字符串对象
public String(bytr[ ] ch)	根据字节数组的内容，来创建字符串对象

public class Test {
    public static void main(String[] args) {
        //方式一
        String name = "我爱你中国！";
        System.out.println(name);

        //方式二
        //1、public String():创建一个空白字符串对象，不含任何内容（几乎不用）
        String s1 = new String();//s1=""
        System.out.println(s1);

        //2、public String(String):根据传入的字符串内容，来创建字符串对象（几乎不用）
        String s2 = new String("我是中国人！");
        System.out.println(s2);//我是中国人！

        //3、public String（char[] c ）:根据字符数组内容，来创建字符串对象
        char[] ch = {'a', 'b', 'c'};
        String s3 = new String(ch);
        System.out.println(s3);//abc

        //4、public String（byte[] b）:根据字节数组的内容，来创建字符串对象
        byte[] b = {65, 66, 67};
        String s4 = new String(b);
        System.out.println(s4);//ABC
    }
}

这几种方式有何区别？
    以""方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份
    通过构造器new对象，没new一次都会产生一个新对象，放在堆内存中

package com.deng.hello;

public class Test {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);//true

        char[] ch = {'a', 'b', 'c'};
        String s3 = new String(ch);
        String s4 = new String(ch);
        System.out.println(s3 == s4);//FALSE
    }
}

String类字符串的内容比较：
    推荐使用String类提供的“equals”比较：只关心内容一样即可

方法名	说明
public boolean equals（object anObject）	将此字符串与指定对象进行比较，只关心字符内容是否一致
public boolean equalsIgnoreCase（String  antherString）	将此字符串与指定对象进行比较，忽略大小写比较字符串，只关心字符内容是否一致

//登录验证

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //1、正确登录账户和密码
        String userName = "Java";
        String passWord = "123456";

        //2、请输入登录账户和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("登录账户：");
        String userNames = sc.next();
        System.out.println("账户密码：");
        String passWords = sc.next();

        //3、字符串比较是否一致
        if (userName.equals(userNames) && passWord.equals(passWords)) {
            System.out.println("登录成功！");
        } else {
            System.out.println("用户名或密码错误！");
        }
    }
}

//忽略大小写比较内容，一般用于验证码这样的业务逻辑
public class Test {
    public static void main(String[] args) {
        String Code = "7Ac3Bf";
        String Code1 = "7aC3bf";
        System.out.println(Code.equals(Code1));//false
        System.out.println(Code.equalsIgnoreCase(Code1));//true
    }
}

 String常用API

方法名	说明
public int length()	返回此字符串的长度
public char charAt(int index)	获取某个索引位置处的字符
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)	根据传入的规则切割字符串，得到字符串数组返回
public boolean contains(charSequence s)	判断字符串里是否包含某个字符串
public boolean startsWith(String prefix)	判断是否以某个字符串开始

public class Test {
    public static void main(String[] args) {
        //1、public int length()  返回此字符串的长度
        System.out.println("------------返回字符串长度--------------");
        String name = "我爱你中国";
        System.out.println(name.length());//5

        //2、public char charAt(int index)	获取某个索引位置处的字符
        System.out.println("------------获取某个索引位置的字符-----------");
        char c = name.charAt(1);
        System.out.println(c);//爱
        System.out.println("----------遍历输出字符串----------");
        for (int i = 0; i < name.length(); i++) {
            System.out.println(name.charAt(i));
        }

        //3、public char[] toCharArray():	将当前字符串转换成字符数组返回
        System.out.println("-------------将当前字符串转换成字符数组----------------");
        char[] chars = name.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        //4、public String substring(int beginIndex,int endIndex)	根据开始和结束索引进行截取，得到新的字符串（包前不包后）
        System.out.println("-----------根据开始和结束索引的位置进行截取-----------");
        System.out.println(name.substring(1, 3));

        //5、public String substring(int beginIndex)	从传入的索引处截取，截取到尾部，得到新的字符串
        System.out.println("------从当前索引截取到最后-------");
        System.out.println(name.substring(3));

        //6、public String replace(charSequence target,charSequence replacement)	使用新值，将字符中的旧值替换，得到新的字符串
        System.out.println("----------字符替换----------");
        String name1 = "你实在是太厉害了，棒棒哒！";
        System.out.println(name1.replace("棒棒哒", "***"));
        //7、public boolean contains(charSequence s)	判断字符串里是否包含某个字符串
        System.out.println("------------判断字符串里是否包含某个字符串--------------");
        System.out.println(name.contains("中国"));//ture
        System.out.println(name.contains("中山"));//false

        //8、public boolean startsWith(String prefix)	判断是否以某个字符串开始
        System.out.println("-----------判断是否以某个字符串开始------------");
        System.out.println(name.startsWith("我爱你"));//true
        System.out.println(name.startsWith("我爱"));//true
        System.out.println(name.startsWith("我爱1"));//false

        //9、public String[] split(String regex)	根据传入的规则切割字符串，得到字符串数组返回
        System.out.println("-----------根据字符切割返回字符数组-----------");
        String name3 = "小明、小红、小刚、小美、小帅";
        String[] s = name3.split("、");
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
    }
}

String案例

import java.util.Random;

public class Test {
    public static void main(String[] args) {
        //String类开发验证码功能
        //随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母

        //定义成一个字符串
        String stringNum = "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

        Random r = new Random();//随机数对象
        System.out.println("验证码：");
        //生成5个验证码
        String code = "";
        for (int i = 1; i <=5; i++) {
            int index = r.nextInt(stringNum.length());
            //System.out.print(stringNum.charAt(index));
            char c = stringNum.charAt(index);
            code += c;
        }
        System.out.println(code);
    }
}

用户登录

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //模拟用户登录，只给3次机会
        //1、先定义正午的的用户名和密码
        String okName = "sweet";
        String okPassword = "123456";

        //2、接收用户的登录信息
        Scanner sc = new Scanner(System.in);

        //3、3次容错机会
        for (int i = 1; i <= 3; i++) {
            System.out.println("账号：");
            String name = sc.next();//用户名
            System.out.println("密码：");
            String password = sc.next();//登录密码
            if (okName.equals(name)) {
                if (okPassword.equals(password)) {
                    System.out.println("登录成功！");
                } else {
                    System.out.println("密码错误，还剩" + (3 - i) + "次机会");
                }
            } else {
                System.out.println("账号错误，还剩" + (3 - i) + "次机会");
            }
        }
    }
}

手机号码屏蔽

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //手机号码屏蔽
        //例：135****8764
        Scanner sc = new Scanner(System.in);
        System.out.println("手机号码：");
        String tel = sc.next();

        //截取需要屏蔽的4位
        String num = tel.substring(3, 7);

        //将需要屏蔽的4位进行替换
        System.out.println(tel.replace(num, "****"));
    }
}

集合的特点
    1、集合的大小不固定，启动后可以动态变化，类型也可以选择不固定
    2、集合非常适合做元素个数不确定，且要进行增删操作的业务场景
    3、集合的提供了许多丰富、好用的功能，而数组的功能很单一
数组和集合的元素存储个数问题？
    数组定义后类型确定，长度固定
    集合类型可以不固定，大小是可变的
数组和集合适用的场景？
    数组适合做数据个数和类型确定的场景
    集合适合做数据个数不确定，且要做增删元素的场景
ArrayList是集合中的一种，它支持索引

ArrayList集合的对象获取

构造器	说明
public ArrayList（）	创建一个空的集合对象

ArrayList集合添加元素的方法

方法名	说明
public boolean add（E e）	将指定的元素追加到此集合的末尾
public void add（int index，E element）	在此集合中的指定位置插入指定的元素

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //创建ArrayList对象，代表集合容器，往里面添加元素
        //1、创建ArrayList集合的对象
        ArrayList list = new ArrayList();

        //2、添加元素
        list.add("java");
        list.add("python");
        list.add("MySQL");
        list.add(11);
        list.add(0.4);
        list.add(false);

        System.out.println(list);
        //3、按指定索引位置插入元素
        list.add(0, "C语言");
        System.out.println(list);
    }
}

ArrayList类如何创建集合对象的，如何添加元素？
    ArrayList list = new ArrayList（）;
    public boolean add（E e）
    public void add（int index，E element）

泛型概述
ArrayList<E>:其实是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型
举例：
    ArrayList<String>:此集合只能操作字符串类型的元素
    ArrayList<Integer>:此集合只能操作整数型的元素
注意：集合中只能存储引用类型，不支持基本数据类型

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list = new ArrayList<>();//JDK1.7开始，泛型后面的类型个声明可以不写
        list.add("Java");
        list.add("python");

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(22);
    }
}

ArrayList集合常用方法

方法名称	说明
public E get（int index）	返回指定索引处的元素
public int size（）	返回集合中的元素个数
public E remove（int index）	删除指定索引处的元素，返回被删除的元素
public boolean remove（Object o）	删除指定元素，返回删除是否成功
public E set（int index，E element）	修改指定索引处的元素，返回被修改的元素

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("python");
        list.add("Java");
        list.add("MySQL");
        list.add("HTML");
        list.add("C语言");

        //1、public E get（int index）	返回指定索引处的元素
        System.out.println("----------返回指定索引处的元素----------");
        String name = list.get(4);
        System.out.println(name);//HTML

        //2、public int size（）	返回集合中的元素个数
        System.out.println("----------返回集合中的元素个数---------");
        int arrSize = list.size();
        System.out.println(arrSize);//6

        //3、遍历集合元素
        System.out.println("------遍历输出集合元素------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));//遍历输出集合元素
        }

        //4、public E remove（int index）	删除指定索引处的元素，返回被删除的元素
        System.out.println("--------删除指定索引处的元素，返回被删除的元素-------");
        System.out.println(list.remove(3));
        System.out.println(list);


        //5、public boolean remove（Object o）	删除指定元素，返回删除是否成功
        System.out.println("--------删除指定元素，返回删除是否成功---------");
        System.out.println(list.remove("Java"));//集合里的数据有重复时，先删除前面的元素
        System.out.println(list);


        //6、public E set（int index，E element）	修改指定索引处的元素，返回被修改的元素
        System.out.println("-------修改指定索引处的元素，返回被修改的元素--------");
        System.out.println(list.set(0, "c"));
        System.out.println(list);
    }
}

案例：遍历并删除元素值
需求：
    某个班级的考试在系统上进行，成绩大致为：98,77,66,89,79,50,100
    现在需要先把成绩80分以下的数据去掉
分析：
    定义ArrayList集合存储多名学生成绩
    遍历集合中每个元素，将低于80分的成绩删除

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> scores = new ArrayList<>();
        scores.add(98);
        scores.add(77);
        scores.add(66);
        scores.add(89);
        scores.add(79);
        scores.add(50);
        scores.add(100);
        System.out.println(scores);
        //[98,77,66,89,79,50,100]

        //遍历集合中的每一个元素，删除小于80分的元素
        for (int i = scores.size() - 1; i >= 0; i--) {
            int score = scores.get(i);
            if (score < 80) {
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

案例：影片信息在程序中的表示
需求：某电影院系统需要在后台存储上述三部电影，然后一次展示出来
分析：
三部电影是3个对象，定义一个电影类，定义一个集合存储电影对象
创建3个电影对象，封装相关数据，把3个对象存入集合

public class Movie {
    private String movieName;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String movieName, double score, String actor) {
        this.movieName = movieName;
        this.score = score;
        this.actor = actor;
    }

    public String getMovieName() {
        return movieName;
    }

    public void setMovieName(String movieName) {
        this.movieName = movieName;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

 

import java.util.ArrayList;

//《肖申克的救赎》,9.7,罗宾斯
//《霸王别姬》,9.6,张国荣，张丰毅
//《阿甘正传》,9.5,汤姆，汉克斯
public class Test {
    public static void main(String[] args) {
        //定义对象集合
        ArrayList<Movie> movies = new ArrayList<>();

        //创建影片对象封装成电影数据，把对象放进集合
        //Movie m1 = new Movie("《肖申克的救赎》",9.7,"罗宾斯");
        //movies.add(m1);
        movies.add(new Movie("《肖申克的救赎》", 9.7, "罗宾斯"));
        movies.add(new Movie("《霸王别姬》", 9.6, "张国荣、张丰毅"));
        movies.add(new Movie("《肖申克的救赎》", 9.5, "汤姆、汉克斯"));

        //遍历集合中的对象输出
        for (int i = 0; i < movies.size(); i++) {
            Movie movie = movies.get(i);
            System.out.println("片名：" + movie.getMovieName());
            System.out.println("评分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }
    }
}

学生信息系统的数据搜索

学号	姓名	年龄	班级
20220001	叶孤城	24	计算机1班
20220002	东风不败	23	计算机2班
20220003	西门吹雪	25	计算机3班
20220004	梅超风	26	计算机4班

需求：后台程序存储以上学生信息并展示，然后要提供按照学号搜索学生信息的功能
分析：
    定义Student类，定义ArrayList集合存储学生对象信息系，并遍历展现出来
    提供一个方法，接收ArrayList集合和学号，返回该学号的学生信息并展现出来

public class Student {
    private String studentId;//学号
    private String studentName;//姓名
    private int age;//年龄
    private String className;//班级

    public Student() {
    }

    public Student(String studentId, String studentName, int age, String className) {
        this.studentId = studentId;
        this.studentName = studentName;
        this.age = age;
        this.className = className;
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getAge() {
        return age;
    }

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

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

import java.util.ArrayList;
import java.util.Scanner;


public class Test {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> students = new ArrayList<>();

        //将学生信息存入集合
        students.add(new Student("20220001", "叶孤城", 24, "计算机1班"));
        students.add(new Student("20220002", "东方不败", 23, "计算机2班"));
        students.add(new Student("20220003", "西门吹雪", 26, "计算机3班"));
        students.add(new Student("20220004", "梅超风", 26, "计算机4班"));

        //展现学生信息
        System.out.println("学号\t\t\t\t姓名\t\t\t\t年龄\t\t\t\t班级");
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);//将对象集合的地址给学生类对象
            System.out.println(student.getStudentId() + "\t\t" + student.getStudentName() + "\t\t\t" + student.getAge() + "\t\t\t\t" + student.getClassName());
        }

        //创建一个方法，接收ArrayList集合和学号，返回该学号的学生信息并展现出来
        System.out.println("请输入要查询学生信息的学号：");
        Scanner sc = new Scanner(System.in);
        String id = sc.next();
        Student student = getStudent(students, id);

        if (student == null) {
            System.out.println("查无此人！");
        } else {
            System.out.println(student.getStudentId() + "\t\t" + student.getStudentName() + "\t\t\t" + student.getAge() + "\t\t\t\t" + student.getClassName());
        }
    }

    //返回对应的学生信息的集合对象
    public static Student getStudent(ArrayList<Student> students, String Id) {
        //遍历集合里的每个学生对象
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            //判断此时学生对象里的学号与查询学号是否一致
            if (student.getStudentId().equals(Id)) {
                return student;//返回学生对象
            }
        }
        return null;//查无此人！
    }
}