Java从入门到精通 - 常用API（一） - 详解

常用 API

此笔记参考黑马教程，仅学习使用，如有侵权，联系必删

文章目录

• 常用 API
• • 1. 包
  • • 代码演示
  • 2. String
  • • 2.1 String 概述
    • • 代码演示
      • 总结
    • 2.2 String 的常用方法
    • • 代码演示
    • 2.3 String 使用时的注意事项
    • • 第一点
      • 第二点
      • • 代码演示
      • 总结
      • 题目
    • 2.4 String 的应用案例
    • • 2.4.1 案例一
      • 2.4.2 案例二
  • 3. ArrayList
  • • 3.1 ArrayList 快速入门
    • • 代码演示
      • 总结
    • 3.2 ArrayList 应用案例
    • • 代码实现
      • 总结
    • ArrayList 综合案例
    • • 代码实现
  • 总结

API（全称 Application Programming Interface：应用程序编程接口）

就是别人写好的一些代码，给咱们程序员直接拿去调用即可解决问题的

• Java 提供了哪些 API 给咱们使用呢？

  • API 文档

• 为什么要先学习包？

  • 包是分门别类管理程序的
  • 别人写好的程序通常都在别人的包里面！

1. 包

什么是包？

• 包是用来分门别类地管理各种不同程序的，类似于文件夹，建包有利于程序的管理和维护
• 建包的语法格式：
  • Idea 会帮我们自动建

package com.itfeng.javabean
;
public
class Student {
}

在自己程序中调用其他包下的程序的注意事项

• 如果当前程序中，要调用自己所在包下的其他程序，可以直接调用（同一个包下的类，互相可以直接调用）
• 如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包，才可以访问！导包格式：import 包名.类名;
• 如果当前程序中，要调用 Java 提供的程序，也需要先导包才可以使用；但是 Java.lang 包下的程序是不需要我们导包的，可以直接使用
• 如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问

代码演示

• s_pkg.itcast.Demo1.java

package s_pkg.itcast
;
public
class Demo1 {
public
void print(
) {
System.out.println("Hello World2"
)
;
}
}

• s_pkg.itcast.Demo2.java

package s_pkg.itcast
;
public
class Demo2 {
public
void print(
) {
System.out.println("itcast"
)
;
}
}

• s_pkg.itfeng.Demo2.java

package s_pkg.itfeng
;
public
class Demo2 {
public
void print(
) {
System.out.println("itfeng"
)
;
}
}

• s_pkg.Demo.java

package s_pkg
;
public
class Demo {
public
void print(
) {
System.out.println("Hello World"
)
;
}
}

• s_pkg.Test.java

package s_pkg
;
import s_pkg.itcast.Demo1
;
import s_pkg.itfeng.Demo2
;
import java.util.Random
;
import java.util.Scanner
;
public
class Test {
public
static
void main(String[] args) {
// 1. 同一个包下的程序，可以直接访问
Demo d =
new Demo(
)
;
d.print(
)
;
// Hello World
// 2. 访问其他包下的程序，必须导包才可以访问
Demo1 d2 =
new Demo1(
)
;
d2.print(
)
;
// Hello World2
// 3. 自己的程序中调用Java提供的程序，也需要先导包才可以使用；但是Java.lang包下的程序是不需要我们导包的，可以直接使用
Scanner sc =
new Scanner(System.in)
;
String s = "Feng"
;
Random r =
new Random(
)
;
// 4. 访问多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问
Demo2 d3 =
new Demo2(
)
;
d3.print(
)
;
// itfeng
s_pkg.itcast.Demo2 d4 =
new s_pkg.itcast.Demo2(
)
;
d4.print(
)
;
// itcast
}
}

---

2. String

2.1 String 概述

java.lang.String 代表字符串

对字符串处理的步骤：

1. 创建对象
2. 封装字符串数据
3. 调用 String 的方法

• 方式一：Java 程序中的所有字符串文字（例如 “abc”）都为此类的对象

String name = "张三"
;
String schoolName = "FengSchool"
;

• 方式二：调用 String 类的构造器初始化字符串对象（字符串拼接）

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

代码演示

package t_string
;
public
class StringDemo1 {
public
static
void main(String[] args) {
// 目标：掌握创建String对象，并封装要处理的字符串的两种方式
// 1. 直接双引号得到字符串对象，并封装字符串数据
String name = "itfeng"
;
System.out.println(name)
;
// itfeng
// 2. new String创建字符串对象，并调用构造器初始化字符串
String rs1 =
new String(
)
;
System.out.println(rs1)
;
// ""
String rs2 =
new String("itfeng"
)
;
// 不太推荐
System.out.println(rs2)
;
// itfeng
char[] chars = {
'a'
, '哈'
, '嘿'
}
;
String rs3 =
new String(chars)
;
// a哈嘿
System.out.println(rs3)
;
byte[] bytes = {
97
, 98
, 99
}
;
String rs4 =
new String(bytes)
;
System.out.println(rs4)
;
// abc
}
}

总结

1. String 是什么，可以做什么？

• 代表字符串，可以用来创建对象封装字符串数据，并对其进行处理

2. String 类创建对象封装字符串数据的方式有几种？

• 方式一：直接使用双引号 "..."
• 方式二：new String 类，调用构造器初始化字符串对象

---

2.2 String 的常用方法

方法名	说明
public int length()	获取字符串的长度返回（就是字符个数）
public char charAt(int index)	获取某个索引位置处的字符返回
public char[] toCharArray():	将当前字符串转换成字符数组返回
public boolean equals(Object anObject)	判断当前字符串与另一个字符串的内容一样，一样返回 true
public boolean equalsIgnoreCase(String anotherString)	判断当前字符串与另一个字符串的内容是否一样（忽略大小写）
public String substring(int beginIndex, int endIndex)	根据开始和结束索引进行截取，得到新的字符串（包前不包后）
public String substring(int beginIndex)	从传入的索引处截取，截取到末尾，得到新的字符串返回
public String replace(CharSequence target, CharSequence replacement)	使用新值，将字符串中的旧值替换，得到新的字符串
public boolean (CharSequence s)	判断字符串中是否包含了某个字符串
public boolean startsWith(String prefix)	判断字符串是否以某个字符串内容开头，开头返回 true，反之
public String[] split(String regex)	把字符串按照某个字符串内部分割，并返回字符串数组回来

代码演示

package t_string
;
public
class StringDemo2 {
public
static
void main(String[] args) {
// 目标：快速熟悉String提供的处理字符串的常用方法
String s = "FengJava"
;
// 1. 获取字符串的长度
System.out.println(s.length(
)
)
;
// 8
// 2. 提取字符串中某个索引位置处的字符
char c = s.charAt(1
)
;
System.out.println(c)
;
// e
// 字符串的遍历
for (
int i = 0
; i < s.length(
)
; i++
) {
char ch = s.charAt(i)
;
System.out.println(ch)
;
}
System.out.println("----------------------------"
)
;
// 3. 把字符串转换成字符数组，再进行遍历
char[] chars = s.toCharArray(
)
;
for (
int i = 0
; i < chars.length; i++
) {
System.out.println(chars[i]
)
;
}
// 4. 判断字符串内容，内容一样就返回true
String s1 =
new String("feng"
)
;
String s2 =
new String("feng"
)
;
System.out.println(s1.equals(s2)
)
;
// true
// 5. 忽略大小写比较字符串内容
String c1 = "34AeFG"
;
String c2 = "34aEfg"
;
System.out.println(c1.equals(c2)
)
;
// false
System.out.println(c1.equalsIgnoreCase(c2)
)
;
// true
// 6. 截取字符串内容（包前不包后）
String s3 = "Java是最好的编程语言之一"
;
String rs = s3.substring(0
, 8
)
;
System.out.println(rs)
;
// Java是最好的
// 7. 从当前索引位置一直获取到字符串的末尾
String rs2 = s3.substring(5
)
;
System.out.println(rs2)
;
// 最好的编程语言之一
// 8. 把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们
String info = "这个电影简直就是个垃圾，垃圾电影"
;
String rs3 = info.replace("垃圾"
, "**"
)
;
System.out.println(rs3)
;
// 这个电影简直就是个**，**电影
// 9. 判断字符串中是否包含某个关键字
String info2 = "Java是最好的编程语言之一，我爱Java，Java不爱我！"
;
System.out.println(info2.contains("Java"
)
)
;
// true
System.out.println(info2.contains("java"
)
)
;
// false
// 10. 判断字符串是否以某个字符串开头
String rs4 = "张三丰"
;
System.out.println(rs4.startsWith("张"
)
)
;
// true
System.out.println(rs4.startsWith("张三"
)
)
;
// true
// 11. 把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
String rs5 = "张无忌，周芷若，殷素素，赵敏"
;
String[] names = rs5.split("，"
)
;
for (
int i = 0
; i < names.length; i++
) {
System.out.println(names[i]
)
;
}
}
}

---

2.3 String 使用时的注意事项

第一点

• String 对象的内容不可改变，被称为不可变字符串对象

但是：

name 指向的字符串对象确实变了啊，那为什么还说 String 的对象都是不可变字符串对象？

看执行流程：

结论：每次试图改变字符串对象实际上是新产生了新的字符串对象，变量每次都是指向了新的字符串对象，之前字符串对象的内容确实是没有改变的，因此说 String 的对象是不可变的

• 其实就是地址不会发生变化

第二点

• 只要是以 “…” 方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只能存储一份
  • Java 为什么这么设计？
    • 节约内存

• 但通过 new 方式创建字符串对象，每 new 以此都会产生一个新的对象放在堆内存中


代码演示

package t_string
;
public
class StringDemo3 {
public
static
void main(String[] args) {
// 1. 只要是以双引号给出的字符串对象，存储在常量池中，而且内容相同时只会存储一份
String s1 = "abc"
;
String s2 = "abc"
;
System.out.println(s1 == s2)
;
// true
// 2. new String创建字符串对象，每次new出来的收拾一个新对象，放在堆内存中
char[] chars = {
'a'
, 'b'
, 'c'
}
;
String a1 =
new String(chars)
;
String a2 =
new String(chars)
;
System.out.println(a1 == a2)
;
// false
}
}

总结

1. String 有哪几点注意事项？

• String 是不可变字符串对象
• 只要是以 “…” 方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份
• 但通过 new 方式创建字符串对象，每 new 以此都会产生一个新的对象放在堆内存中

题目

---

2.4 String 的应用案例

2.4.1 案例一

需求

• 系统正确的登录名和密码是：itfeng/123456，请在控制台开发一个登录页面，接收用户输入的登录名和密码，判断用户是否登录成功，登录成功后展示：“欢迎进入系统！”，即可停止程序
• 注意：要求最多给用户三次登录机会

步骤：

1. 开发登录页面，提示用户通过键盘输入登录名和密码
2. 设计一个登录方法，对用户的登录名和密码进行正确性认证
3. 根据登录方法返回的认证结果，判断用户是否登陆成功
4. 使用循环控制登录界面最多显示3次

• 代码实现

package t_string
;
import java.util.Scanner
;
/**
* 目标：完成用户的登录案例
*/
public
class StringTest4 {
public
static
void main(String[] args) {
// 1. 开发登录页面，提示用户通过键盘输入登录名和密码
for (
int i = 0
; i <
3
; i++
) {
Scanner sc =
new Scanner(System.in)
;
System.out.println("请您输入登录名称："
)
;
String loginName = sc.next(
)
;
System.out.println("请您输入登录密码："
)
;
String passWord = sc.next(
)
;
// 5. 开始调用登录方法，判断是否登录成功
boolean rs = login(loginName, passWord)
;
if (rs) {
System.out.println("恭喜您，欢迎进入系统~~~"
)
;
break
;
}
else {
System.out.println("登录名或者密码错误，请您确认~~~"
)
;
}
}
}
/**
* 2. 开发一个登录方法，接收用户的登录名和密码，返回认证的结果
*/
public
static
boolean login(String loginName, String passWord) {
// 3. 准备一份系统正确的登录名和密码
String okLoginName = "itfeng"
;
String okPassWord = "123456"
;
// 4. 开始真是判断用户是否登录成功
// if (okLoginName.equals(loginName) && okPassWord.equals(passWord)) {
// // 登录成功的
// return true;
// } else {
// return false;
// }
return (okLoginName.equals(loginName) && okPassWord.equals(passWord)
)
;
}
}

• 总结

1. 字符串的比较使用 == 比较好吗？为什么？什么时候使用 == ？

• 不好，对于字符串对象的比较，== 比较的是地址，容易出业务 bug
• 基本数据类型的变量或者值应该使用 == 比较

2. 开发中比较字符串推荐使用什么方式比较？

• 使用 String 提供的 equals 方法，它只关心字符串内容一样就返回 true

2.4.2 案例二

需求

• 实现随机产生验证码，验证码的每位可能是数字、大写字母、小写字母

分析：

1. 设计一个方法，该方法接收一个整型参数，最终要返回对应位数的随机验证码
2. 方法内定义2个字符串变量：1个用来记住生成的验证码，1个用来记住要用到的全部字符
3. 定义 for 循环控制生成多少位随机字符，每次得到一个字符范围内的随机索引，根据索引提取该字符，把该字符交给 code 变量连接起来，循环结束后，在循环外返回code即可
4. 主程序中，调用该方法即可得到随机验证码了

• 代码实现

package t_string
;
import java.util.Random
;
public
class StringTest5 {
public
static
void main(String[] args) {
System.out.println(createCode(4
)
)
;
System.out.println(createCode(6
)
)
;
}
/**
* 1. 设计一个方法，返回指定位数的验证码
* */
public
static String createCode(
int n){
// 2. 定义2个变量，一个是记住最终产生的随机验证码，一个是记住可能用到的全部字符
String code = ""
;
String data = "abcdefghijklmnopqrstuvwxyz1234567890"
;
Random r =
new Random(
)
;
// 3. 开始定义一个循环产生每位随机字符
for (
int i = 0
; i < n; i++
) {
// 4. 随机一个字符范围内的索引
int index = r.nextInt(data.length(
)
)
;
code += data.charAt(index)
;
// code = code + 字符
}
// 6. 返回code即可
return code;
}
}

---

3. ArrayList

3.1 ArrayList 快速入门

什么是集合？

• 集合是一种容器，用来装数据的，类似于数组

有数组，为什么还要学习集合？

• 数组定义完成并启动后，长度就固定了，对于经常要增删元素的业务场景数组是不太合适的
• 集合大小可变，开发中用的更多

ArrayList：

1. 会提供创建容器对象的方式
2. 会提供相应的方法对容器进行操作（增删改查）

• 添加数据
• 删除某个数据
• 修改某个数据
• 获取某个数据

ArrayList

• 是用的最多、最常见的一种集合

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

常用方法名	说明
public boolean add(E e)	将指定的元素添加到此集合的末尾
public void add(int index, E element)	在此集合中的指定位置插入指定的元素
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)	修改指定索引处的元素，返回被修改的元素

代码演示

package u_arraylist
;
import java.util.ArrayList
;
/**
* 目标：要求掌握如何创建ArrayList集合的对象，并熟悉ArrayList提供的常用方法
*/
public
class ArrayListDemo1 {
public
static
void main(String[] args) {
// 1. 创建一个ArrayList的集合对象
ArrayList list =
new ArrayList(
)
;
// 从jdk 1.7开始才支持
// ArrayList<String> list = new ArrayList();list.add("feng");list.add(666);list.add(99.5);list.add("张三");list.add("feng");System.out.println(list);// [feng, 666, 99.5, 张三, feng]// 2. 在集合中的某个索引位置处添加一个数据list.add(1, "MySQL");System.out.println(list);// [feng, MySQL, 666, 99.5, 张三, feng]// 3. 根据索引获取集合中某个索引位置处的值System.out.println(list.get(1));// MySQL// 4. 获取集合的大小（返回集合中存储的元素个数）System.out.println(list.size());// 6// 5. 根据索引删除集合中的某个元素值，会返回被删除的元素值给我们System.out.println(list.remove(1));// MySQLSystem.out.println(list);// [feng, 666, 99.5, 张三, feng]// 6. 直接删除某个元素值，删除成功会返回true，反之System.out.println(list.remove("张三"));// trueSystem.out.println(list);// [feng, 666, 99.5, feng]// 默认删除的是第一次出现的数据System.out.println(list.remove("feng"));// trueSystem.out.println(list);// [666, 99.5, feng]// 7. 修改某个索引位置处的数据，修改后会返回原来的值给我们System.out.println(list.set(1, "itfeng"));// 99.5System.out.println(list);// [666, itfeng, feng]}}

总结

1. 集合是什么，有什么特点？

• 一种容器，用来存储数据的
• 集合的大小可变

2. ArrayList 是什么？怎么使用？

• 是集合中最常用的一种，ArrayList 是泛型类，可以约束存储的数据类型
• 创建对象，调用无参数构造器初始化对象：public ArrayList();
• 调用相应的增删改查数据的方法

3. ArrayList 提供了哪些常用方法？
   | 常用方法名 | 说明 |
   | ------------------------------------- | -------------------------------------- |
   | public boolean add(E e) | 将指定的元素添加到此集合的末尾 |
   | public void add(int index, E element) | 在此集合中的指定位置插入指定的元素 |
   | 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) | 修改指定索引处的元素，返回被修改的元素 |

---

3.2 ArrayList 应用案例

需求：

• 现在假设购物车中存储了如下这些商品：Java 入门，宁夏枸杞，黑枸杞，人字拖，特技枸杞，枸杞子。现在用户不想买枸杞，选择了批量删除，请完成该需求

分析：

1. 后台使用 ArrayList 集合表示购物车，存储这些商品名
2. 遍历集合中的每个数据，只要这个数据包含了 “枸杞” 则删除它
3. 输出集合看是否已经成功删除了全部枸杞数据了

代码实现

package u_arraylist
;
import java.util.ArrayList
;
/**
* 目标：掌握从集合容器中找数据并删除的技巧
*/
public
class ArrayListDemo2 {
public
static
void main(String[] args) {
ArrayList<
String> list =
new ArrayList(
)
;
list.add("Java入门"
)
;
list.add("宁夏枸杞"
)
;
list.add("黑枸杞"
)
;
list.add("人字拖"
)
;
list.add("特级枸杞"
)
;
list.add("枸杞子"
)
;
System.out.println(list)
;
// [Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
// 2. 开始完成需求：从集合中找出包含枸杞的数据并删除它
// for (int i = 0; i < list.size(); i++) {
// // 取出当前遍历到的数据
// String ele = list.get(i);
// // 判断这个数据中包含枸杞
// if (ele.contains("枸杞")){
// // 直接从集合中删除该数据
// list.remove(ele);
// }
// }
// System.out.println(list); // [Java入门, 黑枸杞, 人字拖, 枸杞子]
// 方式一：每次删除一个数据后，就让i往左退一步
// for (int i = 0; i < list.size(); i++) {
// // 取出当前遍历到的数据
// String ele = list.get(i);
// // 判断这个数据中包含枸杞
// if (ele.contains("枸杞")) {
// // 直接从集合中删除该数据
// list.remove(ele);
// i--;
// }
// }
// System.out.println(list); // [Java入门, 人字拖]
// 方式二：从集合的后面倒着遍历并删除
for (
int i = list.size(
) - 1
; i >= 0
; i--
) {
// 取出当前遍历到的数据
String ele = list.get(i)
;
// 判断这个数据中包含枸杞
if (ele.contains("枸杞"
)
) {
// 直接从集合中删除该数据
list.remove(ele)
;
}
}
System.out.println(list)
;
// [Java入门, 人字拖]
}
}

总结

1. 从集合中遍历元素，并筛选出元素删除它，应该如何操作才能不出 bug？

• 方式一：每次删除一个数据后，索引 - 1
• 方式二：从集合后面遍历然后删除，可以避免漏掉元素

---

ArrayList 综合案例

模仿外面系统中的商家系统

需求：

• 完成菜品的上架、以及菜品信息浏览功能

目标：

• 使用所学的 ArrayList 集合结合面向对象编程实现以上2个需求

代码实现

• Food.java

package u_arraylist
;
public
class Food {
private String name;
private
double price;
private String desc;
// 描述
public Food(
) {
}
public Food(String name,
double price, String desc) {
this.name = name;
this.price = price;
this.desc = desc;
}
public String getName(
) {
return name;
}
public
void setName(String name) {
this.name = name;
}
public
double getPrice(
) {
return price;
}
public
void setPrice(
double price) {
this.price = price;
}
public String getDesc(
) {
return desc;
}
public
void setDesc(String desc) {
this.desc = desc;
}
}

• FoodOperator.java

package u_arraylist
;
import java.util.ArrayList
;
import java.util.Scanner
;
/**
* 菜品操作类：负责上架和浏览功能的实现
*/
public
class FoodOperator {
// 1. 定义一个ArrayList集合对象，负责存储菜品对象的信息
private ArrayList<
Food> foodList =
new ArrayList<
>(
)
;
// foodList = []
// 2. 开发功能：上架菜品功能
public
void addFood(
) {
// 3. 创建一个菜品对象，封装上架的菜品信息
Food f =
new Food(
)
;
// 4. 录入菜品信息进去
Scanner sc =
new Scanner(System.in)
;
System.out.println("请您输入该菜品名称："
)
;
String name = sc.next(
)
;
f.setName(name)
;
System.out.println("请您输入该菜品价格："
)
;
double price = sc.nextDouble(
)
;
f.setPrice(price)
;
System.out.println("请您输入该菜品描述："
)
;
String desc = sc.next(
)
;
f.setDesc(desc)
;
// 5. 把菜品对象存入到集合中去
foodList.add(f)
;
System.out.println("上架成功！"
)
;
}
// 6. 展示菜品
public
void showAllFood(
) {
if (foodList.size(
) == 0
) {
System.out.println("什么菜品都没有，先去上架"
)
;
return
;
}
for (
int i = 0
; i < foodList.size(
)
; i++
) {
Food f = foodList.get(i)
;
System.out.println(f.getName(
)
)
;
System.out.println(f.getPrice(
)
)
;
System.out.println(f.getDesc(
)
)
;
System.out.println("---------------------"
)
;
}
}
// 负责展示操作界面
public
void start(
) {
while (true
) {
System.out.println("请选择功能"
)
;
System.out.println("1. 上架菜品"
)
;
System.out.println("2. 展示菜品"
)
;
System.out.println("3. 退出"
)
;
Scanner sc =
new Scanner(System.in)
;
System.out.println("请选择您的操作："
)
;
String command = sc.next(
)
;
switch (command) {
case "1":
addFood(
)
;
break
;
case "2":
showAllFood(
)
;
break
;
case "3":
System.out.println("下次再来哦~~~"
)
;
return
;
// 干掉方法
default:
System.out.println("您输入的命令不存在！"
)
;
}
}
}
}

• ArrayListTest3.java

package u_arraylist
;
import java.util.ArrayList
;
public
class ArrayListTest3 {
public
static
void main(String[] args) {
// 目标：完成拓展案例：商家菜品上架操作
// 1. 设计一个菜品类，负责创建菜品对象，封装菜品数据
// 2. 设计一个菜品操作类FoodOperator，负责完成对菜品的业务实现：上架，浏览信息
FoodOperator operator =
new FoodOperator(
)
;
operator.start(
)
;
}
}

---

总结

---