Java-常用 API(String、ArrayList)_熟悉java标准库的常用api,如string、arraylist、hashmap等,掌握它们的使用

常用 API(String、ArrayList)

› API(Application Programming Interface，应用程序编程接口)

​ ● Java写好的技术(功能代码)，可以直接调用.

​ ● Oracle 也为Java提供了这些功能代码和相关的API文档(技术使用说明书).

▼ 下载API文档网址

http://www.oracle.com/technetwork/java/javase/downloads/index.html

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

String 简单介绍

​ ● String类定义的变量可以用于储存字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用.

＞ 关于 String 类学什么？

› String 定义变量储存字符串

◣需要知道如何创建字符串对象，并用String定义变量指向该字符串对象.

› String 的内存原理

◣字符串对象在内存中的原理是什么样.能够解决一些字符串的成绩面试题.

› String 类提供了哪些API

◣能够说出并使用String类提供的操作字符串的功能：遍历、替换、截取、相等、包含···

› String 解决实例

◣能够利用String的常用API去解决实际场景的业务需求，真正做到学以致用

◆ String 类概述

​ ● Java.lang.String 类代表字符串，String类定义的变量可以变量可以用于指向字符串对象，然后操作该字符串.

​ ● Java 查询中的所有字符串文字(例如：“abc”)都为此类的对象

＞ String 类的特点详解

​ ● String起始常被称为不可改变字符串类型，它的对象在创建后不能被更改.

＞ String是不可变字符串的原因 ：

​ ● String变量每次的修改其实都是产生并指向了类的字符串.

​ ● 原来的字符串对象都是没改变的，所以称不可变字符串.

◆ String 类创建对象的2种方式

＞ 方式一：总结使用 " " 定义.

String Word="文字";
1

＞ 方式二：通过String 类的构造器创建对象

public class StringDemo1 {
    public static void main(String[] args) {
        //方式一: 直接使用双引号得到字符串对象
        String Word="文字";
        System.out.println(Word);

        //方式二:
        //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[] chars = {'a','b','中','国'};
        String s3 = new String(chars);
        System.out.println(s3);

        //4.public String(byte b): 根据字节数组的内容，来创建字符串对象
        byte[] bytes={97,98,99,65,66,67};
        String s4=new String(bytes);
        System.out.println(s4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

◆ String 类创建面试题

＞ 有什么区别吗？(面试参考)

● 以 " " 方法给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份.

● 通过构造器new 对象，每new 一次都会产生一个新对象，放在堆内存中.

public class StringDemo1 {
    public static void main(String[] args) {
        String ss1 = "abc";
        String ss2 = "abc";
        System.out.println(ss1 == ss2);

        char[] char1 = {'a','b','c'};
        String ss3 = new String(char1);
        String ss4 = new String(char1);
        System.out.println(ss3 == ss4);
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12

◆ String 类常用API - 字符串内容比较

● 使用 ‘==’ 比较的的是地址 (比对基本数据类型)

● 使用 ‘equals’ 比较的的是内容 (比对引用数据类型)

● 使用 'equalsIgnoreCase ’ 忽略大小写进行比较的的是内容 (比对引用数据类型)

import java.util.Scanner;
public class StringDemo2 {
    public static void main(String[] args) {
        //成员变量
        String Name = "用户";
        String Pwd = "123456";

        //接收值
        Scanner input = new Scanner(System.in);
        System.out.print("请输入用户名: ");
        String name = input.next();
        System.out.print("请输入密码: ");
        String pwd = input.next();
        
        //与成员变量比对接收值
        System.out.println("------此处使用的是 '==' 进行的比对-----");
        if(name == Name && pwd == Pwd){
            System.out.println("正确");
        }else {
            System.out.println("错误");
        }
        System.out.println("------此处使用的是 '.equals(比对值)' 进行的比对-----");
        if(name.equals(Name) && pwd.equals(Pwd)){
            System.out.println("正确");
        }else {
            System.out.println("错误");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

◆ String 类常用API - 遍历、替换、截取、分隔操作

● 常用API

public class StringAPIOtherDemo3 {
    public static void main(String[] args) {
        //1.public int length(): 获取字符串的长度
        String word = "我爱祖国Love";
        System.out.println(word.length());
        
        //2.public char charAt(int index): 获取某个索引位置处的字符
        char c=word.charAt(4);
        System.out.println(c);

        System.out.println("----------遍历字符串中的每个字符--------");
        for (int i=0; i<word.length(); i++) {
            char cr = word.charAt(i);
            System.out.println(cr);
        }
        
        //3.public char[ ] toCharArray(): 把字符串换成字符数组
        char[] ar=word.toCharArray();
        System.out.println();
        for (int i=0; i<ar.length; i++){
            char ch=ar[i];
            System.out.println(ch);
        }
       
        //4.public String substring(int beginIndex, int endIndex): 截取内容，包前不包后
        String name = "Java是世界最厉害的语言";
        String rs1 = name.substring(0,9);
        System.out.println(rs1);
        String rs2 = name.substring(5,10);
        System.out.println(rs2);
        
        //5.public String substring(int beginIndex): 从当前索引一直截取到末尾
        String rs3 = name.substring(4);
        System.out.println(rs3);
        
        //6.public String replace(charSequence target,charSequence replacement): 比对文字，并替换
        String name2 = "张三厉害，张三狂徒.";
        String rs4 = name2.replace("张三","**");
        System.out.println(rs4);
        
        //7.public Boolean contains(CharSequence s): 比对当前成员变量中是否存在该变量
        System.out.println(name2.contains("张三"));
        System.out.println(name2.contains("张三"));
        
        //8.public Boolean startsWithstand(String prefix): 比对是否为当前成员变量的开头
        System.out.println(name.startsWith("张三"));
        System.out.println(name.startsWith("张三厉害"));
        System.out.println(name.startsWith("张三棒棒"));
        
        //9.public String[ ] split(String s):搜索某个内容把字符串分割成字符串数组返回
        String name3 = "张三,李四,王五";
        String[] names = name3.split(",");
        for (int i=0; i<names.length; i++){
            System.out.println("选择了:"+names[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

◆ String 类实例

● 实现随机生成验证码

import java.util.Random;
/* 使用String完成随机5位数的验证码 */
public class StringCode {
    public static void main(String[] args) {
        //1.定义可取的字符范围
        String verification = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        //2.利用 For 循环5次,每次循环从 verification 变量中随机取走一个字符
        Random random=new Random();
        String Code="";
        for (int i=0; i<5; i++){
            //按verification变量的长度随机生成一个数
            int index = random.nextInt(verification.length());
            //利用public char charAt(int index): 获取某个索引(index)位置处的字符
            char c = verification.charAt(index);
            //将获取到的随机值连起来通过Code接收
            Code += c;
        }
        System.out.println(Code);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

● 模拟用户登录

import java.util.Scanner;
/*
  模拟用户登录,3次重新登录机会
 */
public class StringLogin {
    public static void main(String[] args) {
        //成员变量
        String Name = "用户";
        String Pwd = "123456";
        //接收用户输入信息
        Scanner input = new Scanner(System.in);
        for (int i=0; i<3;i++){
            System.out.print("请输入用户名: ");
            String name=input.next();
            System.out.print("请输入密码: ");
            String pwd=input.next();

            if (name.equals(Name)){
                if (pwd.equals(Pwd)){
                    System.out.println("登录成功");
                    break;
                }else {
                    System.out.println("密码输入错误，请重新输入.你还有"+(2-i)+"机会");
                }
            }else {
                System.out.println("用户名错误，请重新输入，你还有"+(2-i)+"机会");
            }
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

● 手机号码屏蔽

import java.util.Scanner;
/* 接收号码，并替换号码 */
public class StringPhone {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入你的电话号码: ");
        String Phone=input.next();
        String s=Phone.substring(3,9);
        String Replace=Phone.replace(s,"******");
        System.out.println("你的电话为: "+Replace);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

ArrayList 简单介绍

​ ● ArrayList 代表的是集合类，集合是一种容器，不同的是集合的大小是不固定的.

​ ● 通过ArrayList 的对象代表得到一个集合容器，同时ArrayList 提供了比数组更好用，更丰富的API(功能)给程序员使用.

＞ 关于 ArrayList 类学什么？

› ArrayList 集合如何创建对象

◣要知道如何利用ArrayList 创建对象代表集合容器来存放数据.

› ArrayList 常用API

◣能够说出并使用ArrayList 类提供的丰富的元素操作的功能：添加、获取、删除、修改等功能.

› ArrayList 存储自定义对象

◣能够使用ArrayList存储自定义的对象，并清楚ArrayList 集合存储对象的底层原理.

› ArrayList 解决实例

◣能够使用ArrayList 存储对象，并完成数据搜索，删除···创建业务需求.

◆ ArrayList 集合概述

● 数组的特点

​ 数组定义完成并启动后，类型确定、长度固定.

​ 数组适合用于数据个数和类型确定的场景

● 集合的特点

​ 集合类型可以不固定，大小是可变

​ 集合适合数据个数不确定，且要做增删改查元素的场景

◆ ArrayList 集合快速入门

● ArrayList集合

​ ArrayList是集合中的一种，它支持索引.

● ArrayList集合的对象获取

● ArrayList集合添加元素的方法

------代码展示-------

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //1.创建ArrayList集合对象
        ArrayList list = new ArrayList();
        //2.添加数据
        list.add(120);
        list.add(9.8);
        list.add("Java");
        list.add('中');
        list.add("集合中可以添加各种类型的数据");
        System.out.println(list);
        //3.向指定位置添加数据
        list.add(1,"hollow");
        System.out.println(list);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

◆ ArrayList 对泛型的支持

● 泛型概述

​ ArrayList: 起始就是一个泛型类，可以在编译阶段约束集合只能操作某种数据类型.

● 案例

​ ArrayList: 此集合只能操作整数类型的元素

​ ArrayList: 此集合只能操作字符串类型的元素

※注意: 集合中只能存储引用类型，不支持基本数据类型

------代码展示-------

import java.util.ArrayList;
/* 目标: 能够使用ArrayList集合操作的数据类型 */
public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<Object> listObject=new ArrayList<>();         //支持所有的类型
        listObject.add(120);
        listObject.add(9.8);
        listObject.add("Java");
        listObject.add('中');
        listObject.add("集合中可以添加各种类型的数据");
        ArrayList<String> listString1=new ArrayList<String>();  //只支持String类型
        ArrayList<String> listString2=new ArrayList<>();        //从JDK 1.7开始,泛型后面的类型声明可以不写
        //listString2.add(120);
        //listString2.add(9.8);
        listString2.add("Java");
        listString2.add("集合中只支持String类型的数据");
        ArrayList<Integer> listInteger=new ArrayList<>();       //只支持String类型
        listInteger.add(120);
        //listInteger.add(9.8);
        //listInteger.add("Java");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

◆ ArrayList 常用API - 遍历

● ArrayList集合常用方法

------代码展示-------

import java.util.ArrayList;

public class ArrayListDemo3 {
    public static void main(String[] args) {
        ArrayList<String> listString=new ArrayList<>();
        listString.add("Java");
        listString.add("Java");
        listString.add("MySQL");
        listString.add("HTML");
        listString.add("MyBatis");
        //1.public E get(int index): 获取某个索引位置处的元素值
        String e = listString.get(3);
        System.out.println(e);
        //2.public int size(): 获取集合的大小(元素个数)
        System.out.println(listString.size());
        //3.完成集合的遍历
        for (int i=0; i<listString.size(); i++){
            System.out.println(listString.get(i));
        }
        /* for (String s : listString) { System.out.println(s); } */
        //4.public E remove(int index): 删除指定索引处的元素，返回被删除的元素
        System.out.println(listString);
        String e2 = listString.remove(2);
        System.out.println(e2);
        System.out.println(listString);
        //5.public boolean remove(Object o): 直接删除元素值，删除成功返回true，删除失败返回false
        listString.remove("Java");
        System.out.println(listString);
        //6.public E set(int index,E element): 修改指定索引处的元素，返回被修改的元素
        String e3 = listString.set(2,"MySql");
        System.out.println(e3);
        System.out.println(listString);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

◆ ArrayList 集合案例：遍历并删除元素

import java.util.ArrayList;
/* 目标:学习遍历删除元素的正确方案 */
public class ArratListDemo4 {
    public static void main(String[] args) {
        ArrayList<Integer> listInteger = new ArrayList<>();
        listInteger.add(79);
        listInteger.add(87);
        listInteger.add(100);
        listInteger.add(97);
        listInteger.add(73);
        listInteger.add(80);
        System.out.println(listInteger);

        for (int i=0; i<listInteger.size(); i++){
            int score = listInteger.get(i); //将索引值暂时存储在score中
            if (score>=80){
                System.out.println(score);
            }else {
                listInteger.remove(i);
                i--;                        //删除成功后,必须退一步,这样可以保证下次回到这个位置,如此不会跳过数据
            }
        }

        //重后面到这删除就可以
        for (int i = listInteger.size()-1; i >=0 ; i--) {
            int score = listInteger.get(i);
            if (score>=80){
                System.out.println(score);
            }else {
                listInteger.remove(i);
            }
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

◆ ArrayList 集合案例：存储自定义类型的对象

/* 电影类 */
public class Movie {
    //成员变量
    private String File;
    private double Score;
    private String Name;

    //构造
    public Movie() { }
    public Movie(String file, double score, String name) { File = file; Score = score; Name = name; }

    //封装
    public String getFile() { return File; }
    public void setFile(String file) { File = file; }

    public double getScore() { return Score; }
    public void setScore(double score) { Score = score; }

    public String getName() { return Name; }
    public void setName(String name) { Name = name; }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import cn.ObjectOriental.MoviesShow.Movie;
import java.util.ArrayList;
/*
方法1：
 需求：定义电影类（名称、分值、演员）,创建三个电影对象,代表影片,插入集合中遍历
    "《长津湖》",9.8,"吴京"
    "《我和我的父辈》",9.6,"吴京"
    "《扑水少年》",9.5,"王川"
 */
public class ArrayListDemo5 {
    public static void main(String[] args) {
        /*1.定义电影类Movie*/
        /*2.创建3个电影对象*/
        Movie m1 = new Movie("《长津湖》",9.8,"吴京");
        Movie m2 = new Movie("《我和我的父辈》",9.6,"吴京");
        Movie m3 = new Movie("《扑水少年》",9.5,"王川");
        /*3.创建一个电影对象的ArrayList集合,并存储电影对象*/
        ArrayList<Movie> list = new ArrayList<>();
        list.add(m1);
        list.add(m2);
        list.add(m3);
        System.out.println(list);  //此时list集合中存储的是指向电影对象的地址
        /*4.遍历电影类型的集合中的每一个对象.访问它的信息即可*/
        for (int i = 0; i < list.size(); i++) {
            Movie m = list.get(i); //定义对象来接它遍历对象的地址
            System.out.println("电影名称: "+m.getFile());
            System.out.println("电影评分: "+m.getScore());
            System.out.println("电影主演: "+m.getName());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import cn.ObjectOriental.MoviesShow.Movie;
import java.util.ArrayList;
/*
方法2：使用匿名对象
 需求：定义电影类（名称、分值、演员）,创建三个电影对象,代表影片,插入集合中遍历
    "《长津湖》",9.8,"吴京"
    "《我和我的父辈》",9.6,"吴京"
    "《扑水少年》",9.5,"王川"
 */
public class ArrayListDemo5 {
    public static void main(String[] args) {
        /*1.定义电影类Movie*/
        /*2.创建3个电影对象*/
        /*3.创建一个电影对象的ArrayList集合,并存储电影对象*/
        ArrayList<Movie> list = new ArrayList<>();
        list.add(new Movie("《长津湖》",9.8,"吴京"););
        list.add(new Movie("《我和我的父辈》",9.6,"吴京"););
        list.add(new Movie("《扑水少年》",9.5,"王川"););
        System.out.println(list);  //此时list集合中存储的是指向电影对象的地址
        /*4.遍历电影类型的集合中的每一个对象.访问它的信息即可*/
        for (int i = 0; i < list.size(); i++) {
            Movie m = list.get(i); //定义对象来接它遍历对象的地址
            System.out.println("电影名称: "+m.getFile());
            System.out.println("电影评分: "+m.getScore());
            System.out.println("电影主演: "+m.getName());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

◆ ArrayList 集合案例：元素搜索

public class Student {
    private String studyNumber;     //学号
    private String name;            //姓名
    private int age;                //年龄
    private String className;       //教室

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

    public String getStudyNumber() { return studyNumber; }
    public void setStudyNumber(String studyNumber) { this.studyNumber = studyNumber; }

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

    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; }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.ArrayList;
import java.util.Scanner;
/* 案例:学生信息系统,显示数据,并按照学号完成搜索学生类信息
*  测试数据:
*  "BI035gEYy","一叶孤城",22,"推理一班"
*  "wqA90HQpU","东方延绪",26,"中医学四班"
*  "0uzRxJv6o","西门吹雪",24,"法医系三班"
*  "bUQqiml3Z","东梅超风",21,"精神科五班"
*  "Uo7Hbykpb","西方不败",27,"修理学二班" */
public class ArrayListStudent {
    public static void main(String[] args) {
        //1.创建学生类
        //2.创建学生对象封装学生对象
        //把学生对象添加到集合中去
        ArrayList<Student> liststudent = new ArrayList<>();
        liststudent.add(new Student("BI035gEYy","一叶孤城",22,"推理一班" ));
        liststudent.add(new Student("wqA90HQpU","东方延绪",26,"中医学四班"));
        liststudent.add(new Student("0uzRxJv6o","西门吹雪",24,"法医系三班"));
        liststudent.add(new Student("bUQqiml3Z","东梅超风",21,"精神科五班"));
        liststudent.add(new Student("Uo7Hbykpb","西方不败",27,"修理学二班"));
        //3.遍历变量集合中的每个信息并打印
        System.out.println("学号"+"\t\t\t"+"姓名: "+"\t\t"+"年龄: "+"\t"+"班级: ");
        for (int i = 0; i < liststudent.size(); i++) {
            Student s = liststudent.get(i);
            System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName());
        }
        //4.定义方法按照学号查询学员信息
        Scanner input=new Scanner(System.in);
        while (true){
            System.out.print("请输入学号查询对象: ");
            String studyNumber = input.next();
            //5.调用方法查询
            Student s = getStudyId(liststudent,studyNumber);
            //6.判断s中是否存在学生地址
            if(s == null){
                System.out.println("对不起,查无此人(￣▽￣)~*");
            }else {
                System.out.println("你查询的学生信息如下:");
                System.out.println("学号"+"\t\t\t"+"姓名: "+"\t\t"+"年龄: "+"\t"+"班级: ");
                System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName()+"\n");
            }
        }
    }
    /* 根据学生的学号查询学生对象返回
    * @param students 存储全部学生对象的集合
    * @param studyNumber 搜索的学生对象的集合
    * @return 学生对象 | null
    * */
    public static Student getStudyId(ArrayList<Student> liststudent,String studyNumber){
        //1.遍历全部学生对象
        for (int i = 0; i < liststudent.size(); i++) {
            Student s = liststudent.get(i);
            //2.询问当前遍历的这个学生的学号:是否我们要找的学号
            if(s.getStudyNumber().equals(studyNumber)){
                //这个s代表的学生对象,就是我们要找的,返回它
                return s;
            }
        }
        //查无此人
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62