0
点赞
收藏
分享

微信扫一扫

黑马全套Java教程（七）

343d85639154 2022-12-06 阅读 47
JavaSystemjava字符串系统/运维


文章目录

  • ​​27 Arrays​​
  • ​​27.1 冒泡排序​​
  • ​​27.2 Arrays类的概述和常用方法​​
  • ​​28 基本类型包装类​​
  • ​​28.1 基本类型包装类概述​​
  • ​​28.2 Integer类的概述和使用​​
  • ​​28.3 int和String的相互转换​​
  • ​​28.4 自动装箱和拆箱​​
  • ​​29 日期类​​
  • ​​29.1 Date类概述和构造方法​​
  • ​​29.2 SimpleDateFormat类概述​​
  • ​​29.3 Calendar概述 和 常用方法​​
  • ​​30 异常​​
  • ​​30.1 异常概述​​
  • ​​30.2 JVM的默认处理方案​​
  • ​​30.3 异常处理​​
  • ​​try...catch...​​
  • ​​throws​​
  • ​​30.4 Throwable的成员方法​​
  • ​​30.5 编译时异常和运行时异常区别​​
  • ​​30.6 自定义异常​​


本博客从视频d198开始，​​视频链接​​

27 Arrays

27.1 冒泡排序

黑马全套Java教程（七）_java


黑马全套Java教程（七）_System_02

package myArrays.Demo1;

//冒泡排序
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前：" + arrayToString(arr));

        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }

        System.out.println("排序后：" + arrayToString(arr));
    }

    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}



27.2 Arrays类的概述和常用方法

黑马全套Java教程（七）_java_03


工具类的设计思想：

  • 构造方法用private修饰
  • 成员用public static修饰

package myArrays.Demo2;

import java.util.Arrays;

/*
    Arrays类包含用于操作数组的各种方法

    public static String (int[] a): 返回指定数组的内容和字符串表示形式
    public static voidsort(int[] a): 按照数字顺序排序指定的数组
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};

        System.out.println("排序前：" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

黑马全套Java教程（七）_java_04




28 基本类型包装类

28.1 基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

黑马全套Java教程（七）_System_05

package myInteger.Demo1;
/*
    基本类型包装类
 */
public class InterDemo {
    public static void main(String[] args) {
        //需求：我要判断一个数据是否在int范围内？
        //public static final int Min_VALUE
        //public static final int MAX_VALUE
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
}

黑马全套Java教程（七）_System_06


28.2 Integer类的概述和使用

Integer：包装一个对象中的原始类型int的值

黑马全套Java教程（七）_System_07

package myInteger.Demo2;
/*
    构造方法：
        public Integer(int value):根据int值创建Integer对象（过时）
        public Integer(String s):根据String值创建Integer对象（过时）

    静态方法获取对象：
        public static Integer valueOf(int i)：返回表示指定的int值的Integer实例
        public static Integer valueOf(String s):返回一个保存指定值的Integer对象 String
 */
public class InterDemo {
    public static void main(String[] args) {
        //1
        Integer i1 = new Integer(100);
        System.out.println(i1);

        //2
        Integer i2 = new Integer("100");
        System.out.println(i2);

        //3
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        //4
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
    }
}



28.3 int和String的相互转换

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

黑马全套Java教程（七）_System_08

package myInteger.Demo3;

//int和String类型的相互转换
public class IntegerDemo {
    public static void main(String[] args) {
        //int---String
        int number = 100;

        //方式一
        String s1 = "" + number;
        System.out.println(s1);

        //方式二
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------------");

        //String---int
        String s = "100";
        //方式一
        //String---Integer----int
        Integer i = Integer.valueOf(s);
        int x = i.intValue();
        System.out.println(x);

        //方式二
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}



案例：字符串中数据排序

黑马全套Java教程（七）_System_09

package myInteger.Demo4;

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //1.定义字符串
        String s = "91 27 46 38 50";

        //2.字符串数字存储入数组
        String[] strArray = s.split(" ");
        String start = Arrays.toString(strArray);
        System.out.println(start);

        //3.int数组
        int[] arr = new int[strArray.length];
        for(int i=0;i< strArray.length ;i++){
            arr[i] = Integer.parseInt(strArray[i]);
        }
        Arrays.sort(arr);
        String result = Arrays.toString(arr);
        System.out.println(result);

    }
}

黑马全套Java教程（七）_System_10


28.4 自动装箱和拆箱

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

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

黑马全套Java教程（七）_字符串_11

package myInteger.Demo5;

import myInteger.Demo1.InterDemo;

/*
    装箱：把基本数据类型转换为对应的包装类类型
    拆箱：把包装类类型转换为对应的基本数据类型
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(100);  //手动装箱
        Integer ii = 100;   //自动装箱

        //拆箱
        ii = ii.intValue() + 200;   //手动拆箱
        ii += 200;   //自动
        System.out.println(ii);

        Integer iii = null;
        if(iii!=null) {
            iii += 300;
        }
        System.out.println(iii);
    }
}


29 日期类

29.1 Date类概述和构造方法

Date代表了一个特定的时间，精确到毫秒

黑马全套Java教程（七）_java_12

package myDate.Demo1;

import java.util.Date;

/*
构造方法：
    public Date():分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
    public Date(long date):分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
 */
public class DateDemo01 {
    public static void main(String[] args) {
        //1.
        Date d1 = new Date();
        System.out.println(d1);

        //2.
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);
    }
}

黑马全套Java教程（七）_字符串_13


常用方法：

黑马全套Java教程（七）_字符串_14

package myDate.Demo1;

import java.util.Date;

/*
    public long getTime():获取的是日期对象从1970年1月1日 0时刻开始的毫秒值
    public void setTime(long time):设置时间，给的是毫秒值
 */
public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();

        //1.
        System.out.println(d);  //当前时间
        System.out.println(d.getTime());   //获取某时间点到现在的毫秒值
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
        System.out.println("------------------");

        //2.
        //long time = 1000*60*60;
        long time = System.currentTimeMillis();  //返回当前时间
        d.setTime(time);
        System.out.println(d);
    }
}

黑马全套Java教程（七）_Java_15


29.2 SimpleDateFormat类概述

黑马全套Java教程（七）_Java_16


构造方法：

黑马全套Java教程（七）_System_17


格式化和解析日期：

黑马全套Java教程（七）_Java_18

package mySimpleDateFormat.Demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
    构造方法：
        public SimpleDateFormat(): 构造一个SimpleDateFormat，使用默认模式和日期格式
        public SimpleDateFormat(String pattern): 构造一个SimpleDateFormat使用给定的模式和默认的日期格式

    格式化：从 Date 到 String
          public final String format(Date date): 将日期格式化成日期/时间字符串

    解析：从 String 到 Date
         public Date parse （String source）：从给定字符串的开始解析文本以生成日期
 */

public class Demo1 {
    public static void main(String[] args) throws ParseException {
        //格式化： 从Date到String
        Date d = new Date();   //获取当前时间
//        SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);   //格式化成字符串
        System.out.println(s);

        //从String 到 Date
        String ss = "2048-08-09 11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

黑马全套Java教程（七）_java_19


案例：日期工具类

黑马全套Java教程（七）_System_20


DateUtils.java

package mySimpleDateFormat.Demo2;

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

/*
    工具类
        构造方法私有
        成员方法静态
 */
public class DateUtils {
    private DateUtils(){}  //构造方法私有
    /*
        把日期转为指定格式的字符串
        返回值类型：String
        参数：Date date，  String format
     */
    public static String dateToString(Date date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }

    /*
        把字符串解析为指定格式的日期
        返回值：Date
        参数：String s， String format
     */
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }
}

DateDemo.java

package mySimpleDateFormat.Demo2;

import java.text.ParseException;
import java.util.Date;

//测试类
public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);
        System.out.println("-----------------");

        String s = "2048-08-09 12:12:12";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}



29.3 Calendar概述 和 常用方法

黑马全套Java教程（七）_字符串_21

package myCalendar.Demo1;

import java.util.Calendar;

/*
    Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供一些方法

    Calendar 提供了一个类方法 getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化
        Calendar rightNow = Calendar.getInstance();
 */
public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态的形式
        System.out.println(c);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

黑马全套Java教程（七）_java_22


黑马全套Java教程（七）_System_23

package myCalendar.Demo2;

import java.util.Calendar;

/*
    Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供一些方法

    Calendar 提供了一个类方法 getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化
        Calendar rightNow = Calendar.getInstance();
 */
public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态的形式
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
        System.out.println("--------------");

        c.set(2048,10,10);
        int year1 = c.get(Calendar.YEAR);
        int month1 = c.get(Calendar.MONTH) + 1;
        int date1 = c.get(Calendar.DATE);
        System.out.println(year1 + "年" + month1 + "月" + date1 + "日");
        System.out.println("---------------");

        c.add(Calendar.YEAR, 3);   //add加减时间值
        c.add(Calendar.DATE, -5);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH) + 1;
        int date2 = c.get(Calendar.DATE);
        System.out.println(year2 + "年" + month2 + "月" + date2 + "日");
    }
}

黑马全套Java教程（七）_System_24

案例：二月天

黑马全套Java教程（七）_字符串_25

package myCalendar.Demo3;

import java.util.Calendar;
import java.util.Scanner;

/*
    需求：
        获取任意一年的二月有多少天
 */
public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = sc.nextInt();

        //设置日历年月日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);  //月份索引是从0开始的

        //往前推一天
        c.add(Calendar.DATE, -1);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }
}


30 异常

30.1 异常概述

异常：就是程序出现了不正常的情况

黑马全套Java教程（七）_Java_26


索引越界异常显示：

黑马全套Java教程（七）_Java_27


30.2 JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

  • 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
  • 程序停止执行

30.3 异常处理

如果程序出现了问题，我们需要自己来处理，有两种方案：

  • try…catch…
  • throws

try…catch…

类似Python的try…except…

黑马全套Java教程（七）_System_28

package myException.Demo2;

//异常
public class Demo1 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            //System.out.println("你访问的数组索引越界！");
            e.printStackTrace();
        }
    }
}

黑马全套Java教程（七）_System_29


throws

黑马全套Java教程（七）_System_30


1.

黑马全套Java教程（七）_字符串_31


2.

黑马全套Java教程（七）_java_32


3.

黑马全套Java教程（七）_字符串_33


4.

黑马全套Java教程（七）_Java_34

30.4 Throwable的成员方法

黑马全套Java教程（七）_Java_35

package myException.Demo2;

//异常
public class Demo2 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }

    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {   //e为异常对象
            //System.out.println("你访问的数组索引越界！");
            //e.printStackTrace();   //这个输出信息最全
            System.out.println("e.getMessage()：" + e.getMessage());  //Index 3 out of bounds for length 3   异常原因
            System.out.println("e.toString()：" + e.toString());
        }
    }
}

黑马全套Java教程（七）_Java_36


30.5 编译时异常和运行时异常区别

黑马全套Java教程（七）_java_37

30.6 自定义异常

黑马全套Java教程（七）_Java_38


ScoreException.java

package myException.Demo4;

public class ScoreException extends Exception{
    public ScoreException(){}
    public ScoreException(String message){
        super(message);
    }
}

Teacher.java

package myException.Demo4;

public class Teacher {
    public void cheakScore(int score) throws ScoreException {
        if (score < 0 || score > 100) {
            //throw new ScoreException();   //无参构造方法
            throw new ScoreException("你给的分数有误，分数应该在0-100之间");
        } else {
            System.out.println("分数正常！");
        }
    }
}

TeacherTest.java

package myException.Demo4;

import java.util.Scanner;

public class TeacherTest {
    public static void main(String[] args) throws ScoreException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数：");
        int score = sc.nextInt();

        Teacher t = new Teacher();
        t.cheakScore(score);    //编译时异常
    }
}

黑马全套Java教程（七）_System_39


注意：

黑马全套Java教程（七）_Java_40


本博客到视频d219截止！


举报

相关推荐

黑马全套Java教程（三）

JavaSystem字符串构造方法系统/运维

黑马全套Java教程（六）

javaSystem抽象类系统/运维

黑马全套Java教程（五）

JavaSystemjava父类系统/运维

黑马全套Java教程（一）

JavaSystemi++系统/运维

黑马全套Java教程（二）

JavaSystem数组数据系统/运维

黑马全套Java教程（八）：集合进阶

JavaSystemjavaList系统/运维

黑马全套Java教程（十）：网络编程

javajvm前端System.net编程语言

黑马程序员SpringBoot2全套教程学习笔记

spring bootjavaintellij-idearedisehcache

优质全套SpringMVC教程

c语言c++算法

Java Web 开发入门全套教程（Vue + Spring Boot）

项目实战vueJava程序猿VueJAVA程序员
0 条评论