Java学习打卡第六天——[Calendar，Date，Collection，增强for，异常的简介和使用]

Javaee之【Calendar】

Javaee之【Date】

Javaee之【异常】

Javaee之【Collection之ArrayList和LinkedList】

Calendar的简单使用

这里主要实现了： 获取年月日，并对年月日进行加减：

import java.util.Calendar;

public class Calendar02 {
    public static void main(String[] args) {
        Calendar c =Calendar.getInstance();

        //获取年月日
//        int year = c.get(Calendar.YEAR);
//        int month = c.get(Calendar.MONTH)+1;
//        int day = c.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + day + "日");


        //public abstract void add(int field, int amount)
        // 对当前日历进行增或者减--------------
        // 六年后的今天
//        c.add(Calendar.YEAR,+6);
//        int year = c.get(Calendar.YEAR);
//        int month = c.get(Calendar.MONTH)+1;
//        int day = c.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + day + "日");

        //四年前五天后的今天、
//        c.add(Calendar.YEAR,-4);
//        c.add(Calendar.DATE,+5);
//        int year = c.get(Calendar.YEAR);
//        int month = c.get(Calendar.MONTH)+1;
//        int day = c.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + day + "日");

        //public final void set(int year, int month, int date)
        //将日期设为指定值
        c.set(2022,1,8);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + day + "日");

    }
}

Date

主要实现两种方法： 使用SimpleDateFormat类将日期格式化，转变成自己想要的格式或者将时间转化成国际标准（这里有一个异常在后面发布）：

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

public class Date {
    public static void main(String[] args) throws ParseException {
        java.util.Date d = new java.util.Date();

        //从1970年到现在过去了多少秒
        System.out.println(d.getTime());
        //从1970年到现在过去了多少年
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");


        //使用SimpleDateFormat类将日期格式化
        SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s1 = s.format(d);
        System.out.println(s1);

        //转回国际标准
        String ss = "2022-01-08 10:42:30";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        java.util.Date dd = sdf.parse(ss);
        System.out.println(dd);
    }
}

异常

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。
这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-
要理解Java异常处理是如何工作的，掌握以下三种类型的异常：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

编译时异常就是在编写代码的时候必须要处理的清况
可以使用throws解决：
提倡使用
也可以使用try{
}catch (){
}

运行时异常：运行时出现错误：
数组运行时异常示例：

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

        //使用异常处理可以使得出错的代码可以继续执行到结束
        /*
         try{
         可能会出错的代码
         }catch(异常类名 变量名){
         解决代码
         }*/
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try {
            int[] arr = {12,23,45,56};
            System.out.println(arr[4]);
        }catch (ArrayIndexOutOfBoundsException e){
//            System.out.println("你访问的数组下标不存在");
            e.printStackTrace();
        }
    }
}

解决异常也可以使用throw来自动抛出一个异常；
使用案例：
案例的异常原因：输入的分数在0-120区间之外
解决方法：在教师类里面需要给出解决办法，在测试类中采用 e.printStackTrace();输出异常原因

Teacher类

public class Teacher {
    public void checkScore(int score)throws ScoreException{
        //throws后面跟的是类名
        if (score<0||score>100){
//            throw new ScoreException();
            throw new ScoreException("你输入的分数有误，分数应该在0-100之间");//抛出一个异常
        }else {
            System.out.println("分数正常");
        }
    }
}

分数类继承Exception直接表明是一个异常：

public class ScoreException extends Exception{//extends Exception表明了这是一个异常
    //有参无参形式
    public ScoreException(){

    }
    public ScoreException(String message){
        super(message);
    }
}

测试类：

import java.util.Scanner;

public class TeacherDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个分数：");
        int score = sc.nextInt();
        Teacher t = new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

Collection之ArrayList和LinkedList

Java 集合框架主要包括两种类型的容器；
一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。
Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
一张图看懂集合之间关系：

零外：
ArrayList底层是数组；《访问数据方便》
LinkedList底层是链表所以具有链表的特性（删除数值方便）

示例一：
Collection的常用方法：

import java.util.ArrayList;
import java.util.Collection;

public class Collection02 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();

        //boolean add(E e) 确保此集合包含指定的元素（可选操作）。
        c.add("hello");
        c.add("world");
        c.add("java");
//        System.out.println(c);

        //boolean remove(Object o)此集合中移除指定元素的单个实例（如果存在）（可选操作）。
//        c.remove("java");
//        System.out.println(c);

        //void clear() 从此集合中删除所有元素（可选操作）。
//        c.clear();

        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        System.out.println(c.contains("hello"));

        //boolean isEmpty() 如果此集合不包含任何元素，则返回 true 。
        System.out.println(c.isEmpty());

        //int size() 返回此集合中的元素数。
        System.out.println(c.size());
    }
}

iterator迭代器的使用：
通过集合的对象生成可以直接遍历集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collect_03 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();

        //boolean add(E e) 确保此集合包含指定的元素（可选操作）。
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);

        //Iterator<E> iterator() 返回此集合中元素的迭代器。
        Iterator<String> it = c.iterator();
        //输出下一个元素
//        System.out.println(it.next());

        //boolean hasNext() 如果迭代具有更多元素，则返回 true 。
        //集合的遍历
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

List集合属于Collection的一种允许有重复的数据：
List集合的使用案例：

Student类：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

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

测试类：

public class ListDemo {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();

        Student s1 = new Student("林青霞", 22);
        Student s2 = new Student("朱茵", 21);
        Student s3 = new Student("蔡少芬", 20);

        //把学生添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //遍历list集合
        //方法一
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        //方法二
        for (int x = 0; x < list.size(); x++) {
            Student ss = list.get(x);
            System.out.println(ss.getName() + "," + ss.getAge());
        }
    }
}

示例二：
采用字符串的方式添加元素到集合里面去：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");

        //创建ListIterator()对象
        ListIterator<String> lst = list.listIterator();
        while (lst.hasNext()){
            String s = lst.next();
            if (s.equals("world")){
                lst.add("javaee");
            }
        }

        System.out.println(list);
    }
}

ArrayList和LinkedList的综合案例：
在这里使用了一种增强for
增强for的格式：
for(变量类型 变量名 : 数组或者集合){
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

//使用ArrayList和Linkedlist遍历集合
public class ArrayandLInk {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<String>  list = new ArrayList<String>();

        list.add("hello");
        list.add("world");
        list.add("java");
        //三种遍历
        //方法一：增强for
        for (String s : list){
            System.out.println(s);
        }
        System.out.println("-------");


        //方法二：普通for
        for (int x=0; x<list.size(); x++){
            String s = list.get(x);
            System.out.println(s);
        }
        System.out.println("-------");

        //方法三：iterator迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------");

        //创建LinkedList集合
        LinkedList<String> list1 = new LinkedList<String>();
        list1.add("hello");
        list1.add("world");
        list1.add("java");

        //遍历方法
        //方式一： 增强for
        for (String s : list1){
            System.out.println(s);
        }
        System.out.println("-------");

        //方法二：普通for
        for (int x=0; x<list1.size(); x++){
            String s = list1.get(x);
            System.out.println(s);
        }
        System.out.println("-------");

        //方法三：迭代器
        Iterator<String> it1 = list1.iterator();
        while(it1.hasNext()){
            String ss = it1.next();
            System.out.println(ss);
        }
    }
}

ArrayList和LinkedList的综合案例02：
使用学生类：
学生类：

public class Student {
    private String name;
    private  int age;

    public Student() {
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class ArrayListandLinkedListDemo {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();

        Student s1 = new Student("林青霞",22);
        Student s2 = new Student("朱茵",21);
        Student s3 = new Student("赵丽颖",20);

        list.add(s1);
        list.add(s2);
        list.add(s3);

        //三种遍历方法
        for (Student s :list){
            System.out.println(s);
        }
        System.out.println("-------");

        for (int x=0; x<list.size(); x++){
            Student s = list.get(x);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("-------");

        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("-------");


        //创建LinkedList集合对象
        LinkedList<Student> list1 = new LinkedList<Student>();

        list1.add(s1);
        list1.add(s2);
        list1.add(s3);
        //三种遍历方法
        for (Student s : list1){
            System.out.println(s);
        }
        System.out.println("-------");

        for (int x = 0; x < list1.size(); x++){
            Student s = list1.get(x);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("-------");

        ListIterator<Student> lit = list1.listIterator();
        while (lit.hasNext()){
            Student s = lit.next();
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

LinkedList特有的功能：

实现：

import java.util.LinkedList;

//void addFirst(E e) 在此列表的开头插入指定的元素。
//void addLast(E e) 将指定的元素追加到此列表的末尾。
//E getFirst() 返回此列表中的第一个元素。
//E getLast() 返回此列表中的最后一个元素。
//E removeFirst() 从此列表中删除并返回第一个元素。
//E removeLast() 从此列表中删除并返回最后一个元素。
public class LinkedListDemo01 {
    public static void main(String[] args) {

        LinkedList<String> list = new LinkedList<String>();

        list.add("hello");
        list.add("world");
        list.add("java");


        //void addFirst(E e) 在此列表的开头插入指定的元素。
//        list.addFirst("javaee");

        //void addLast(E e) 将指定的元素追加到此列表的末尾。
//        list.addLast("javase");

        //E getFirst() 返回此列表中的第一个元素。
        System.out.println(list.getFirst());

        //E removeFirst() 从此列表中删除并返回第一个元素。
        System.out.println(list.removeFirst());

        System.out.println(list);
    }
}