常用 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 代表字符串
对字符串处理的步骤：
- 创建对象
- 封装字符串数据
- 调用 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
}
}
总结
- String 是什么，可以做什么？
- 代表字符串，可以用来创建对象封装字符串数据，并对其进行处理
- 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 为什么这么设计？
- 节约内存
- 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
}
}
总结
- String 有哪几点注意事项？
- String 是不可变字符串对象
- 只要是以 “…” 方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份
- 但通过 new 方式创建字符串对象，每 new 以此都会产生一个新的对象放在堆内存中
题目
2.4 String 的应用案例
2.4.1 案例一
需求
- 系统正确的登录名和密码是：itfeng/123456，请在控制台开发一个登录页面，接收用户输入的登录名和密码，判断用户是否登录成功，登录成功后展示：“欢迎进入系统！”，即可停止程序
- 注意：要求最多给用户三次登录机会
步骤：
- 开发登录页面，提示用户通过键盘输入登录名和密码
- 设计一个登录方法，对用户的登录名和密码进行正确性认证
- 根据登录方法返回的认证结果，判断用户是否登陆成功
- 使用循环控制登录界面最多显示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));
}
}
- 总结
- 字符串的比较使用
==比较好吗？为什么？什么时候使用==？
- 不好，对于字符串对象的比较，
==比较的是地址，容易出业务 bug - 基本数据类型的变量或者值应该使用
==比较
- 开发中比较字符串推荐使用什么方式比较？
- 使用 String 提供的
equals方法，它只关心字符串内容一样就返回 true
2.4.2 案例二
需求
- 实现随机产生验证码，验证码的每位可能是数字、大写字母、小写字母
分析：
- 设计一个方法，该方法接收一个整型参数，最终要返回对应位数的随机验证码
- 方法内定义2个字符串变量：1个用来记住生成的验证码，1个用来记住要用到的全部字符
- 定义 for 循环控制生成多少位随机字符，每次得到一个字符范围内的随机索引，根据索引提取该字符，把该字符交给 code 变量连接起来，循环结束后，在循环外返回code即可
- 主程序中，调用该方法即可得到随机验证码了
- 代码实现
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：
- 会提供创建容器对象的方式
- 会提供相应的方法对容器进行操作（增删改查）
- 添加数据
- 删除某个数据
- 修改某个数据
- 获取某个数据
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)); // MySQL
System.out.println(list); // [feng, 666, 99.5, 张三, feng]
// 6. 直接删除某个元素值，删除成功会返回true，反之
System.out.println(list.remove("张三")); // true
System.out.println(list); // [feng, 666, 99.5, feng]
// 默认删除的是第一次出现的数据
System.out.println(list.remove("feng")); // true
System.out.println(list); // [666, 99.5, feng]
// 7. 修改某个索引位置处的数据，修改后会返回原来的值给我们
System.out.println(list.set(1, "itfeng")); // 99.5
System.out.println(list); // [666, itfeng, feng]
}
}
总结
- 集合是什么，有什么特点？
- 一种容器，用来存储数据的
- 集合的大小可变
- ArrayList 是什么？怎么使用？
- 是集合中最常用的一种，ArrayList 是泛型类，可以约束存储的数据类型
- 创建对象，调用无参数构造器初始化对象：
public ArrayList(); - 调用相应的增删改查数据的方法
- 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 入门，宁夏枸杞，黑枸杞，人字拖，特技枸杞，枸杞子。现在用户不想买枸杞，选择了批量删除，请完成该需求
分析：
- 后台使用 ArrayList 集合表示购物车，存储这些商品名
- 遍历集合中的每个数据，只要这个数据包含了 “枸杞” 则删除它
- 输出集合看是否已经成功删除了全部枸杞数据了
代码实现
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入门, 人字拖]
}
}
总结
- 从集合中遍历元素，并筛选出元素删除它，应该如何操作才能不出 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();
}
}
总结
![BUUCTF[极客大挑战 2019]EasySQL 1题解](https://i-blog.csdnimg.cn/direct/f06d142a379242829520fed9e25d337c.png)
