2.常用API(应用程序接口)

常用API(应用程序接口)

Before:前置知识点——>包

• 是用来管理各种不同的Java程序的，类似于文件夹，建包有利于程序的管理和维护

注意事项：

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

一、String

1.String概述

java.lang.String代表字符串，封装字符串数据，处理字符串的方法：

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

String创建对象封装字符数据的方式

• 方式一：Java程序中所有字符串文字(例如 “abc”)都为此类的对象(直接赋值)

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

  说明	构造器
  创建一个空白字符串，不含有任何内容	public String()
  根据传入的字符串内容，来创建字符串对象	public String(String original)
  根据字符串数组的内容，来创建字符串对象	public String(chat[] chars)
  根据字节数组的内容，来创建字符串对象 (通过使用平台的默认字符集解码指定的字节数组来构造新的 String )	public String(byte[] byte)

2.String的常用方法

2.1 方法

方法名	说明
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 contains(CharSequence s)	判断某个字符串是否包含另一个字符串
public boolean startsWith(String prefix)	判断字符串是否以某个字符串内容开头，开头返回true，反之
public String[] split(String regex)	把字符串按照某个字符串内容分割，并返回字符串数组回来

2.2 字符串遍历：

1. 方式二:遍历字符串数组(length)

String s1 = "abcd";

char[] ch1 = s1.toCharArray();

for (int i = 0; i < ch1.length; i++) {

           System.out.println(ch1[i]);

       }

2. 方式一:charAt()——返回指定索引处的char值

String s1 = "abcd";

for (int i = 0; i < s1.length(); i++) {

           System.out.println(s1.charAt(i));

       }

3. 方式三:toCharArray()——将此字符串转换为字符数组

String str="2022 fight";

char[] s = str.toCharArray();

for(int i=0;i < str.length();i++) {

	System.out.println(s[i]);

}

4. 方式四:getBytes()——将String编码为一系列字节序列，然后存储到字节数组中

String str="2022 fight";

byte[] b = str.getBytes();

for(int i=0;i < str.length();i++) {

	System.out.println(b[i]);

}

5. 方式五:substring()——根据开始和结束索引进行截取，得到新的字符串（包前不包后）

String str="2022 fight";

for(int i=0;i < str.length();i++) {

System.out.println(str.substring(i,i+1)); 

}

2.3 案例

import java.lang.reflect.Array;
import java.util.Arrays;
public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = "abcd";
        //1.public int length() 获取字符串的长度返回（就是字符个数）
        System.out.println(s1.length());
        //2.public char charAt(int index) 获取某个索引位置处的字符返回
        for (int i = 0; i < s1.length(); i++) {//字符串的遍历一
            System.out.println(s1.charAt(i));
        }
        //3.public char[] toCharArray() 将当前字符串转换成字符数组返回
        char[] ch1 = s1.toCharArray();
        System.out.println(ch1);
        for (int i = 0; i < ch1.length; i++) {//字符串遍历二
            System.out.println(ch1[i]);
        }
        //4.public boolean equals(Object anObject) 判断当前字符串与另一个字符串的内容一样，一样返回true
        String s2 = "abc";
        System.out.println(s2.equals(s1));
        //5.public boolean equalsIgnoreCase(String anotherString) 判断当前字符串与另一个字符串的内容是否一样(忽略大小写)
        String s3 = "AbCd";
        System.out.println(s3.equalsIgnoreCase(s1));
        //6.public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包前不包后）
        System.out.println(s1.substring(1, 3));
        //7.public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串返回
        System.out.println(s1.substring(1));
        //8.public String replace(CharSequence target, CharSequence replacement) 使用新值，将字符串中的旧值替换，得到新的字符串
        System.out.println(s1.replace("c", "***"));//前后替换的位数可以不一致
        //9.public boolean contains(CharSequence s) 判断某个字符串是否包含另一个字符串
        System.out.println(s1.contains("bc"));
        //10.public boolean startsWith(String prefix) 判断字符串是否以某个字符串内容开头，开头返回true，反之
        System.out.println(s1.startsWith("a"));
        //11.public String[] split(String regex) 把字符串按照某个字符串内容分割，并返回字符串数组回来
        String s4 = "张三,李四,王五";
        String[] s5 = s4.split("李四");
        System.out.println(Arrays.toString(s5));
        for (int i = 0; i < s5.length; i++) {
            System.out.println(s5[i]);
        }
    }
}

3.String注意事项(面试题)

问题一：String直接赋值 和 new String()区别

jdk设计者认为使用字符串频率比较高，用 new String创建对象会在内存中造成浪费，在堆内存中做了优化

字符串常量池(内存空间)：

• 直接赋值在创建字符串对象时,创建0~1个对象：先去字符串常量池中查找，是否存在相同内容的字符串对象
  • 存在：直接复用
  • 不存在：创建新的字符串对象，并将其存入字符串常量池中
• new String创建字符串对象时，创建1~2个对象：先在堆内存中创建字符串对象，并引用，再去字符串常量池中查找，是否存在相容内容的字符串对象
  • 存在：不做任何操作
  • 不存在：再创建新的字符串对象，并将其存入字符串常量池中

public class StringDemo3 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1 == s2);//false,比较的是地址
        String s3 = "abc";
        String s4 = "abc";
        System.out.println(s3 == s4);//true,比较的是 字符串常量池中的内容
    }
}

问题二：拼接字符串时，+号两边字符串变量存在和不存在的区别

java底层存在编译优化机制：

字符串拼接时，两边不存在字符串变量(两个字面量相加)，编译时，编译优化机制会帮我们将两个字符串自动拼接成一个完整的字符串字面量。

两边存在字符串变量时，编译优化机制无法确定变量的值是什么，只会将该变量看做是一个符号，不会进行自动拼接，创建新的字符串对象，将拼接后的内容存入该对象。

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "aa" + "bb";
        String ss = "aabb";
        System.out.println(ss == s1);//true, + 号 左右字面量直接进行拼接，比较的是[字符串常量池中的内容]
        String s = "aa";
        String s2 = s + "bb";
        System.out.println(ss == s2);//false,编译优化机制,会[创建新对象]将拼接后的内容存入
    }
}

4.String的应用案例

需求：

• 系统正确登录名和密码是：root/123456，在控制台开发登录界面，接收用户输入的账号和密码

• 判断用户是否登录成功，成功则展示：“欢迎进入系统”[只有三次机会]

/* 步骤：
    1.获取用户输入的账号密码
  	2.判断登录是否成功
       2.1成功：展示信息，退出系统
       2.2失败，提示输入错误，并显示还有几次机会,返回重新输入账密
           2.2.1判断最后一次输入，错误则退出系统
*/
import java.util.Scanner;
public class StringZonghe {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//接收用户输入的账号密码
        for (int i = 1; i <= 3; i++) {
            System.out.println("请输入您的账号：");
            String username = sc.next();//账号
            System.out.println("请输入您的密码：");
            String password = sc.next();//密码
            //判断用户是否登录成功(账号 密码)
            if(username.equals("root") && password.equals("123456")){
                System.out.println("欢迎进入系统");
                break;//登录成功则直接退出系统
            }else{
                if(i == 3){//最后一次机会
                    System.out.println("您今日的机会已用完！再见！");
                    break;//最后一次登录不成功直接退出系统
                }
                System.out.println("您的账号或密码输入错误！您还有"+(3-i)+"次机会，请您重新输入!");
            }
        }
    }
}

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

import java.util.Random;
public class StringZonghe02 {
    public static void main(String[] args) {
        System.out.println(getCode(4));
    }
    public static String getCode(int n) {
        String code = "";
        String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random rd = new Random();
        for (int i = 0; i < n; i++) {
            int index = rd.nextInt(s.length());
            char c = s.charAt(index);
            code += c;
        }
        return code;
    }
}

二、ArrayList

1.概述

• 集合：是一种容器，用来装数据的，类似于数组，集合的大小可变

• ArrayList：

  • 是集合中的一种，ArrayList是泛型类，可以约束存储的数据类型

    ArrayList<String> arr1 = new ArrayList<>();// <泛型> 添加泛型限制数据类型
    

  • 创建对象，调用无参构造器初始化对象： public ArrayList();

  • 调用相应的增删改查数据的方法

2.方法

构造器	说明
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)	修改指定索引处的元素，返回被修改的元素

import java.util.ArrayList;
public class arrayDemo1 {
    public static void main(String[] args) {
        //1.public ArrayList<泛型>()    创建对象
        ArrayList<String> arr1 = new ArrayList<>();
        //2.public boolean add(E e)   将指定的元素添加到此集合的末尾
        arr1.add("aaa");
        arr1.add("bbb");
        arr1.add("ccc");
        arr1.add("ddd");
        System.out.println(arr1);
        //3.public void add(int index,E element)    在此集合中的指定位置插入指定的元素
        arr1.add(2,"eee");
        System.out.println(arr1);
        //4.public E get(int index) 返回指定索引处的元素
        System.out.println(arr1.get(2));
        //5.public int size() 返回集合中的元素的个数
        System.out.println(arr1.size());
        //-- 集合的遍历
        for (int i = 0; i < arr1.size(); i++) {
            System.out.println(arr1.get(i));
        }
        //6.public E remove(int index)  删除指定索引处的元素，返回被删除的元素
        arr1.remove(2);
        System.out.println(arr1);
        //7.public boolean remove(Object o) 删除指定的元素，返回删除是否成功
        arr1.remove("ccc");
        System.out.println(arr1);
        //8.public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
        arr1.set(1,"www");
        System.out.println(arr1);
    }
}

3.集合的遍历

• 方式一：get(index)+size()

for (int i = 0; i < arr1.size(); i++) {
    
            System.out.println(arr1.get(i));
    
        }

• 方式二:toArray()方法先将集合转为数组，然后遍历数组[能操作所有的单列集合]

Object[] objs = c.toArray();  // 将集合转换为数组

for(int i = 0; i < objs.length; i++){  // 遍历数组
    
    System.out.println(objs[i]);
    
}

• 方式三:迭代器遍历，Iterator()获取到迭代器，然后通过迭代器的方法获取

// 获取迭代器对象
Iterator it = c.iterator();  // 多态，实际上获取的是Iterator的实现类对象

While(it.hasNext()) {  // boolean hasNext()：判断是否有元素可以获取，没有就结束循环，用于循环结束的条件
    
    System.out.println(it.next());  // Objext next()：返回下一个元素
    
}

• 方式四:列表迭代器遍历，listIterator()先获取到列表迭代器，然后通过列表迭代器的方法【只适用于list集合】

ArrayList list = new ArrayList();// 创建集合对象
// 添加元素
list.add("a");
list.add("b");
list.add("c");

// 获取列表迭代器
ListIterator lit = list.listIterator();

// 循环获取到每一个元素
while(lit.hasNext()){  // boolean hasNext():判断是否有元素可以获取，没有就结束循环
    
    System.out.println(lit.Next());  // E next()：获取元素
}

• 方式五:增强for -->快捷键：fore 按 alt + /;

// 创建集合对象
Collection<String> c = new ArrayList<String>();  //父类引用指向子类对象
c.add("a");
c.add("b");
c.add("c");

// 增强for循环遍历集合
for(String s : c){   //增强for遍历集合底层使用的是迭代器，不能对集合中的元素进行增删操作
    
    System.out.println(s);
    
}

4.案例

需求：

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

import java.util.ArrayList;
public class arrayDemo2 {
    public static void main(String[] args) {
        //1.创建ArrayList集合存储一批商品
        ArrayList<String> list = new ArrayList<>();
        list.add("Java入门");
        list.add("宁夏枸杞");
        list.add("黑枸杞");
        list.add("人字拖");
        list.add("特级枸杞");
        list.add("枸杞子");
        System.out.println(list);
        //遍历集合删除特定元素
        //方式一
//        for (int i = 0; i < list.size(); i++) {
//            if(list.get(i).contains("枸杞")){
//                list.remove(i);
//                i--;//集合长度可变，需要让i保持原位
//            }
//        }
//        System.out.println(list);
        //方式二：倒着遍历集合
        for (int i = list.size()-1; i >= 0; i--) {
            if(list.get(i).contains("枸杞")){
                list.remove(i);
            }
        }
        System.out.println(list);
    }
}

需求：完成菜品的上架，以及菜品信息浏览功能

//Food实体类
package Arraylist;
//Food实体类
public class Food {
    private String name;//菜品名称
    private String url;//图片地址
    private double yuanMoney;//原价
    private double xianMoney;//现价
	
    //构造器(2)、get、set
}

//操作类： 1.菜品上架   2.展示所有菜品信息
import java.util.ArrayList;
import java.util.Scanner;
public class FoodOperator {
    //菜品上架
    public void addFood(ArrayList<Food> foods) {
        //获取商家输入的菜品的信息
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入菜品的名称：");
        String name = sc.next();
        System.out.print("请输入菜品图片的地址：");
        String url = sc.next();
        System.out.print("请输入菜品原价：");
        double yuanMoney = sc.nextDouble();
        System.out.print("请输入菜品现价：");
        double xianMoney = sc.nextDouble();
        //使用有参构造器创建一个Food对象
        Food food = new Food(name, url, yuanMoney, xianMoney);
        foods.add(food);//将food 添加到集合 foods中
        System.out.println("添加菜品成功！");
    }
    //菜品展示
    public void showFood(ArrayList<Food> foods) {
        //遍历集合输入所有菜品信息
        for (int i = 0; i < foods.size(); i++) {
            Food food = foods.get(i);//获得 i 索引处的 菜品(Food)
            System.out.println(food.getName() + " " + food.getUrl() + " " + food.getYuanMoney() + " " + food.getXianMoney());
        }
    }
}

//测试类
import java.util.ArrayList;
import java.util.Scanner;
public class FoodTest {
    public static void main(String[] args) {
        //定义集合来存储所有菜品信息
        ArrayList<Food> foods = new ArrayList<>();
        FoodOperator fo = new FoodOperator();
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("欢迎进入上架菜品系统");
            System.out.println("=================");
            System.out.println("请输入您需要做的操作：1.添加菜品  2.展示所有菜品  3.退出系统");
            int num = sc.nextInt();
            switch (num){
                case 1://添加菜品
                    fo.addFood(foods);
                    break;
                case 2://展示所以菜品信息
                    fo.showFood(foods);
                    break;
                case 3:
                    System.out.println("欢迎再次光临！再见！");
                    return;//直接退出系统
            }
        }
    }
}