常用API-1

API(Application Programming Interface) ：应用程序编程接口

Java API ：指的就是 JDK 中提供的各种功能的 Java类。

Scanner

一个简单的文本扫描程序，可以获取基本类型数据和字符串数据

构造方法：

　　Scanner(InputStream source)：创建 Scanner 对象

　　System.in：对应的是InputStream类型，可以表示键盘输入

　　Scanner sc = new Scanner(System.in);

成员方法：

　　int nextInt()：获取一个int类型的数据

　　int i = sc.nextInt();

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int i = sc.nextInt();
        System.out.println("你输入的数据是：" + i);
    }
}

注（成员方法）：

next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键
nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符

Random

该类的实例用于生成随机数

构造方法：

　　Random()：创建一个新的随机数生成器

成员方法：

　　int nextInt(int bound)：获取一个int类型的随机数，参数bound表示获取到的随机数在[0,bound)之间

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(100) + 1; //获取1-100之间的随机数
        System.out.println(number);
    }
}

String

String类表示字符串。Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例
　　字符串不可变，它们的值在创建后不能被更改。Java 程序中所有的双引号字符串，都是 String 类的对象。

构造方法：
　　String()：初始化新创建的 String对象，使其表示空字符序列
　　String(String original)：初始化新创建的String对象，使其表示与参数相同的字符序列

成员方法：
　　int length()：返回此字符串的长度
　　boolean equals(Object anObject)：将此字符串与指定的对象进行比较
　　boolean equalsIgnoreCase(String anotherString)：将此 String与另一个 String比较，忽略了大小写
　　String trim()：返回一个字符串，其值为此字符串，删除了所有前导和尾随空格
　　char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
　　char[] toCharArray()：将当前字符串拆分为字符数组并返回
　　String substring(int beginIndex)：从传入的索引位置处，向后截取，一直截取到末尾，得到新的字符串并返回
　　String substring(int beginIndex, int endIndex)：从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新的字符串并返回（含头不含尾）
　　String replace(CharSequence target, CharSequence replacement)：将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
　　String[] split(String regex) ：根据传入的字符串作为规则进行切割 将切割后的内容存入字符串数组中，并将字符串数组返回

public class StringDemo {
    public static void main(String[] args) {
        String s1 = new String();
        System.out.println(s1);
        System.out.println(s1.length());    //0
        String s1 = "it";
        
        String s2 = new String("it");  //实际创建了两个对象，"abc"是第一个；new创建出来的是第二个。浪费内存，最好不要用
        String s3 = "It";
        //equals 将此字符串与指定的对象进行比较,不区分大小写
        System.out.println(s1.equals(s2));  //true
        System.out.println(s1.equals(s3));    //false
        //equalsIgnoreCase 将此 String与另一个 String比较，忽略了大小写
        System.out.println(s1.equalsIgnoreCase(s2));  //true
        System.out.println(s1.equalsIgnoreCase(s3));  //true

        String s4 = " it ";
        //trim 返回一个字符串，其值为此字符串，删除了所有前和尾的空格，不删除字符串中间的空格
        System.out.println(s4);
        System.out.println(s4.trim());
        System.out.println(s4);
    }
}

创建字符串对象的区别对比

字符串常量池：当使用双引号创建字符串对象的时候，系统会检查该字符是否在字符串常量池中存在（不存在：创建；存在：不会重新创建，而是直接复用）

字符串的比较
　　== 比较基本数据类型：比较的是具体的值
　　== 比较引用数据类型：比较的是对象地址值

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串常量池中维护

String常见面试题

面试题一：

public class Test{
    public static void main(String[] args){
        String s1 = "abc";
        String s2 = "ab";
        String s3 = s2 + "c";
        System.out.println(s1 == s3);  //false  
    }
}

当字符串之间使用+号串联（拼接）的时候，系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接。拼接后，再调用其toString方法转换为String类型。

 面试题二：

public class Test{
    public static void main(String[] args){
        String s1 = "abc";
        String s2 = "a" + "b" + "c" ;
        System.out.println(s1 == s2);  //true
    }
}

Java存在常量优化机制，在编译时，就会将"a" + "b" + "c" 拼接为"abc"。

StringBuilder（常用）

概述 : StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的。线程不安全。
作用：提高字符串的操作效率。
构造方法：
　　StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
　　StringBuilder(String str): 通过构造方法就可以实现把String转换为StringBuilder
成员方法：
　　StringBuilder append(任意类型)：添加数据，并返回对象本身
　　StringBuilder reverse()：返回相反的字符序列
　　int length()：返回长度（字符出现的个数）
　　String toString()：通过toString()就可以实现把StringBuilder转换为String

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length()); //0
        
        //链式编程
        sb.append("红色").append("蓝色").append("绿色");
        System.out.println("sb:" + sb); //红色蓝色绿色
    
        sb.reverse();
        System.out.println("反转后:" + sb); //色绿色蓝色红

        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println(sb2.length());  //5
        
        String s = sb2.toString();
        System.out.println(s); //hello    
    }
}

StringBuilder提高效率原理

 

使用StringBuilder，进行多次添加，堆内存中只有一个StringBuilder对象。

StringBuffer

概念：线程安全的可变字符串。
StringBuffer和StringBuilder非常类似，均代表可变的字符序列，而且方法也一样。

String，StringBuilder，StringBuffer 三者的区别

String：内容是不可变的。
StringBuilder：内容是可变的；线程不安全；效率高。
StringBuffer：内容是可变的；线程安全；效率低。

面试题：
StringBuffer与数组的区别：
二者都可以看作一个容器，装其他的数据。但StringBuffer的数据最终是一个字符串数据；而数组可以存放多种数据，但必须是同一种类型。

Integer

八种基本数据类型和其对应的包装类类型

Integer类在对象中包装基本类型int的值
构造方法：
　　Integer(int value)：根据 int 值创建 Integer 对象(过时)
　　Integer(String s)：根据 String 值创建 Integer 对象(过时)
成员方法：
　　static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
　　static Integer valueOf(String s)：返回一个保存指定值的 Integer 对象 String

public class IntegerDemo01 {
    public static void main(String[] args) {
        Integer i1 = Integer.valueOf(100);
        Integer i2 = Integer.valueOf("100");
        System.out.println(i1);
        System.out.println(i2);
    }
}

int和String的相互转换　

int 转换为 String
　　static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法
String 转换为 int
　　static int parseInt(String s)：将字符串解析为 int 类型。该方法是 Integer 类中的方法
Integer 转换为 int
　　int intValue()：返回此值 Integer 为 int

public class IntegerDemo02 {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1 加""
        String s1 = number + "";
        System.out.println(s1);
        //方式2 使用String类中的方法 valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //int intValue() 返回此值 Integer 为 int
        int x = i.intValue();
        System.out.println(x);
        //方式2 使用Integer类中的方法 parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

自动装箱和拆箱（jdk1.5特性）

装箱：把基本数据类型转换为对应的包装类类型
拆箱：把包装类类型转换为对应的基本数据类型

public class IntegerDemo03 {
    public static void main(String[] args) {
        //装箱：把基本数据类型转换为对应的包装类类型
        // Integer i = Integer.valueOf(100); //手动装箱
        Integer ii = 100; //自动装箱 内部执行： Integer.valueOf(100); 
        
        //拆箱：把包装类类型转换为对应的基本数据类型
        ii += 200;
        /*
        ii = ii + 200;
        ii = ii.intValue() + 200; //自动拆箱
        ii = 300; //Integer.valueOf(300);
        */
        System.out.println(ii);
    }
}

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为 null 。推荐：只要是对象，在使用前就必须进行不为 null 的判断。

Integer i = null;
if(i != null){
    i += 200;
    System.out.println(i);
}

Date和SimpleDateFormat

Date

北京时间需要在世界标准时间上加8小时。
计算机中的时间原点为：1970年1月1日 00:00:00 (c语言的生日)

Date类表示特定的时刻，精度为毫秒
构造方法：
　　Date()：创建一个Date对象，表示默认时间
　　Date(long date)：创建一个Date对象，表示指定时间，即1970年1月1日00:00:00

import java.util.Date;
public class DateDemo {
    public static void main(String[] args) {
        //Date()：把当前时间封装成一个Date对象(电脑的当前时间)
        Date d1 = new Date();
        System.out.println(d1);  //Tue Jun 19 20:41:20 CST 2099
        //Date(long date)：把从时间原点开始，过了指定毫秒的时间，封装成一个Date对象。需要考虑时差问题。1970年1月1日00:00:00
        Date d2 = new Date(1000 * 60 * 60);
        System.out.println(d2);  //Thu Jan 01 09:00:00 CST 1970  在中国，属于东八区，需加8小时
    }
}

成员方法：
　　public long getTime() 　　获取时间对象的毫秒值
　　public void setTime(long time) 　　设置时间，传递毫秒值

public static void main(String[] args) {
    //把当前时间封装成一个date对象
    Date date1 = new Date();
    //获取当前时间的毫秒值
    long time = date1.getTime();
    System.out.println(time);  //1696671727515
    date1.setTime(0L);
    System.out.println(date1);  //Thu Jan 01 08:00:00 CST 1970
}

SimpleDateFormat(Date和String的相互转换)

可以对Date对象，进行格式化和解析

常用的模式字母对应关系：yyyy年MM月dd日 HH:mm:ss

构造方法：
　　SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
　　SimpleDateFormat(String pattern)：构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式化(从 Date 到 String )：
　　String format(Date date)：将日期格式化成日期/时间字符串
解析(从 String 到 Date )：
　　Date parse(String source)：从给定字符串的开始解析文本以生成日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //格式化(从 Date 到 String )
        Date d = new Date();
        //SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
        // SimpleDateFormat sdf = new SimpleDateFormat();
        //SimpleDateFormat(String pattern)：构造一个SimpleDateFormat使用给定的模式和默认的日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);  //2022年10月26日 11:11:11

        //解析(从 String 到 Date )
        String ss = "2022-10-26 11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式与给定字符串格式一致
        Date dd = sdf2.parse(ss);
        System.out.println(dd);  //Wed Oct 26 11:11:11 CST 2022
    }
}

GUI

GUI：Graphical User Interface(图形用户接口)。用图形的方式，来显示计算机操作的界面

Java为GUI提供的API都存在java.awt和javax.Swing两个包中：

　　java.awt 包：awt是这三个单词首字母的缩写，翻译过来是抽象窗口工具包，只不过这个包的API，需要调用本地系统方法实现功能，和本地系统有关联，不利于代码移植，属重量级控件

　　javax.swing 包：它是在awt的基础上，建立的一套图形界面系统，提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件

组件：具有图形表示的对象，该图形表示可以显示在屏幕上并且可以与用户交互

常用组件

JFrame(初识窗体)

是一个顶层窗口

构造方法：

　　JFrame()：构造一个最初不可见的新窗体

成员方法：

　　void setVisible(boolean b)：显示或隐藏此窗体具体取决于参数b的值

　　void setSize(int width, int height)：调整此组件的大小，使其宽度为width，高度为height，单位是像素

　　void setTitle(String title)：设置窗体标题

　　void setLocationRelativeTo(Component c)：设置位置，值为null，则窗体位于屏幕中央

　　void setDefaultCloseOperation(int operation)：设置窗体关闭时默认操作　　整数3表示：窗口关闭时退出应用程序

　　void setAlwaysOnTop(boolean alwaysOnTop)：设置此窗口是否应始终位于其他窗口之上

import javax.swing.*;

public class JFrameDemo {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        //void setTitle(String title)：设置窗体标题
        jf.setTitle("百度一下，你就知道");
        //设置窗体大小
        jf.setSize(400, 300);
        //void setDefaultCloseOperation(int operation)：设置窗体关闭时默认操作(整数3表示：窗口关闭时退出应用程序)
        jf.setDefaultCloseOperation(3);
        //void setLocationRelativeTo(Component c)：设置位置，值为null，则窗体位于屏幕中央
        jf.setLocationRelativeTo(null);
        //void setAlwaysOnTop(boolean alwaysOnTop)：设置此窗口是否应始终位于其他窗口之上
        jf.setAlwaysOnTop(true);
        //设置窗体可见
        jf.setVisible(true);
    }
}

JButton(窗口中添加按钮)

按钮的实现

构造方法：

　　JButton(String text)：创建一个带文本的按钮

成员方法：

　　void setSize(int width, int height)：设置大小

　　void setLocation(int x, int y)：设置位置(x坐标，y坐标)

　　void setBounds(int x, int y, int width, int height)：设置位置和大小

和窗体相关操作：

　　取消窗体默认布局：窗体对象.setLayout(null);

　　把按钮添加到窗体：窗体对象.add(按钮对象);

import javax.swing.*;

public class JButtonDemo {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("窗口中添加按钮");
        jf.setSize(400, 300);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null); //取消窗体的默认布局

        JButton btn = new JButton("按钮");
        btn.setBounds(100,100,100,20);
        jf.add(btn);
        //设置窗体可见
        jf.setVisible(true);
    }
}

JLabel(显示文本和图像)

短文本字符串或图像的显示区域

构造方法：

　　JLabel(String text)：使用指定的文本创建 JLabel实例

　　JLabel(Icon image)：使用指定的图像创建 JLabel实例

　　　　ImageIcon(String filename)：从指定的文件创建ImageIcon

　　　　文件路径：绝对路径和相对路径

　　　　　　绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：D:\IdeaProjects\javase_code\it-api-gui\images\mn.png

　　　　　　相对路径：必须使用取自其他路径名的信息进行解释。例如：it-api-gui\images\mn.png

成员方法：

　　void setBounds(int x, int y, int width, int height)：设置位置和大小

import javax.swing.*;

public class JLabelDemo {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("显示文本和图像");
        jf.setSize(400, 300);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null);

        JLabel jLabel = new JLabel("好好学习");
        jLabel.setBounds(0,0,100,20);

        JLabel jLabel2 = new JLabel(new ImageIcon("it-api-gui\\images\\mn.png"));
        jLabel2.setBounds(50,50,100,143);
        jf.add(jLabel);
        jf.add(jLabel2);
        //设置窗体可见
        jf.setVisible(true);
    }
}

 JTextField（编辑单行文本）

 实现输入框

构造方法：

　　JTextField()：构造一个新的 TextField

成员方法：

　　void setBounds(int x, int y, int width, int height)：设置位置和大小

JPasswordField（编辑单行文本，但不显示原始字符）

实现密码输入框，密码隐藏

构造方法：

　　JPasswordField()：构造一个新的 JPasswordField

成员方法：

　　void setBounds(int x, int y, int width, int height)：设置位置和大小

import javax.swing.*;
/*
用户登录
*/
public class UserLogin {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("用户登录");
        jf.setSize(400, 300);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null);
        //显示用户名文本
        JLabel usernameLable = new JLabel("用户名");
        usernameLable.setBounds(50,50,50,20);
        jf.add(usernameLable);
        //用户名输入框
        JTextField usernameField = new JTextField();
        usernameField.setBounds(150,50,180,20);
        jf.add(usernameField);
        //显示密码文本
        JLabel passwordLable = new JLabel("密码");
        passwordLable.setBounds(50,100,50,20);
        jf.add(passwordLable);
        //密码输入框
        // JTextField passwordField = new JTextField();
        // passwordField.setBounds(150,100,180,20);
        // jf.add(passwordField);
        JPasswordField passwordField = new JPasswordField();
        passwordField.setBounds(150,100,180,20);
        jf.add(passwordField);
        //登录按钮
        JButton loginButton = new JButton("登录");
        loginButton.setBounds(50,200,280,20);
        jf.add(loginButton);
        jf.setVisible(true);
    }
}

JTextArea（纯文本的多行区域）

显示纯文本的多行区域

构造方法：

　　JTextArea()：构造一个新的TextArea

成员方法：

　　void setBounds(int x, int y, int width, int height)：设置位置和大小

　　void append(String str) 将给定文本附加到文档的末尾

事件监听机制

事件监听机制的组成：
　　事件源：事件发生的地方。可以是按钮，窗体，图片等
　　事件：发生了什么事情。例如：鼠标点击事件，键盘按下事件等
　　事件绑定：把事件绑定到事件源上，当发生了某个事件，则触发对应的处理逻辑
　　　　事件源对象. addXXXListener(事件);

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class UserLogin {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("用户登录");
        jf.setSize(400, 300);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null);
        //显示用户名文本
        JLabel usernameLable = new JLabel("用户名");
        usernameLable.setBounds(50, 50, 50, 20);
        jf.add(usernameLable);
        //用户名输入框
        JTextField usernameField = new JTextField();
        usernameField.setBounds(150, 50, 180, 20);
        jf.add(usernameField);
        //显示密码文本
        JLabel passwordLable = new JLabel("密码");
        passwordLable.setBounds(50, 100, 50, 20);
        jf.add(passwordLable);
        //密码输入框
        JPasswordField passwordField = new JPasswordField();
        passwordField.setBounds(150, 100, 180, 20);
        jf.add(passwordField);
        //登录按钮
        JButton loginButton = new JButton("登录");
        loginButton.setBounds(50, 200, 280, 20);
        jf.add(loginButton);
        //已知的用户名和密码
        String name = "username";
        String pwd = "123456";
        
        //事件监听机制
        loginButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //获取用户输入的用户名和密码
                String username = usernameField.getText();
                String password = passwordField.getText();
                //先判断输入的用户名和密码是否符合要求
                //用户名和密码的长度都是6-12位
                if(username.length()<6 || username.length()>12) {
                    // System.out.println("用户名的长度是6-12位，请重新输入");
                    //静态的成员方法和成员变量是可以通过类名访问的
                    JOptionPane.showMessageDialog(jf,"用户名的长度是6-12位，请重新输入");  //JOptionPane弹出一个标准对话框，提示用户输入值
                    usernameField.setText("");
                    return;
                }
                //再判断用户登录是否成功
                if(username.equals(name) && password.equals(pwd)) {
                    // System.out.println("登录成功");
                    JOptionPane.showMessageDialog(jf,"登录成功");
                    usernameField.setText("");
                    passwordField.setText("");
                } else {
                    // System.out.println("用户名或者密码有误");
                    JOptionPane.showMessageDialog(jf,"用户名或者密码有误");
                }
            }
        });
        jf.setVisible(true);
    }
}