Java(十六)

知识点一：常用类的扩展

1.时间类

1）Date

缺点：显示不友好，年有1990问题，月是少1

@Test
    public void test1() throws ParseException {
        long time = System.currentTimeMillis(); // 当前时间, 以1970-01-01 00:00:00.000为0, 距离当前时间的毫秒数
        System.out.println(time);
        Date date = new Date();
        System.out.println(date);
        //时间格式化器
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println(format);

        String string = "1972-05-12 12:33:50";
        Date parse = simpleDateFormat.parse(string); // 解析转换字符串为日期对象
        System.out.println(parse);

        System.out.println(simpleDateFormat.format(time));

        Date date2 = new Date(2008, 8, 8);
        System.out.println(simpleDateFormat.format(date2));
    }

测试：写一个小时钟

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

public class Clock {
	
	public static void main(String[] args) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		while (true) {
			//java.util.Date date = new java.util.Date();
			long l = System.currentTimeMillis();
			//System.out.print("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" + sdf.format(l));
			System.out.print("\r" + sdf.format(l));
		}
	}
}

2)Calender

缺点 : 显示不友好, 月有小1, 内部用数组保存数据不好. 致命缺点: 内容可以改变, 不好.

@Test
    public void test2() {
        Calendar calendar = Calendar.getInstance(); //new Calendar(); // 不能直接new对象的时候.
        System.out.println(calendar);
        //int year = calendar.getYear();
        int year = calendar.get(Calendar.YEAR); // 获取年
        int month = calendar.get(Calendar.MONTH); // 存储的月比实际要小1
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println(year);
        System.out.println(month);
        System.out.println(day);

        // 设置为1992,10,22
        calendar.set(Calendar.YEAR, 1992);
        calendar.set(Calendar.MONTH, 9);
        calendar.set(Calendar.DAY_OF_MONTH, 22);

        System.out.println(calendar.getTime()); // 转换成date对象

        calendar.add(Calendar.MONTH, 10); // 10个月后

        System.out.println(calendar.getTime());

        calendar.add(Calendar.DAY_OF_MONTH, -500); // 500天以前

        System.out.println(calendar.getTime());
    }

测试：// 创建Calendar对象, 设置为你的生日, 再推算你的百日.

@Test
    public void exer() {
        Calendar calendar = Calendar.getInstance();
        // 1978,6,9
        calendar.set(Calendar.YEAR, 1978);
        calendar.set(Calendar.MONTH, 5);
        calendar.set(Calendar.DAY_OF_MONTH, 9);

        System.out.println(calendar.getTime());

        calendar.add(Calendar.DAY_OF_MONTH, 100);

        System.out.println(calendar.getTime());
    }

3)LocalDate、LocalTime、LocalDateTime

java8中的日期, 显示友好, 数据没问题, 内容不可改变.

@Test
    public void test3() {
        LocalDate date = LocalDate.now();//new LocalDate();
        System.out.println(date);
        int year = date.getYear();
        int month = date.getMonthValue();
        int day = date.getDayOfMonth();
        System.out.println("year = " + year);
        System.out.println("month = " + month);
        System.out.println("day = " + day);

        // 1995, 10, 5
        /*
        LocalDate localDate1 = date.withYear(1995); // 伴随新的年产生新的对象
        LocalDate localDate2 = localDate1.withMonth(10); // 伴随新的月产生新的对象
        LocalDate localDate3 = localDate2.withDayOfMonth(5);
        */
        LocalDate localDate1 = date.withYear(1995).withMonth(10).withDayOfMonth(5);
        System.out.println(localDate1);
        // 推算日期
        LocalDate localDate4 = localDate1.minusDays(-200);

        System.out.println(localDate4);
    }

创建LocalDate对象, 设置为你的生日, 再推算你的百日.

 @Test
    public void exer2() {
        // 1978,6,9
        System.out.println(LocalDate.now().withYear(1978).withMonth(6).withDayOfMonth(9).plusDays(100));
    }

2.数学类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9V6EZcke-1625912216496)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\1625909908523.png)]

package com.atguigu.math;

import org.junit.Test;

import java.math.BigDecimal;
import java.math.BigInteger;

public class MathTest {

    @Test
    public void test2() {
        BigInteger bi1 = new BigInteger("234239423084720834729387429837429834293847239847239847239874239847203982093850285092859028509280958230982095820395820938509285092385098235098235");
        BigInteger bi2 = new BigInteger("134234234234234234234239423084720834729387429837429834293847239847239847239874239847203982093850285092859028509280958230982095820395820938509285092385098235098235");
        BigInteger multiply = bi1.multiply(bi2);
        System.out.println(multiply);

        BigDecimal bd1 = new BigDecimal("293842398472874208348273.239842394823482734829374927349827492873498274928734928374987234234234");
        BigDecimal bd2 = new BigDecimal("293842392342342348472874208348273.23234234234234234234239842394823482734829374927349827492873498274928734928374987234234234");
        BigDecimal add = bd1.add(bd2);
        System.out.println(add);

    }

    @Test
    public void test1() {
        System.out.println(Math.random());
        System.out.println((int)(Math.random() * 100));

        System.out.println(Math.round(9.5));
        System.out.println(Math.round(-9.5));
        System.out.println(Math.round(-9.6));

        System.out.println(0x7FFFFFFFFFFFFFFFL); // 0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111
    }
}

知识点二：集合

1.理解

* 数组 : 解决批量数据的存储问题
* 集合 : 解决批量对象的存储问题, 可以简单把集合看成是一个可变长的Object数组, Object意味着任意对象都可以保存

2.Collection接口

表示的集合只能保存一个一个的对象。特点：无序可重复！！

无序：不按添加顺序保存元素；

可重复：内容相等的元素可以重复放入（个人理解，暂时只会把所传入的实体内容认为是内容相等，因为不会把声明同时两个相同的对象来用）

1）Set子接口

特点：无序不可重复

①HashSet子类：使用使用哈希算法实现的Set集合

重复的标准：两个对象的equals为true，并且两个对象的HashCode相等。

②TreeSet子类：基于二叉树实现的Set集合

③

boolean add(Object obj); 添加一个元素到集合中, 返回真假
*      boolean contains(Object obj); 测试当前集合中是否已经包含了某个元素
*      boolean remove(Object obj); 从当前集合中删除指定的元素, 返回真假
*      int size(); 获取集合中的元素个数

class Student {

    private int id;
    private String name;
    private int grade;
    private double score;

    public Student() {}

    public Student(int id, String name, int grade, double score) {
        this.id = id;
        this.name = name;
        this.grade = grade;
        this.score = score;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                grade == student.grade &&
                Double.compare(student.score, score) == 0 &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, grade, score);
    }
}

 @Test
    public void testSet2() {
        Set set = new HashSet();
        Student s1 = new Student(1, "小明", 3, 50);
        Student s2 = new Student(2, "小丽", 2, 90);
        Student s3 = new Student(1, "小明", 3, 50);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s2); // 完全同一个对象, 即使不重写equals和hashCode也会去重.

        for (Object tmp : set) {
            System.out.println(tmp);
        }
    }

@Test
    public void testSet() {
        Set set = new HashSet(); // 无序不可重复
        set.add("abc");
        set.add("QQQ");
        set.add(new Integer(200));
        set.add(new Student(1, "小明", 5, 80));
        boolean b0 = set.add(100); // set.add(Integer.valueOf(100));
        System.out.println(b0);
        boolean b1 = set.add(200); // 会被去重
        boolean b2 = set.add("abc");
        System.out.println("b1 = " + b1);
        System.out.println("b2 = " + b2);
        System.out.println(set.size());
        System.out.println(set.contains(100)); // 判断是否包含某元素
        System.out.println(set.remove("bbb")); // 删除失败时返回false
        System.out.println(set);
        /*
        for (元素数据类型 临时变量 : 数组或集合) {
            访问 临时变量
        }*/
        System.out.println("**************************");
        for (Object tmp : set) {
            System.out.println(tmp);
        }

    }

1.创建一个集合，保存10个

2.保证十个

解析：

可以使用①set.size() != 10

②！set.add(rand){ 

​	i--

}

③set.add(rand){

​	i++;

}

3.十个不相同

// 创建一个Set集合, 保存10个20以内的随机整数, 遍历
    @Test
    public void exer1() {
        Set set = new HashSet();
        for (int i = 0; i < 10; i++) {
            int rand = (int)(Math.random() * 20);
            set.add(rand);
        }
        for (Object tmp : set) {
            System.out.println(tmp);
        }
    }
    // 创建一个Set集合, 保存10个20以内的随机整数, 保证10个. 遍历
    @Test
    public void exer12() {
        Set set = new HashSet();
        while (set.size() != 10) {
            int rand = (int)(Math.random() * 20);
            set.add(rand);
        }
        for (Object tmp : set) {
            System.out.println(tmp);
        }
    }

    @Test
    public void exer13() {
        Set set = new HashSet();
        for (int i = 0; i < 10; i++) {
            int rand = (int)(Math.random() * 20);
            if (!set.add(rand)) {
                i--;
            }
        }

        for (Object tmp : set) {
            System.out.println(tmp);
        }
    }

    @Test
    public void exer14() {
        Set set = new HashSet();
        for (int i = 0; i < 10;) {
            int rand = (int)(Math.random() * 20);
            if (set.add(rand)) {
                i++;
            }
        }

        for (Object tmp : set) {
            System.out.println(tmp);
        }
    }

2）List子接口

特点：有序可重复

①ArrayList子类：基于数组实现的List集合

②LinkedList子类：基于链表实现的List集合

③

void add(int index, Object ele) 在指定的index下标处插入新元素
*          Object get(int index) 获取指定的index下标处的元素
*          Object remove(int index) 删除指定的index下标处的元素并返回元素
*          Object set(int index, Object ele) 替换指定的index下标处的元素为新ele元素, 被替换的老元素作为返回值返回
*

@Test
    public void testList() {
        List list = new ArrayList(); // 有序可重复
        list.add("ccc");
        list.add(new Integer(500));
        list.add(200);
        list.add(false);
        list.add(new Student(2, "小丽", 2, 50));
        list.add(200);

        System.out.println(list);
        list.add(3, "yyy"); // 插入
        list.set(0, "ZZZ"); // 替换
        System.out.println(list);
        Object o = list.get(0);
        System.out.println(o);
        System.out.println("*************************************");
        // 可以使用经典for, 因为它像数组
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1);
        }
        list.add(2);
        list.add(1);

        list.remove(2); // 优先当成下标来使用
        list.remove(Integer.valueOf(2));

        System.out.println(list);

    }

测试：创建一个List集合, 保存10个20以内的随机整数, 不要重复. 遍历

@Test
    public void exer22() {
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            int rand = (int)(Math.random() * 20);
            if (list.contains(rand)) {
                i--;
                continue;
            }
            list.add(rand);
        }
        // 遍历
        for (Object tmp : list) {
            System.out.println(tmp);
        }
    }

    @Test
    public void exer23() {
        List list = new ArrayList();
        while (list.size() != 10) {
            int rand = (int)(Math.random() * 20);
            if (!list.contains(rand)) {
                list.add(rand);
            }
        }
        // 遍历
        for (Object tmp : list) {
            System.out.println(tmp);
        }
    }

    @Test
    public void exer24() {
        List list = new ArrayList();
        for (int i = 0; i < 10;) {
            int rand = (int)(Math.random() * 20);
            if (!list.contains(rand)) {
                list.add(rand);
                i++;
            }
        }
        // 遍历
        for (Object tmp : list) {
            System.out.println(tmp);
        }
    }

Map接口，表示的集合保存的一对一对的对象

知识点三：二叉树

二叉树作为链表里面的另外一种情况，其和链表差不多的形式，只不过是二叉树是由一个根节点root，以及它的左子树和右子树，而左子树和右子树可能又作为其他子树的根节点。

内存解析了解一下：

package com.atguigu.collection;

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;
}

class Tree {

    TreeNode root;

    public void insert(TreeNode target, TreeNode newNode) {
        if (newNode.value < target.value) { // 向左走
            if (target.left == null) { // 左子为空, 新结点直接插入
                target.left = newNode;
            } else { // 左子非空, 把左子作为根当成子树进一步插入
                insert(target.left, newNode);
            }
        } else { // 向右走
            if (target.right == null) {
                target.right = newNode;
            } else {
                insert(target.right, newNode);
            }
        }
    }

    public void add(int val) {
        TreeNode newNode = new TreeNode();
        newNode.value = val;
        if (root == null) {
            root = newNode;
        } else {
            insert(root, newNode);
        }
    }

    public void view(TreeNode node) {
        if (node == null) {
            return;
        }
        view(node.left);
        System.out.println(node.value);
        view(node.right);
    }

    public void travel() {
        view(root);
    }
}


public class TreeTest {

    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.add(10);
        tree.add(20);
        tree.add(5);
        tree.add(3);
        tree.add(30);
        tree.add(18);
        tree.add(15);
        tree.add(1);

        tree.travel();

    }

}