JAVA----API

一、API

1.Scanner的基本使用

API解释：
	全称叫应用程序编程接口(Application Programming Interface), 本意指的是JDK提供的各种类和接口

例如： Scanner获取字符串
	public String nextLine();	获取用户录入的字符串，能获取整行数据。
	public String nextInt();	获取整数类型的数据
	public String next();		获取用户录入的字符串，但是只能获取空格以前的内容

代码演示

//会自动导包
import java.util.Scanner;

/*
    演示Scanner如何获取字符串
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你爱的人的名字: ");

        // 接收键盘输入的结果
        String str = scanner.nextLine();

        // 只能接收空格之前的内容
        //String str = sc.next();
        //打印
        System.out.println(str);
    }
}

2.Scanner的小技巧.

Scanner的细节问题：
	问题描述：
		先用 nextInt() 接收整数，再用 nextLine() 接收字符串，发现字符串无法接收。
	产生原因：
		1. nextInt() 、 nextLine() 两个方法结束标记都是 \r\n
		2. nextInt() 方法只接收用户录入的整数，不接收 \r\n
		3. 它遗留下来的 \r\n 只能被 nextLine() 识别， 导致 nextLine() 方法直接结束。

	解决方案：
		1. 都用字符串接收，然后把字符串形式的整数转化成对应的整数。  ----》【掌握： 这是实际开发做法】
			int num = Integer.parseInt("123");
				
		2. 重新 new 一个Scanner对象。
		3. 重新调用一次 newLine() 方法。
		4. 通过 next() 方法实现。
		5. 尽量先 nextLine(), 然后 nextInt() 也能解决。

基本操作：

package demo01_scanner;

import java.util.Scanner;

public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        // ==============[问题代码]==============
    /*
        //创建 Scanner对象
        Scanner sc = new Scanner(System.in);

        // 接收键盘输入的结果
        System.out.println("请输入一个整数: ");
        // 接收输入的整数
        int num = sc.nextInt();
        // 打印
        System.out.println("num " + num);   //520

        //再调用nextLine() 接收字符串
        System.out.println("请输入字符串 ");
        String str = sc.nextLine();
        System.out.println(str);
        //问题描述  ： 数字输完之后   无法输入字符串  直接自动退出运行 原因 \r\n

     */

        System.out.println("----------------[华丽分割线]----------------");

        //=================[解决方案]=================
        // 1 都用字符串接收 然后把字符串形式的整数 转化成对应的整数 -----》【掌握，实际开发的做法】
        // int num = Integer.parseInt("123");

        Scanner sc = new Scanner(System.in);

        // 接收键盘输入的结果
        System.out.println("请输入一个整数: ");

        // 接收整数
        String str_num = sc.nextLine();
        //将字符串"123" ===》123整型
        // Integer.parseInt("123")  ==> 123   强转
        int num = Integer.parseInt(str_num);

        // 打印内容
        System.out.println("num " + num);

        //再用nextLine() 接收字符串
        System.out.println("请输入字符串: ");

        String str = sc.nextLine();
        System.out.println(str);

    }
}

3.Object类的toString和 equals方法

Object类 简介： '它是所有类的父类， 所有的类都直接或者间接的继承自Object类'
	构造方法：
		public Object();

	成员方法：
		public String toString()
			
			返回该对象的字符串表示形式。
			作者：格式为： 全类名，@标记符 ，该对象的哈希码的无符号十六进制形式组成。 ===》对象的地址
	实际开发：无意义，实际开发中，子类都会重写该方法，改为打印：该对象的各个属性值。

	如何重写呢？ 快捷键生成。

	public boolean equals(Object obj)；
		作者：比较两个对象是否相等(即：是否是同一个对象)，默认比较的是地址值是否相等，无意义
		实际开发：子类都会重写该方法，用来比较各个对象的属性值是否相等。
		举例：
			stu1.name == stu2.name
            stu1.age == stu2.age
            stu1和stu2地址肯定不一样 new了两次
            如果各个属性都相等，可以认为是同一个对象

细节（'记忆'）:
	1. 实际开发中，我们认为，如果同一个类的多个对象，只要属性值相同，他们就是同一个对象，即：
		Student s1 = new Student("马佳玉" ，23)；
		Student s2 = new Student("马佳玉" ，23);
		上述两个对象实际开发中，我们也会认为他们是同一个对象。
	2. 输出语句直接打印对象，默认调用了该对象的toString()方法。

代码

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //1.演示toString方法
        Student student = new Student();

        //还未重写：toString方法
        //作者：格式为: 全类名, @标记符, 该对象的哈希码的无符号十六进制形式组成. ==> 对象的地址
        //重写了toString方法：实际开发：无意义, 实际开发中, 子类都会重写该方法, 改为打印: 该对象的各个属性值.
        System.out.println(student);
        System.out.println(student.toString());

        //演示equals方法
        Student stu1 = new Student("马佳玉" ,23);
        Student stu2 = new Student("马佳玉" ,23);
        //还未重写equals方法
        //作者：比较两个对象是否相等(即: 是否是同一个对象), 默认比较的是地址值是否相等, 无意义, false

        //已经重写了equals
        //实际开发：子类都会重写该方法，用来比较各个对象的属性值是否相等
        boolean flag = stu1.equals(stu2);
        System.out.println(flag); //true
    }
}

4.字符串比较详解

String类简介：
	他是java.lang包下的类，可以直接使用，无需导包，他表示所有的字符串，每一个字符串都是它的对象。
		String s1 = new String("abc");
		String s1 = "abc";  //免new 语法糖

				成员方法：
		public boolean equals(Object obj);
			这个是String重写了Object#equals() 方法，比较字符串的内容是否相同，区分大小写。
			注意：不再是比较地址是否一致，非要比较地址是否一致： ===比较运算符
		public boolean equalsIgnoreCase(String s)
			这个是String独有的方法，比较字符串的内容是否相同，不区分大小写。

	需求：
		定义字符数组chs，初始化值为：'a' ,'b' ,'c' ，这三个字符。
		将其分别封装成s1 ，s2这两个字符串对象
		直接通过 "" 的方式创建两个字符串对象s3 和 s4 
		通过 == 分别判断s1 和s2 ， s3 和 s4 是否相同。
		通过equals() 分别判断 s1 和s2 ， s3 和 s4 是否相同。
		通过equalsIgnoreCase() 判断字符串abc 和 ABC 是否相同

	细节：（记忆）
		1. == 的作用：
			比较基本类型：比的是 数值。     10 == 20  比较数值
			比较引用类型：比的是 地址值     s1 == s2  比较地址值
		2. String# equals() 区分大小写  equalsIgnoreCase()忽略大小写

代码

package demo02_object;

/**
 * 需求：
 *  定义字符数组chs 初始化值为：‘a’，'b', 'c', 这三个字符 .
 *  将其分别封装成s1，s2这两个字符串对象
 *  直接通过 “” 的方式创建两个字符串对象s3和s4
 *  通过 == 分别判断是s1 和 s2  s1和s3 s3和s4是否相同
 *  通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
 *  通过equalsIgnoreCase()判断字符串abc和ABC是否相同.
 */
public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        //定义字符数组chs  初始化值为 ：'a', 'b', 'c', 这三个字符 .
        char[] chs = {
    
    'a' ,'b' ,'c'};
        // 快捷键： alt + shift + 光标选中多行
        // 将其分别封装成s1, s2这两个字符串对象.
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接通过“”的方式创建两个字符串对象s3和s4
        String s3 = "abc";
        String s4 = "abc";

        // 通过==分别判断s1和s2, s1和s3, s3和s4是否相同.
        // TODO:注意：不再是比较地址是否一致，非要比较地址是否一致：==比较运算符
        System.out.println(s1 == s2); // false  因为new了两次，不是同一块空间
        System.out.println(s1 == s3); // false  两个不同的对象，地址不一致
        System.out.println(s3 == s4); // true   在内存只会存在一块空间
        System.out.println("----------------[华丽分割线]----------------");
        // 通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
        // TODO:equals()判断内容是否一致
        System.out.println(s1.equals(s2)); // true 比较的是内容，内容一致
        System.out.println(s1.equals(s3)); // true 比较的是内容，内容一致
        System.out.println(s3.equals(s4)); // true 比较的是内容，内容一致

        System.out.println("----------------[华丽分割线]----------------");
        // 通过equalsIgnoreCase()判断字符串abc和ABC是否相同.  忽略大小写
        System.out.println("abc".equals("ABC")); // false equals区分大小写
        System.out.println("abc".equalsIgnoreCase("ABC")); // true 不区分大小写\
    }
}

在这里插入图片描述

5. 模拟登陆

思路

1. 定义变量，记录账号密码
2. 创建Scanner对象
3. 因为只有三次机会 使用for循环
4. 提示用户录入账号和密码 并接收
5. 判断录入的账号密码是否正确 正确就等于成功 退出程序
6. 如果不正确 判断是否还有剩余的登录次数 有就继续  没有就锁定账号

代码

package demo02_object;

import java.util.Scanner;

/*
    案例: 模拟登陆.

    需求:
       模拟用户登录, 只给3次机会, 登录成功则提示"欢迎您, ***".
       登录失败则判断是否还有登录机会, 有则提示剩余登录次数, 没有则提示"您的账号已被锁定".
       假设初始化账号和密码分别为: "传智播客", "黑马程序员".

     // 1.定义变量，记录账号和密码  "传智播客", "黑马程序员".
     // 2.创建Scanner对象
     // 3.因为只有三次机会，使用for循环
     // 4.提示用户输入账号密码，并接收
     // 5.判断录入的账号和密码是否正常，正确，登录成功则提示"欢迎您, ***".
     // 6.如果不正确，判断剩余登录次数，有就提示剩余登录次数，继续， 没有就提示"您的账号已被锁定".

 */
public class Demo03_Login {
    
    
    public static void main(String[] args) {
    
    
        // 1.定义变量，记录账号和密码  "传智播客", "黑马程序员".
        String username = "马佳玉";
        String password = "你好";

        // 2.创建scanner对象
        Scanner sc = new Scanner(System.in);

        // 3.因为只有3次机会 所有使用for循环
        // 快捷键 fori
        for (int i = 0; i < 3; i++) {
    
    
            System.out.println("请输入您的密码: ");
            String usern = sc.nextLine();
            System.out.println("请输入您的密码: ");
            String pass = sc.nextLine();

            // 5.判断录入的账号和密码是否正常，正确，登录成功则提示"欢迎您, ***".
            // 判断值相等：equals方法
            if (usern.equals(username) && pass.equals(password)) {
    
    
                System.out.println("欢迎您登录: " + usern);

                //跳出循环
                break;
            }else {
    
    
                // 6.如果不正确，判断剩余登录次数，有就提示剩余登录次数，继续， 没有就提示"您的账号已被锁定".
                // 剩余次数？？？ 公式： 2 - i = 次数
                /*if((2 - i) > 0){
                    System.out.println("录入错误 您还有 " + (2-i)  + " 次机会");
                }else{
                    System.out.println("错误次数已达上限，账号锁定，请联系管理员");
                }*/

                // 优化：三目运算符
                System.out.println(2 - i > 0 ? "录入错误 您还有" + (2 - i) + "次机会" : "错误次数 已达上限，账号锁定，请联系管理员");
            }
        }
    }
}

6.遍历字符串

思路：

1. 提示用户录入字符串 并接收
2. 遍历字符串

代码

package demo02_object;

import java.util.Arrays;
import java.util.Scanner;

/*
    案例: 遍历字符串.

    需求:
        键盘录入一个字符串, 使用程序实现在控制台遍历打印该字符串.

    涉及到的String类中的成员方法:
        public char charAt(int index);      根据索引, 获取对应的字符.
        public int length();                获取字符串的长度.
        public char[] toCharArray();        将字符串转成其对应的字符数组形式.
 */
public class Demo03_Iter {
    
    
    public static void main(String[] args) {
    
    
        // 1.提示用户输入字符串 并接收
        // 快速导包快捷键 alt + 回车
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        //"abcde"
        String s = sc.nextLine();
        // 2.遍历字符串
        // 方案1：for循环遍历
        for (int i = 0; i < s.length(); i++) {
    
    
            // i 就是下标
            char c = s.charAt(i);
            System.out.println(c);
        }
        System.out.println("----------------[华丽分割线]----------------");

        //方案2 toCharArray() 将字符串转换字符数组
        // "abcde" ==>['a' ,'b' ,'c' ,'d' ,'e']
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
    
    
            char ch = chars[i];
            System.out.println(ch);
        }
        System.out.println("----------------[华丽分割线]----------------");

        // 实际开发
        //s.toCharArray() 转换成字符串数组
        // Arrays.toString() 打印数组每个元素
        System.out.println(Arrays.toString(s.toCharArray()));
    }
}

7. 统计每类字符的次数

思路

定义统计变量 用来记录结果
键盘录入一个字符串 并接收
遍历字符串 获取每一个字符
判断该字符属于那种类别 对应类别得到计数器就 ++

代码

package demo04_exercise;

import java.util.Scanner;

/*
    案例:  统计没类字符的次数 并打印结果
    需求：
        键盘录入一个字符串 统计该字符串中大写字符串 小写字母字符 数字字符出现的次数
        注意: 不考虑其他字符 例如@ ! \ /等
 */
public class Demo03 {
    
    
    public static void main(String[] args) {
    
    
        // 定义统计变量 用来记录结果
        int smallCount = 0, bigCount = 0, numberCount = 0;
        // 键盘录入一个字符串 并接收  abc12ABCD!@#$
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        String s = sc.nextLine();

        //3.遍历字符串 获取每一个字符
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
    
    
            //ch 就是字符串中的每一个字符
            char ch = chs[i];  //"a" ,'B'
            // 判断该字符属于那个类别  属于谁 对应的计数器就++
            if (ch >= 'a' && ch <= 'z')
                smallCount ++;
            else if (ch >= 'A' && ch <= 'Z')
                bigCount++;
            else if (ch >= 'O' && ch <= '9')
                numberCount++;
        }
        // 打印结果
        System.out.println("小写字母字符: " + smallCount);
        System.out.println("大写字母字符: " + bigCount);
        System.out.println("数字字符: " + numberCount);
    }
}

8.StringBuilder基本使用

思路

StringBuilder 简介：
	它表示字符串缓冲区类，内容是可变的

构造方法：
	public StringBulider();
	public StringBulider(String s);
	可以把这个构造方法理解为就是用来实现： 把字符串转成 对应的StringBuilder 对象的。
	String 字符串  ==》 StringBulider 字符串缓冲区类

成员方法：
	public String toString(); 	重写object#toString(),打印对象内容
	public String reverse(String); 反转字符串 返回自身
	public boolean append(Object obj); 添加元素 返回自身

代码

package demo08_StringBuilder;
/*
    //StringBuilder简介:
           它表示字符串缓冲区类, 内容是可变的.

    //构造方法:
        public StringBuilder();
        public StringBuilder(String s);
        可以把这个构造方法理解为就是用来实现:把 字符串 转成 对应的StringBuilder对象 的.
        String 字符串类 ==>  StringBuilder 符串缓冲区类

    //成员方法:
          public String toString();           重写Object#toString(), 打印对象内容.
          public String reverse(String);      反转字符串, 返回自身.
          public boolean append(Object obj);  添加元素, 返回自身.
 */

/**
 * 演示StringBuilder入门
 * 需求：
 *     通过上述的两种方式 创建StringBuilder对象
 *     在控制台直接打印上述创建好的两个对象 并观察结果
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        // 方案1: 空参构造创建StringBuilder对象
        StringBuilder sb1 = new StringBuilder();
        // 添加元素，返回StringBuilder对象
        StringBuilder sb2 = sb1.append("abc");
        StringBuilder sb3 = sb1.append("123");

        System.out.println(sb1);
        System.out.println(sb2);
        System.out.println(sb3);

        System.out.println("----------------[华丽分割线]----------------");

        System.out.println(sb1 == sb2); //地址相同 true
        System.out.println(sb1 == sb3); //地址相同 true
        System.out.println(sb2 == sb3); //地址相同 true

        //结论：
        // 1.因为只有一开始的时候使用new创建 sb1对象
        // 2.sb2 ，sb3都是指向同一块内存区域的变量

        System.out.println("----------------[华丽分割线]----------------");
        //方案2：使用字符串初始化 创建StringBuilder对象
        // 本质：String ==》StringBuilder
        StringBuilder sb4 = new StringBuilder("james");
        System.out.println(sb4);
    }
}

9.StringBuilder和string相互转换

问题: 为什么会有类型互相转换？
- 答案: 当某个类A 想用类B的功能的，我们可以尝试把类A对象转换成类B对象，这样就可以调用类B的方法之后，调用完毕之后，再转回类A即可。

package demo08_StringBuilder;
/*
    案例: 演示String和StringBuilder之间的相互转换.

    String -> StringBuilder:
        通过 StringBuilder的构造方法, 即: public StringBuilder(String s);

    StringBuilder -> String:
        通过 StringBuilder#toString()方法, 即: public String toString();
 */
public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        // 1.String -> StringBuilder;
        String name = "马佳玉";
        StringBuilder sb1 = new StringBuilder(name);
        System.out.println(sb1);
        System.out.println("----------------[华丽分割线]----------------");

        // 2.StringBuilder -> String
        String new_str = sb1.toString();
        System.out.println(new_str);
    }
}

10.拼接数组元素

链式调用：
- 如果某个方法的返回值是一个对象，可以再后边直接通过，语法继续调用对象的方法
实际开发写法
Arrays.toSring(arr)
代码

package demo05_StringBuilder;

import java.util.Arrays;

/*
    拼接数组元素
    需求：
        定义方法arrayToString() 把int数组的元素按照指定的格式拼接成一个字符串，并返回
        在main 方法中 调用上述的方法
        例如：数组int[] arr = {1,2,3},则拼接后，结果为：[1,2,3]
 */
public class Demo03 {
    
    
    public static void main(String[] args) {
    
    
        //1.定义数组
        int[] arr = {
    
    1,2,3};

        //实际开发写法：
        System.out.println(Arrays.toString(arr));

        System.out.println("----------------[华丽分割线]----------------");

        //调用自定义的arrayTostring方法
        String s = arrayToString(arr);
        System.out.println(s);
    }

    /**
     * 将数组转换成字符串
     * @param arr   int类型数组
     * @return      字符串
     * 例如： 数组为int[] arr = {1,2,3} 则拼接后 结果为：[1,2,3]
     */
    public static String arrayToString(int[] arr) {
    
    
        // 1.数组非空判断
        if (arr == null || arr.length == 0) {
    
    
            // 返回空数组
            return "[]";
        }

        //2.定义StringBuilder类的对象，接受缓存的字符串数据
        StringBuilder sb = new StringBuilder("[");

        // 遍历数组 完成数据拼接
        // 数组遍历快捷键 itar
        for (int i = 0; i < arr.length; i++) {
    
    
            //arr = {1,2,3} 则拼接后，结果为：[1,2,3]
            // 如果没有到最后一个元素 我们添加数组的元素和逗号
            if (i != (arr.length - 1)) {
    
    
                //添加数组的元素和逗号
                // 链式调用：如果某一个方法返回值是该类的对象，后面可以继续掉该对象的其他方法，这种继续调用
                sb.append(arr[i]).append(",");
            } else {
    
    
                // 如果到最后一个元素 我们添加数元素和 “]”
                sb.append(arr[i]).append("]");
            }
        }
        // 将StringBuilder对象转换成字符串返回
        return sb.toString();
    }
}

11.StringBuilder反转字符串

链式调用：
如果某个方法的返回值是一个对象可以在后边直接通过，语法继续调用对象的方法
代码

package demo05_StringBuilder;

import java.util.Scanner;

/*
    反转字符串
    需求：
        键盘录入一个字符串 然后反转其内容 并打印

    思路：通过StringBuilder#reverse()方法实现.
        1. 把 String -> StringBuilder.
        2. 调用StringBuilder#reverse()反转内容.
        3. 把StringBuilder -> String.
        4. 打印结果.
 */
public class Demo04 {
    
    
    public static void main(String[] args) {
    
    
        // 输入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        String s = sc.nextLine();
        System.out.println("反转之前: " + s);  //反转之前: sdfslkdfjsldf
        System.out.println("----------------[华丽分割线]----------------");
        //1.把String -》StringBuilder
        StringBuilder sb = new StringBuilder(s);

        //2. 把StringBuilder#reverse()反转内容
        sb.reverse();

        //3.把StringBuilder -》String
        String new_str = sb.toString();
        //4.打印结果
        System.out.println("反转之后: " + new_str);   //反转之后: fdlsjfdklsfds
        System.out.println("----------------[华丽分割线]----------------");

        //方案2：链式调用，一句代码搞定
        String s1 = new StringBuilder(s).reverse().toString();
        System.out.println(s1);

    }
}

数据结构算法：冒泡排序，快速排序，希尔排序，堆排序。。。。。。。

12.冒泡排序

冒泡排序原理：
- 相邻元素两两比较，大的往后走，这样第一轮比较完之后，最大值就在最大所引出
代码

package demo06_sort;

import java.util.Arrays;

/*
    案例: 演示冒泡排序.
    需求:
        已知数组int[] arr = {25, 69, 80, 57, 13}, 请编写代码对齐进行升序排序.
        即: 排序后结果为: arr = {13, 25, 57, 69, 80};

    核心点:
        1. 总共比较几轮?
            arr.length - 1
        2. 每轮比较多少次?
            arr.length - 1 - i
        3. 谁和谁比较?
            arr[j] 和 arr[j+1]

    灵魂三连问:
        1. 外循环的-1是什么意思?
            最后一轮不需要和自己再比较，减少比较次数，提高性能
        2. 内循环的-1是什么意思?
            防止出现索引越界
        3. 内循环的-i是什么意思?
            减少每一轮的比较次数，提高性能
 */
public class Demo01_Sort {
    
    
    public static void main(String[] args) {
    
    
        //1.定义数组
        int[] arr = {
    
    25,69,80,57,13};

        //2.定义外层循环控制: 比较的总轮数 arr.length -1
        //折叠快捷键ctrl + -
        for (int i = 0; i < arr.length - 1; i++) {
    
    // 0 1 2 3
            //3.定义内层循环控制每一轮比较的次数 arr.length -1 -i
            for (int j = 0; j < arr.length -1 - i; j++) {
    
    
                // 4. 两两比较 如果前面的值比后面一个值大 就交换位置 大的元素 ==》冒泡
                //前一个值: arr[j]
                //后面一个值: arr[j + 1]
                if (arr[j] > arr[j + 1]) {
    
    
                    /*
                        a和b交换
                        temp临时变量 记录
                        int temp = a;
                        a = b;
                        b = temp;
                     */
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 5.打印结果
        System.out.println(Arrays.toString(arr));
            //结果为：[13, 25, 57, 69, 80]
        /*for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
    }
}

二、Arrays

1.演示Arrays工具类的用法

Arrays工具类概念：
- 他是用来操作数组的工具类，里边定义了大量操作数组元素的方法，例如：排序、转换字符串等。
格式：

涉及到的成员方法:
	1. 对数组进行升序排序，默认是升序。
		public static void sort(int[] arr);
	2. 把数组转换成其对应的字符串表示形式，例如: int[] arr = [1,2,3]; --> "[1,2,3]"
		public static String toString(数组对象)；

工具类:
	1. 成员都是静态的
	2. 构造方法私有化

代码：

package demo06_sort;

import java.util.Arrays;

public class Demo02_Array_Sort {
    
    
    public static void main(String[] args) {
    
    
        //1. 定义数组
        int[] arr = {
    
    25,69,80,57,13};

        //2.对数组进行排序
        Arrays.sort(arr);

        //3.打印数组结果
        System.out.println(Arrays.toString(arr));
    }
}

四、包装类

1.包装类入门

概念

包装类入门
包装类简介:
	'	所谓的包装类指的就是 基本类型对应的引用类型。	'
	对应关系：
		基本类型				对应的包装类(引用类型)
		byte					Byte
		short					Short
		char					Character
		int  					Integer
		long					Long
		float					Float
		double					Double
		boolean					Boolean

	学习包装类主要目的：
		'	String类型的数据  ==转换==》  该包装类对应的基本类型	'

	例如：
		Integer	是用来把	"123" 	-> 123
		Double	是用来把	"10.3" 	-> 10.3
		Boolean 是用来把 "false" -> false
		..........

	Integer类解释:
		概述：
			'	他是int类型对应的引用类型(包装类)，主要适用于把"123" 	-> 123	'
		构造方法:
			public Integer(int i);			创建Integer对象，封装：整数。
			public Integer(String s)；		创建Integer对象，封装：字符串，必须是纯数字形式的字符串
		成员变量:
			public static final int MAX_VALUE;		int类型最大值。
			public static final int MIN_VALUE;		int类型最小值。

代码

package demo04_exercise;
/*
    案例：包装类入门
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        // int类型最大值
        System.out.println(Integer.MAX_VALUE);

        //int类型最小值
        System.out.println(Integer.MIN_VALUE);

        //构造方法
        //创建Integer对象，封装: 整数.
        Integer il = new Integer(10);
        System.out.println(il);

        // 创建Integer对象, 封装: 字符串, 必须是纯数字形式的字符串.
        Integer i1 = new Integer("123");
        System.out.println(i1);
    }
}

2.int和String相互转换

int 和 String 之间相互转换

int 和 String 之间如何相互转换
	int ---》 String：
		String s = "" + 10；

	String ---》 Int：
		int num = Integer.parseInt("123");

Integer类中的方法解释:
     public static int parseInt(String s);  把字符串形式的整数转成其对应的int类型.

记忆（细节）：
	所有包装类都有一个parseXXX（）方法，用于把字符串数据转换成该类型对应的基本类型的数据
	例如：
		int num = Integer.parseInt("123");
		double d = Double.parseDouble("10.3");
        boolean flag = Boolean.parseBoolean("true");

代码：

package demo07_interger;
/*
    int 和String之间如何相互转换
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //需求：int 和 String之间如何相互转换:

        //1. int -> String:
        String str = "" + 10;
        System.out.println(str);
        System.out.println("----------------[华丽分割线]----------------");

        //2.String -> Int
        String str_int = "520";
        int num  = Integer.parseInt(str_int);
        System.out.println(num);

        // 举一反三
        /*
        Double.parseDouble("10.11");
        Float.parseFloat("11.11");
        Boolean.parseBoolean("true");
        */
    }
}

3.字符串元素排序

需求:
    已知字符串String s = "91 27 45 38 50";
    请通过代码实现最终输出结果是: "27, 38, 45, 50, 91"

思路：
	1. 把String字符串转换成其对应的字符串数组。
			String[] arrstr = {
    
    "91", "27", "45", "38", "50"};
	2. 把String[]  -> int[]
            int[] arr = [91, 27, 45, 38, 50];
    3. 对int[]进行排序.
            int[] arr = [27, 38, 45, 50, 91];
    4. 把上一获取到的数组元素拼接成对应格式的字符串.
            "27, 38, 45, 50, 91"

涉及到的成员方法：
	String类中的成员的方法：
		public String[] split(String regex);	根据规则，切割字符串。
		public String substring(int start ，int end)；  截取字符串，包左不包右。
		public String replaceAll(String older ,String newStr); 替换字符串

	Integer类中的成员方法：
		将字符串转换成int类型
			parseInt();
			
	Arrays类中的成员方法：
		数组排序
			sort(),
			打印数组
			toString()

代码

package demo07_interger;

import java.util.Arrays;

/**
 * 案列：字符串元素排序
 * 已知字符串String s = "91 27 45 38 50";
 * 请通过代码实现最终输出结果是: "27, 38, 45, 50, 91"
 */
public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        String str = "91 27 45 38 50";
        //1.将字符串String 转换成对应的字符串数组
        //"91 27 45 38 50" ==>  String[] arrStr = {"91", "27", "45", "38", "50"}
        String[] arrstr = str.split(" ");

        //2.字符串数组String[] 转换成 int[]整型数组
        //int[] arr = {91, 27, 45, 38, 50}
        int[] intArr = new int[arrstr.length];
        // 遍历字符串数组，将每一个字符串转换成整型，再装入到int[]整型数组
        for (int i = 0; i < arrstr.length; i++) {
    
    
            String str1 = arrstr[i];
            // 将每一个字符串转换成整型
            intArr[i] = Integer.parseInt(str1);
        }
        //3.int[]整型数组进行升序排序
        Arrays.sort(intArr);

        //4.排序后的int[]整型数组，拼接成字符串
        // [27, 38, 45, 50, 91] ==> 目标："27, 38, 45, 50, 91"
        String s11 = Arrays.toString(intArr);
        // 字符串的截取
        //String s12 = s11.substring(1, s11.length() - 1);
        // 字符串的替换
        // 参数1：旧的字符串 参数2：新的字符串  注意点：\\ 转译
        String s12 = s11.replaceAll("\\[","").replaceAll("]","");
        //"27, 38, 45, 50, 91"
        System.out.println(s12);

    }
}

4.自动拆装箱(JDK1.5的特性)

代码

package demo07_interger;

import com.sun.tools.corba.se.idl.InterfaceGen;

/*
    案例: 演示自动拆装箱(JDK1.5的特性)

    装箱: int -> Integer, 即: 把基本类型 -> 包装类.
    拆箱: Integer -> Int, 即: 包装类 -> 基本类型.
 */
public class Demo03 {
    
    
    public static void main(String[] args) {
    
    
        // 1.装箱
        // JDK1.5之前的写法  装箱: int -> Integer,
        Integer i1 = new Integer(1);

        // JDK1.5版本 以上版本
        Integer i2 = 10;

        System.out.println(i1);
        System.out.println(i2);
        System.out.println("----------------[华丽分割线]----------------");

        // 2.拆箱
        // JDK1.5之前的写法 拆箱: Integer -> Int
        int a = i2.intValue();

        // JDK1.5 以上的写法 拆箱: Integer -> Int
        int b = i2;

        System.out.println(a);
        System.out.println(b);

        // 观察如下代码 发生了什么
        // 装箱
        Integer i3 = 10;
        // 等价于：i3 = i3 + 20   先拆箱i3变成int，然后和20相加，再把结果int类型装箱变成Integer
        i3 += 20;
    }
}

五、Date和Calendar

Date类


Date解释:java.util包下的类, 它表示日期类,可以精确到毫秒,里边大多数的方法已过时,已经被Calendar替代了.

   构造方法:
            public Date();    // 获取当前时间           

   成员方法:
            public void setTime(long time);      //设置时间, 单位: 毫秒.
            public long getTime();      				 //获取时间, 单位: 毫秒.

   细节:
        1. 直接打印Date对象, 格式我们不习惯, 能不能换成我们习惯的格式.
           可以, SimpleDateFormat可以实现.
        2. 翻看API发现Date大多数方法已过时, 被Calendar替代了.
            Calendar: 日历类.
        3. 获取当前时间毫秒值.
            long time = System.currentTimeMillis();

代码

package demo08_date;
import java.util.Date;

/*
    案例: 演示Date类的用法.
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //演示Date的用法
      
      	// 1.获取当前时间
        Date d = new Date();
        System.out.println(d);      //Thu Sep 09 17:41:30 CST 2021
        System.out.println(d.getTime());  //1631180490798, 从1970到当前时间, 总共有多少毫秒.
        System.out.println("--------------------");
				
        // 2.设置时间
        Date d2 = new Date(1631180490798L);
        System.out.println(d2); //Thu Sep 09 17:41:30 CST 2021
        System.out.println("--------------------");

        //3.获取当前时间毫秒值, 实际开发做法.
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

2.SimpleDateFormat时间格式化类的用法

概述：
	他表示日期格式化类，主要用来格式化或者解析日期的。

构造方法：
	public SimpleDateFormat();			默认模板
	public SimpleDateFormat(String pattern) 指定模板

成员方法：
	Date -》 String：	格式化
		format();
	String -> Date:		解析
		parse();
案例：
	自定义DateUtils工具类。

代码

package demo08_SimpleDateFormat;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
    案例:演示SimpleDateFormat的用法.
    案例:
        自定义DateUtils工具类.
 */
public class Demo01 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // 1.获取当前日记
        Date d = new Date();
        System.out.println(d);
        System.out.println("===================");

        //2.演示：Date 转化 -》String：
        // 格式化日期： YYYY-MM-DD HH-mm-ss
        // 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        String new_date = sdf.format(d);
        System.out.println(new_date);
        System.out.println("=================");

        //3.演示：String -》Date:
        String s = "2021年10月10日 15:50:50";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //此处有异常，需要抛出异常 快捷：alt + 回车
        Date d2 = sdf2.parse(s);
        System.out.println(d2);
    }
}

3.Calendar基本使用

案例: 演示Calendar的用法.

Calendar简介：
	概述：
		它表示日历类，是一个抽象类，里面大多数的方法都是代替 Date类的功能。
	成员常量：
		public static final int YEAR；
		public static final int MONTH;
        public static final int DATE;
        public static final int DAY_OF_MONTH;
        public static final int DAY_OF_YEAR;

	成员方法：
		public static Calendar getInstance()；	获取Calendar类的实例.
		public int get(int field);      根据指定的日历字段, 获取值.
		public int set(int year, int month, int day);  设置时间.

代码

package demo08_SimpleDateFormat;

import java.util.Calendar;

/*
    案例: 演示Calendar的用法.
 */
public class Demo02 {
    
    
    public static void main(String[] args) {
    
    
        //抽象类多态  Calendar类的子类对象.
        Calendar c = Calendar.getInstance();

        //获取时间字段.
        System.out.println(c.get(Calendar.YEAR));   //2021
        System.out.println(c.get(Calendar.MONTH));  //8, Java中月份范围: 0 ~ 11
        System.out.println(c.get(Calendar.DATE));   //9
        System.out.println(c.get(Calendar.DAY_OF_MONTH));   //9
        System.out.println(c.get(Calendar.DAY_OF_YEAR));    //252
        System.out.println("-----------------------------");
    }
}

4. 异常处理

异常简介:
        概述:
            Java中, 把所有的非正常情况统称为异常.
        分类:
            父类: Throwable
                Exception:  这个才是我们常说的异常.
                    运行时异常: 指的是 RuntimeException及其子类.
                    编译期异常: 指的是 非RuntimeException及其子类.
        编译期异常和运行时异常的区别是什么?
            编译期异常: 必须处理, 才能通过编译.
            运行时异常: 不处理, 也能通过编译, 但是运行报错.

        JVM默认是如何处理异常的?
            1. 会把异常的类型, 原因, 位置打印到控制台上.
            2. 并终止程序的执行.

        异常的处理方式:
            方式1: 声明抛出异常, throws
                大白话翻译: 告诉调用这里, 我这里有问题, 谁调用, 谁处理.
                处理之后, 程序终止运行, JVM默认用的就是这个.

            方式2: 捕获异常, 处理之后, 程序继续执行.
                try {
    
    
                    可能出现问题的代码;
                } catch(Exception e) {
    
    
                    e.printStackTrace();  //打印异常的类型, 位置, 原因
                } finally {
    
    
                     里边放一定会执行的代码.
                }

代码

package com.itheima.demo09_exception;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/*
    案例: 演示异常.
 */
public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //运行时异常
        //System.out.println(1 / 0);      //ArithmeticException(算术异常)
        //System.out.println("看看我执行了吗?");

        //编译期异常
        //SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //sdf2.parse("2020年1月1日");

        try{
    
    
            //可能出现问题的代码;
            show();
        }catch (Exception e){
    
    
            e.printStackTrace();  //打印异常的类型, 位置, 原因
        }finally {
    
    
            //释放资源的, 正常情况下, 里边的代码永远会执行.
        }
        System.out.println("看看我执行了吗?");
    }
    public static void show() throws ParseException {
    
    
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        sdf2.parse("2020/1/1");
    }

}

JAVA 基础篇（三）----API 异常处理好好看好好学

JAVA----API

一、API

1.Scanner的基本使用

2.Scanner的小技巧.

3.Object类的toString和 equals方法

4.字符串比较详解

5. 模拟登陆

6.遍历字符串

7. 统计每类字符的次数

8.StringBuilder基本使用

9.StringBuilder和string相互转换

10.拼接数组元素

11.StringBuilder反转字符串

12.冒泡排序

二、Arrays

1.演示Arrays工具类的用法

四、包装类

1.包装类入门

2.int和String相互转换

3.字符串元素排序

4.自动拆装箱(JDK1.5的特性)

五、Date和Calendar

2.SimpleDateFormat时间格式化类的用法

3.Calendar基本使用

4. 异常处理

猜你喜欢

JAVA 基础篇（三）----API 异常处理 好好看 好好学

JAVA----API

一、API

1.Scanner的基本使用

2.Scanner的小技巧.

3.Object类的toString和 equals方法

4.字符串比较详解

5. 模拟登陆

6.遍历字符串

7. 统计每类字符的次数

8.StringBuilder基本使用

9.StringBuilder和string相互转换

10.拼接数组元素

11.StringBuilder反转字符串

12.冒泡排序

二、Arrays

1.演示Arrays工具类的用法

四、包装类

1.包装类入门

2.int和String相互转换

3.字符串元素排序

4.自动拆装箱(JDK1.5的特性)

五、Date和Calendar

2.SimpleDateFormat时间格式化类的用法

3.Calendar基本使用

4. 异常处理

猜你喜欢

JAVA 基础篇（三）----API 异常处理好好看好好学