Java常用API

JackFeng

发布于：May 7, 2020

Java

5k words

24 min

次浏览

Java常用API-I

常用API

1、String类功能

赋值

String S = “hello “

Objcet：是类层次结构的根类，所有类都直接活间接的继承该类

判断功能

boolean equals(Object obj) —-比较字符串的内容是否相同

boolean equalsIgnoreCase(String str) —- 比较字符串内容是否相同，忽略大小写

boolean startsWith(String str) —- 判断字符串对象是否以指定的str开头

boolean endsWitn(String str) —- 判断字符串对象是否以指定的str结尾

获取功能

int length() —- 获取字符串的长度

char charAt(int index) —- 获取指定索引处的字符

int indexOf(String str) —- 获取str 在字符串对象中第一次出现的索引

String substring(int start) —- 从start开始截取字符串

String substring(int start,int end) — 从s-e 截取，包括s 不包括e

统计录入大小写数字

package myTest;

import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/2.
 */

public class StringTest {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();

        //定义统计变量
        int BigCount = 0;
        int SmaCount = 0;
        int numberCount = 0;

        //遍历字符

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

            char ch = s.charAt(i);

            if (ch >= 'A' && ch<= 'Z') {
                BigCount++;
            }else if(ch >= 'a' && ch<= 'z'){
                SmaCount++;
            }else if (ch>='0' && ch<='9'){
                numberCount++;
            }else {
                System.out.println("该字符"+ch+"非法");
            }

        }

        System.out.println("大写字符"+BigCount);
        System.out.println("小写字符"+SmaCount);
        System.out.println("数字字符"+numberCount);



    }
}

转换功能

char[ ] toCharArray() —- 把字符串转换为字符数组

String toLlowerCase() —- 把字符串转换为小写字符串

String toUpperCase() —- 把字符串转换为大写字符串

字符串的遍历：

A：length() 加上charAt()

B：字符串转换字符数组，然后遍历数组

空格&分割

去除字符串两端空格：

String trim()

按照指定符号分割字符串

String[ ] split (String str)

实现字符串反转

package myTest;

import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/2.
 */


/*
* 键盘录入：abc 输出 cba
*
* 反转方法：
*   A： 把字符串倒着遍历，得到每一个字符拼接成字符串
*   B： 把字符串转换成字符数组，然后对字符数组进行反转，最后把字符数组转换为字符串
*
* */


public class StringTest1 {

    public static void main(String[] args) {


        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();

        // 调用方法A
//        String result = reverse(s);

        //调用方法B
        String result = reFan(s);

        //输出结果
        System.out.println("result:"+result);




    }

    // 方案A
    public  static  String  reverse (String s){

        String ss = "";

        // 倒着遍历
        for (int i = s.length()-1; i >=0 ; i--) {
            ss+=s.charAt(i);
        }

        return ss;
    }

    // 方案B

    public  static  String reFan( String s){

        // 把字符串转换为字符数组
        char[] chs = s.toCharArray();

        for (int start = 0,end = chs.length-1; start <=end ; start++,end--) {
            char temp = chs[start];
             chs[start] = chs[end];
            chs[end] = temp;

        }

        // 把字符数组转换为字符串
        String ss = new String(chs);

        return ss;


    }

}

2、StringBuilder类功能

StringBuilder : 可变的字符串，字符串缓冲区类

String 内容是固定

StringBuider 内容是可变的

构造方法：

StringBuilder()

成员方法：

public int capacity() :返回当前容量

public int length() :返回长度(字符数)

容量 —- 理论值

长度 —- 实际值

常用方法

添加功能：

public StringBuilder append(任意类型)

添加数据，并返回自身对象

链式编程

sb.append(“hello”).append(“world)

反转功能

public StringBuilder reverse()

StringBuilder ——>String

toString() —— 转成String

String ——> StringBuilder

StringBuilder (String str) —– 构造方法

键盘录入对称判断

package myTest;

import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/2.
 */


/*
* 判断一个字符串是否是对称字符串
*
* 例如 abc 不是  aba  abba aaa 是对称字符串
*
* */
public class StringBuilderDemo {
    public static void main(String[] args) {
        // 键盘录入

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();

        // 方法实现
        // 调用方法

        boolean b = isDuiChen(s);

        System.out.println("b:"+b);




    }

    public  static  boolean isDuiChen(String s){
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String result = sb.toString();

        return result.equals(s);


    }

}

3、对象数组

对象数组练习：

定义学生类

创建学生数组

创建学生对象

把学生对象作为元素赋值给学生数组

遍历学生数组

package com.datascience.myArray;

/**
 * Created by JackFeng on 2020/3/2.
 */



public class StudentDemo {

    public static void main(String[] args) {

        // 创建学生数组
        Student[] students = new Student[3];

        //创建学生对象
        Student s1 = new Student("荣耀王者", 50);
        Student s2 = new Student("星耀", 10);
        Student s3 = new Student("王者", 20);

        //学生对象  作为元素赋值给学生数组
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;

        //遍历学生数组

        for (int i = 0; i <students.length ; i++) {
            Student s = students[i];
            System.out.println(s); //这样输出的是地址值

            System.out.println(s.getName()+"====="+s.getAge());
        }



    }
}

学生类

package com.datascience.myArray;

/**
 * Created by JackFeng on 2020/3/2.
 */

 // alt + insert 可以快速生成 get/set 方法等



public class Student {

    private String name;
    private int age;

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

    }

    public Student() {
    }

    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;
    }
}

4、集合ArrayList

ArrayList：

大小可变数组的实现

: 特殊的数据类型：泛型

构造方法：

ArrayList()

添加元素：

pubilc boolean add(E e) — 添加元素

public void add (int index, E element) — 指定索引处添加元素

获取元素：

public E get(int index) —- 返回指定索引出的元素

集合长度：

public int size() 返回集合中元素的个数

删除元素：

public boolean remove(object o) 删除指定的元素，返回删除是否成功

pubilc E remove(int index) 删除指定索引出的元素，返回被删除的元素

修改元素：

public E set(int index, E element) 修改指定索引出的元素，返回被修改的元素

AarryList(集合)遍历：

size() + get 方法

package com.myArray;

import java.util.ArrayList;

/**
 * Created by JackFeng on 2020/3/
 */


public class ArrayListDemo {

    public static void main(String[] args) {

        // 创建集合对象
        ArrayList<Object> array = new ArrayList<>();

        // 这里如果是String 接受就是String Object 接受就是Object

        // add(E e) 添加元素
        array.add("hello");
        array.add("world");
        array.add("Data");

        System.out.println(array);


        // 在指定索引处添加一个元素
        // 第一个位置添加  Science

        array.add(1,"Science");

        System.out.println("====");
        System.out.println("array"+ array);

        //获取元素  get

        System.out.println(array.get(1));

        // 集合长度 size
        System.out.println("集合的长度："+array.size());

        // 删除元素 remove
        System.out.println("remove："+array.remove("hello"));
        System.out.println("remove："+array.remove("hello")); // 不存在则失败，这里就是失败了 false

        //删除指定元素 remove (int index)
        System.out.println("remove："+ array.remove(1));


        // 修改元素  set (int index , E element)
        System.out.println("set:"+ array.set(1,"hhha"));

        //
        System.out.println(array);

        // 添加元素
        array.add("aaa");
        array.add("abc");
        array.add("acd");

        //遍历集合
        System.out.println("================");
        for (int i = 0; i <array.size() ; i++) {

            System.out.println(array.get(i));

        }


        // 标准遍历

        for (int i = 0; i <array.size() ; i++) {

            // object
            Object s = array.get(i);
            System.out.println(s);
        }



    }
}

Test

package com.myArray;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/
 */

/*
*
* 创建一个集合：存储学生对象，学生对象的数据来自键盘录入，最后遍历集合
*
*
* 分析：
*   A： 定义学生类 String name , String age 
*   B： 创建集合对象
*   C： 键盘录入数据，创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
*   D： 把学生对象作为元素存储到集合中
*   E： 遍历集合
*
* */


public class ArrayListTest {
    public static void main(String[] args) {

        //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //d调用方法

        addStudent(array);
        addStudent(array);
        addStudent(array);

        //遍历集合

        for (int i = 0; i <array.size() ; i++) {

            Student s = array.get(i);

            System.out.println(s.getName() +"-------"+ s.getAge());
        }



    }


    /*
    * 提高复用性，键盘录入学生信息 封装成一个方法
    *
    * 两个明确：
    *       返回值类型： void
    *       参数列表：  ArrayList<Student>
    *
    *
    * */

    public static  void  addStudent (ArrayList<Student> array){
        //键盘录入

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入姓名：");
        String name = sc.nextLine();

        System.out.println("请输入年龄：");
        String age = sc.nextLine();

        //赋值给成员变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age);

        //学生对象存储到集合中

        array.add(s);
    }

}

简易学生管理系统

步骤：

A：定义学生类

B：主界面的代码编写

C：查看所有学生

D：添加学生

E：修改学生

F：删除学生

Student

package myStudentManager;

/**
 * Created by JackFeng on 2020/3/4.
 */


/*
*
* 学生类
* */
public class Student {

    private String id;

    // 姓名
    private String name;

    //
    private String age;

    private String address;

    public Student() {
    }

    public Student(String id, String name, String age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

Test

package myStudentManager;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/4.
 */


public class StudentMangerTest {

    public static void main(String[] args) {

        //创建集合对象，存储学生数据
        ArrayList<Student> array = new ArrayList<>();



        while (true) {

            // 主界面
            System.out.println("---------欢迎来到学生管理系统----------");
            System.out.println("1 查看所有学生");
            System.out.println("2 添加学生");
            System.out.println("3 删除学生");
            System.out.println("4 修改学生");
            System.out.println("5 退出");
            System.out.println("请输入你的选择：");
            // 键盘录入
            Scanner sc = new Scanner(System.in);


            String choice = sc.nextLine();
            switch (choice) {
                case "1":
                    // 查看所有学生
                    findAllStudent(array);
                    break;
                case "2":
                    // 添加学生
                    addStudent(array);
                    break;
                case "3":
                    //删除学生
                    delStudent(array);
                    break;
                case "4":
                    //修改学生
                    updataStudent(array);
                    break;
                case "5":
                    //退出
//                break; case 穿透
                default:
                    System.out.println("谢谢你的使用！");
                    System.exit(0); // jvm 退出
                    break;
            }
        }

    }

    //1 查看所有学生
    public  static  void findAllStudent(ArrayList<Student> array){
        // 判断集合中是否有数据，如果没有数据，给出提示，并让该方法不继续往下执行
        if (array.size()==0){
            System.out.println("不好意思，暂无学生信息，请重新选择你的操作");
            return;// void 没有返回值 可以直接return
        }

        // \t
        System.out.println("学号\t\t姓名\t年龄\t地址");
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getId()+"--"+s.getName()+"--"+s.getAge()+"---"+s.getAddress());


        }

    }

    // 添加学生

    public  static  void addStudent(ArrayList<Student> array){
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);


        // id 定义在外边 因为下边还要用
        String id;

        // 代码重复使用
        while (true){

            System.out.println("请输入 学生ID：");
//            String id = sc.nextLine();


            id = sc.nextLine();
            //判断学号是否存在
            //  定义标记默认为false
            boolean flag = false;

            for (int i = 0; i <array.size() ; i++) {

                Student s = array.get(i);

                if (s.getId().equals(id)){
                    flag = true;  // 说明学号被占用
                }

            }
            if (flag){
                System.out.println("你输入的学号已经被占用");
            }else {
                break;
            }
        }




        System.out.println("请输入 学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入 学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入 学生地址：");
        String address = sc.nextLine();

        //创建学生对象
        Student s = new Student();

        s.setId(id);
        s.setAge(age);
        s.setName(name);
        s.setAddress(address);


        // 把学生对象添进 集合
        array.add(s);
        System.out.println("学生信息添加成功====姓名为： "+s.getName());
    }



    public static  void delStudent(ArrayList<Student> array){

        //根据学号删除

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除学生的学号：");

        String id = sc.nextLine();

        // 定义一个索引
        int index = -1;

        //遍历集合
        for (int i = 0; i <array.size() ; i++) {
            //获取每个学生的对象
            Student s = array.get(i);

            if (s.getId().equals(id)){
//                array.remove(i); // 根据索引删除
                index = i;
                break;
            }
//            System.out.println("删除学生成功！");
        }
        if (index == -1){
            System.out.println("不好意思，您输入的学号不存在，请重新输入");
        }else {
            array.remove(index); // 根据索引删除
            System.out.println("删除学生成功");
        }



    }

    // 修改学生
    public static void updataStudent(ArrayList<Student> array){
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要修改学生的学号：");
        String id = sc.nextLine();

        // 定义一个索引
        int index = -1;


        for (int i = 0; i <array.size() ; i++) {
            //获取每一个学生对象
            Student s = array.get(i);

            if (s.getId().equals(id)){
                index = i;
                break;
            }
        }

        if (index == -1){
            System.out.println("不好意思，你要修改的学生信息不存在，请重新你的选择");
        }else {
            System.out.println("请输入学生新姓名：");
            String name = sc.nextLine();

            System.out.println("请输入学生新年龄：");
            String age = sc.nextLine();

            System.out.println("请输入学生新住址：");
            String address = sc.nextLine();

            Student s = new Student();

            s.setId(id);
            s.setName(name);
            s.setAddress(address);
            s.setAge(age);

            // 修改集合中的学生信息
            array.set(index, s);

            System.out.println("修改学生信息成功");

        }


    }


}

5、IO字符流

IO流用来处理设备之间的数据传输

文件复制，上传、下载文件

IO流分类

输出流

FileWriter

输入流

FileReader

常见的换行符：

Windows

\r\n

Linux

\n

Mac

\r

5.0、写数据

package myIo;

import java.io.FileWriter;
import java.io.IOException;

/**
 * Created by JackFeng on 2020/3/8.
 */


/*
* 需求： 往文件中写数据
*
*       写数据  -- 输出流 ---FileWriter
*
*
* */

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {

        //  创建输出流对象
        //  调用系统资源创建一个文件,创建输出流对象，把输出流对象指向文件
        //  不写路径 就会在 在相对路径下创建！
//        FileWriter fw = new FileWriter("D:\\Practice\\Java\\JavaSE\\a.txt");  // 默认为false
        FileWriter fw = new FileWriter("D:\\Practice\\Java\\JavaSE\\a.txt",true); // true 为追加写入

        // 写字符串数据
//        fw.write("IO你好");
        // 数据没有直接写入 到文件中， 其实是写到了内存缓冲区
//        fw.flush(); // 刷新缓冲区

        // 释放资源  通知系统释放和该文件相关的资源

        // 写数据的几种方法
        /*
        * 1、write(String str)  写一个字符串数据
        *
        * */
        // 1
//        fw.write("abcde");

        //2
//        fw.write("abcd",1,2);

        // 3
//        fw.write(97);

        // 4 写一个数组
//        char[] chs = {'a', 'b', 'c'};
//        fw.write(chs);

        // 5
//        fw.write(chs, 0, 1);



        // 数据换行 + 数据追加写入
        // \n 可以换行，windows 没有换行 ，\r\n

        for (int i = 0; i < 10 ; i++) {
            fw.write("Hi"+i);
            fw.write("\r\n");
        }




        fw.close(); // 先刷新缓冲区。再通知系统释放资源


    }

}

5.1、读数据

package myIo;

import java.io.FileReader;
import java.io.IOException;

/**
 * Created by JackFeng on 2020/3/8.
 */



public class FileReaderDemo {
    public static void main(String[] args) throws IOException {

        // 创建输入流 对象

        FileReader fr = new FileReader("D:\\Practice\\Java\\JavaSE\\a.txt");

/*        // 读数据方法
        // 1. int read()

        // 第一次读数据
        int ch = fr.read();
        System.out.println(ch);

        System.out.println((char)ch);

        // 第二次
        ch = fr.read();
        System.out.println(ch);

        System.out.println((char)ch);

        // 如果读取数据的返回值 是 -1的时候  说明结束了*/



// 标准代码
        // 读取 字符串
/*        int ch;

        while ((ch=fr.read())!= -1){
//            System.out.println(ch);
            System.out.print((char)ch);
        }*/


        //第二种读取数据方式  一次读取一个数组的数据
        // 标准代码  效率较高

//        char[] chs = new char[5];
        char[] chs = new char[1024]; // 一般写1024 及其整数倍

        int len;
        while ((len= fr.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
            // 以数组方式读入
        }


        fr.close(); // 释放资源
    }
}

5.2、文件复制

package myIo;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * Created by JackFeng on 2020/3/8.
 */



public class CopyFileDemo {

    public static void main(String[] args) throws IOException {


        // 创建输入刘对象
        FileReader fr = new FileReader("D:\\Practice\\Java\\JavaSE\\src\\myIo\\FileWriterDemo.java");

        // 创建输出流对象

        FileWriter fw = new FileWriter("Copy.java");


        //读写数据

/*        int ch;
        while ((ch=fr.read())!=-1){
            fw.write(ch);
        }*/
        char[] chs = new char[1024];
        int len;

        while ((len= fr.read(chs))!= -1){
            fw.write(chs,0,len);
        }



        fr.close();
        fw.close();

    }

}

5.3、字符缓冲流

BufferedWriter —- 高效写入

BufferedReader — 高效读取

不是直接传入文件，而是传入 FileWriter

特殊功能

BufferedWriter

Void newLine() —- 写一个换行符，这个换行符由系统决定的

BufferedReader

String readLine() —- 一次读取一行数据,但是不读取换行符

package myIo;

import java.io.*;

/**
 * Created by JackFeng on 2020/3/8.
 */
public class BufferedDemo {
    public static void main(String[] args) throws IOException {

        // 创建输出缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        bw.write("hello world");
//        bw.flush();


        for (int i = 0; i < 10 ; i++) {
            bw.write("Hi"+i);
//            bw.write("\r\n");
            bw.newLine(); // 等同于  bw.write("\r\n");
        }

        bw.close();


        // 创建输入缓冲流对象

        BufferedReader br = new BufferedReader( new FileReader("a.txt"));


        // 一次写一个字符
/*        int ch;

        while ((ch=br.read())!= -1){
            System.out.print((char) ch);
        }*/

        // 一次读写一个数组
/*
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs))!= -1)
//            System.out.print(chs,0,len); 这里会报错  需要 new String 构造
            System.out.println(new String(chs,0,len));


        br.close();*/


        String line;
        // br.readLine
        while((line= br.readLine())!=null){
            System.out.println(line);
        }

        br.close();


    }
}

集合数据写入文件

package myIo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/**
 * Created by JackFeng on 2020/3/8.
 */
public class ArrayListToFileTest {

    public static void main(String[] args) throws IOException {

        // 创建集合对象

        ArrayList<String> array = new ArrayList<>();

        // 给集合添加元素

        array.add("hello");
        array.add("world");
        array.add("今天是2020，三八妇女节");

        // 创建缓冲流输出对象

        BufferedWriter bw = new BufferedWriter( new FileWriter("array.txt"));

        //遍历集合写入到文件

        for (int i = 0; i <array.size() ; i++) {
            String s = array.get(i);
            bw.write(s);
            bw.newLine();  // 读取换行
            bw.flush();
        }

        bw.close();

    }

}

文件存入集合

package myIo;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/**
 * Created by JackFeng on 2020/3/8.
 */
public class FileToArrayList {
    public static void main(String[] args)  throws IOException {

        // 创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader("array.txt"));

        // 创建集合对象

        ArrayList<String> array = new ArrayList<String>();

        // 读取数据 每次读取一行数据， 把该行数据作为一个元素存储到集合中
        String line;

        while ((line = br.readLine())!= null){
            array.add(line);
        }
        br.close();

        //遍历集合
        for (int i = 0; i <array.size() ; i++) {
            String s = array.get(i);
            System.out.println(s);
        }



    }

}

学生管理添加升级版本

package myIo;

import myStudentManager.Student;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * Created by JackFeng on 2020/3/8.
 */
public class ArratListToFileTest {
    public static void main(String[] args) throws IOException {

        ArrayList<Student> array = new ArrayList<>();

        // 写方法添加学生对象

        addStudent(array);
        addStudent(array);
        addStudent(array);

        // 创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter("std.txt"));

        for (int i = 0; i <array.size() ; i++) {
            Student s = array.get(i);
            // 链式编程
            /// 姓名,年龄,。。。  采用 StringBuilder
            StringBuilder sb = new StringBuilder();

            sb.append(s.getId()).append(",").append(s.getName()).append(",").append(s.getAddress()).append(",").append(s.getAge());

            bw.write(sb.toString());  // 转化为string
            bw.newLine();  // 换行
            bw.flush(); // 刷新

        }

        bw.close();


    }

    // 添加学生

    public  static  void addStudent(ArrayList<Student> array){
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);


        // id 定义在外边 因为下边还要用
        String id;

        // 代码重复使用
        while (true){

            System.out.println("请输入 学生ID：");
//            String id = sc.nextLine();


            id = sc.nextLine();
            //判断学号是否存在
            //  定义标记默认为false
            boolean flag = false;

            for (int i = 0; i <array.size() ; i++) {

                Student s = array.get(i);

                if (s.getId().equals(id)){
                    flag = true;  // 说明学号被占用
                }

            }
            if (flag){
                System.out.println("你输入的学号已经被占用");
            }else {
                break;
            }
        }




        System.out.println("请输入 学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入 学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入 学生地址：");
        String address = sc.nextLine();

        //创建学生对象
        Student s = new Student();

        s.setId(id);
        s.setAge(age);
        s.setName(name);
        s.setAddress(address);


        // 把学生对象添进 集合
        array.add(s);
        System.out.println("学生信息添加成功====姓名为： "+s.getName());
    }



}