Java基础 - 7 - 常用API（一）

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

JDK8 API文档：Java Platform SE 8

注：

        软件开发要注意不要重复造轮子

一. 包

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

建包的语法格式（IDEA等工具中会自动生成）：package 包名;

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

1. 如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互相可以直接调用）

2. 如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包，才可以访问！（导包格式： import 包名.类名;）

3. 如果当前程序中，要调用Java提供的程序，也需要先导包才可以使用；但是Java.lang包下的程序是不需要导包的，可以直接使用。

4. 如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问。

二. String

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

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

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

方式1：Java程序中的所有字符串文字（如"abc"）都为此类的对象

        （直接双引号得到字符串对象，封装字符串数据）

String name = "张三";

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

        （new String创建字符串对象，并调用构造器初始化字符串）

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

        String rs = new String();
        System.out.println(rs);  //""

        String rs1 = new String("你好哇");
        System.out.println(rs1);  //"你好哇"

        char[] chars = {'a','b','c'};
        String rs2 = new String(chars);
        System.out.println(rs2);  //"abc"

        byte[] bytes = {97,98,99,100};
        String rs3 = new String(bytes);
        System.out.println(rs3);  //"abcd" 97-100在ASCII码中代表a-d

2.2 String的常用方法

        String s = "abcdef";
        //统计字符串长度
        System.out.println(s.length());

        //提取字符串中指定索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);

        //字符串的遍历
        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));
        }

        //把字符串转换成字符数组，再遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        //匹配两个字符串内容是否一样
        String s1 = new String("abcdef");
        System.out.println(s == s1); //false 比较两个字符串的地址是否相等
        System.out.println(s.equals(s1));  //true 比较两个字符串的内容是否相等

        //忽略大小写比较字符串内容
        String c1 = "123abc";
        String c2 = "123ABC";
        System.out.println(c1.equals(c2));  //false 大小写不匹配
        System.out.println(c1.equalsIgnoreCase(c2)); //false 忽略大小写

        //截取字符串内容
        System.out.println(s.substring(0, 4)); //（包前不包后）截取第0位到第3位，"abcd"
        System.out.println(s.substring(1)); //从当前位置一直截取到最后，从第一位到最后 “bcdef”

        //把字符串中某个内容替换成新的内容，并返回新的字符串对象给我们
        String str = "真的会谢，会谢";
        System.out.println(str.replace("会谢", "**"));  //"真的**，**"

        //判断字符串中是否包含某关键字
        System.out.println(str.contains("谢")); //true

        //判断字符串以某个字符串开头
        System.out.println(str.startsWith("真"));   //true
        System.out.println(str.startsWith("真的"));  //true
        System.out.println(str.startsWith("的真"));  //fasle

        //把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中
        String s3 = "12-13-14-15";
        String[] strings = s3.split("-");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

 2.3 String使用时的注意事项

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

2. 只要是以"…"方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份，但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。

Java为什么会这么设计（字符串常量池）？ 为了节约内存 

        String str1 = "asdfg";
        String str2 = "asdfg";
        String str3 = new String("asdfg");
        //字符串中用==比较，是比较两个字符串的地址是否相同
        //字符串中用equals比较，是比较两个字符串的内容是否相同
        System.out.println(str1 == str2);  //true 因为”……“写出的字符串对象，会存储到字符串常量池，相同内容的字符串只存储一份
        System.out.println(str1 == str3);  //false 通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中

2.3.1 案例分析

2.4 String的应用案例

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 3;
        while (count > 0) {
            System.out.println("请输入您的用户名：");
            String user = sc.next();
            System.out.println("请输入您的密码：");
            String password = sc.next();
            if(isTrue(user,password)){
                System.out.println("登录成功");
                break;
            }else{
                count--;
            }
        }
    }

    public static boolean isTrue(String user, String password){
        String user_true = "wosun";
        String pwd_true = "123456";
        if(!user.equals(user_true)){
            System.out.println("您输入的用户名错误，请重新输入");
            return false;
        }else if(!password.equals(pwd_true)){
            System.out.println("您输入的密码错误，请重新输入");
            return false;
        }else{
            return true;
        }
//        return (user.equals(user_true) && password.equals(pwd_true)) ? true : false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println("随机验证码是："+scyzm(n));
    }

    public static String scyzm(int n){
        String yzm = "";
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            yzm += data.charAt(index);
        }
        return yzm;
    }

 三. ArrayList

        集合是一种容器（容器有哪些方法？增删改查），用来装数据的，类似于数组，最大的特点是集合大小可变

        ArrayList是一种集合中的一种，还有Set、LIst、Map、HashMap、TreeSet等等

ArrayLIst<E> 

3.1 ArrayList的构造器

ArrayList()用的最多，创建一个空的集合对象

3.2 ArrayList常用的方法

        //创建一个ArrayList的集合对象
        ArrayList List = new ArrayList(); //泛型，尖括号里面没有指定类型
        //ArrayList<String> List1 = new ArrayList<String>(); //只能添加字符串类型的数据到集合中
        //从JDK1.7开始支持后面不写类型
        ArrayList<String> List1 = new ArrayList<>();

        //添加数据
        List.add("你好");
        List.add("123");
        List.add(66.6);
        System.out.println(List);  //[你好, 123, 66.6]

        //往指定位置添加数据
        List.add(1,"星期天");
        System.out.println(List);  //[你好, 星期天, 123, 66.6]

        //获取某个索引位置的元素值
        System.out.println(List.get(2));  //123

        //返回集合中的元素个数（大小）
        System.out.println(List.size());  //4

        //删除指定位置的元素，返回被删除的元素
        System.out.println(List.remove(3));  //删除了索引3的66.6，返回66.6
        System.out.println(List);   //[你好, 星期天, 123]

        //删除指定内容，返回是否删除成功
        System.out.println(List.remove("你"));  //删除指定内容你，因为没有，删除不成功返回false
        System.out.println(List.remove("你好"));  //删除指定内容你好，因为有，删除成功返回true(只删除第一次匹配成功的指定内容)
        System.out.println(List);   //[星期天, 123]

        //修改指定位置的内容
        List.set(0,"不是星期天");
        System.out.println(List);   //[不是星期天, 123]

3.3 ArrayLIst的案例

    public static void main(String[] args) {
        ArrayList<String> List = new ArrayList<>();
        //[枸杞, Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
        List.add("枸杞");
        List.add("Java入门");
        List.add("宁夏枸杞");
        List.add("黑枸杞");
        List.add("人字拖");
        List.add("特级枸杞");
        List.add("枸杞子");
          //该方法存在错误，不能删除干净所有含枸杞的
          //因为成功删除一个后，集合List长度减少，后面的元素前移一位，会导致存在元素没有被检测
//        for (int i = 0; i < List.size(); i++) {
//            String s = List.get(i);
//            if(s.contains("枸杞")){
//                List.remove(i);
//            }
//        }
//        System.out.println(List);  //[Java入门, 黑枸杞, 人字拖, 枸杞子]
        //解决方法：1.每次成功删除一位后，i后退一位，重新遍历该索引位置
        for (int i = 0; i < List.size(); i++) {
            String s = List.get(i);
            if(s.contains("枸杞")){
                List.remove(i);
                i--;
            }
        }
        System.out.println(List);  //[Java入门, 人字拖]
        //解决方法：2.从后往前遍历，这样就不会因为长度改变产生漏检
        for (int i = List.size()-1; i >= 0; i--) {
            String s = List.get(i);
            if(s.contains("枸杞")){
                List.remove(i);
            }
        }
        System.out.println(List);  //[Java入门, 人字拖]
    }

//demo
public class demo {
    public static void main(String[] args) {
        FoodOperator fo = new FoodOperator();
        fo.start();
    }
}

//Food
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
//菜品操作类
public class FoodOperator {
    //定义一个ArrayList集合对象，负责存储菜品对象信息
    //集合中存放的是每一个food对象的地址
    private ArrayList<Food> foodArrayList = new ArrayList<>();  //创建后这是一个空容器

    public FoodOperator() {
    }

    public FoodOperator(ArrayList<Food> foodArrayList) {
        this.foodArrayList = foodArrayList;
    }

    //菜品上架功能
    public void addFood(){
        //创建一个菜品对象，封装上架的菜品信息
        Food f = new Food();
        //录入菜品信息
        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);

        //把菜品对象存入到集合中
        foodArrayList.add(f);
        System.out.println("上架成功");
    }

    //菜品展示功能
    public void showAllFood(){
        if(foodArrayList.size() == 0){
            System.out.println("暂无菜品");
            return ;
        }
        for (int i = 0; i < foodArrayList.size(); i++) {
            Food f = foodArrayList.get(i);
            System.out.println(f.getName()+" "+f.getPrice()+" "+f.getDesc());
        }
    }

    //操作界面
    public void start(){
        while (true) {
            System.out.println("---欢迎来到美食街---");
            System.out.println("---1.展示所有菜品---");
            System.out.println("---2.上架新菜品---");
            System.out.println("---- -1.退出 ----");
            Scanner sc = new Scanner(System.in);
            String choose = sc.next();
            switch (choose){
                case "-1":
                    return ; //退出方法
                case "1":
                    showAllFood();
                    break;
                case "2":
                    addFood();
                    break;
                default:
                    System.out.println("无此操作");
                    break;
            }
        }
    }
}