BigDecimal类

最新推荐文章于 2023-08-10 00:00:49 发布

cherry...a

最新推荐文章于 2023-08-10 00:00:49 发布

阅读量466

点赞数

本文链接：https://blog.csdn.net/qq_46466568/article/details/107792570

版权

BigDecimal类

概述：float类型和double很容易丢失精度，为了能精确地表示计算浮点数，java提供了BigDecimal

构造方法：public BigDecimal(String val)
成员方法：
public BigDecimal add(BigDecimal augend)//加
public BigDecimal subtract(BigDecimal subtrahend)//减
public BigDecimal multiply(BigDecimal multiplicand)//乘
public BigDecimal divide(BigDecimal divisor)//除法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位
// roundingMode 取舍模式 比如四舍五入

package com.itheima.demo8;

import java.math.BigDecimal;

public class test1 {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("11");
        BigDecimal b2 = new BigDecimal("300");
        BigDecimal d = b2.divide(b1,3,2);
        System.out.println(d);


    }
}

Date类

概述：类Date表示特定的瞬间，精确到毫秒

构造方法：
public Date()
public Date(long date)  //把一个long类型的毫秒值转换成一个日期对象
public long getTime():	获取一个日期对象毫秒值
	
public void setTime(long time):	给一个日期对象设置上指定的毫秒值 例：date.setTime(1000 * 60 * 60) ;

package com.itheima.demo8;

import java.util.Date;

public class test3 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        //Sun Aug 02 16:48:28 CST 2020
        // 给 1970 年 1 月 1 日 00:00:00 计算机元年加上相应的时间量。
        Date date1 = new Date(1000 * 60 * 60);
        System.out.println(date1);//Thu Jan 01 09:00:00 CST 1970


    }
}

Date ---- long 的转换

调用getTime方法

long — Date 的转换

可以使用构造方法
setTime(long time)

package com.itheima.demo8;

import java.util.Date;

public class test4 {
    public static void main(String[] args) {
        Date date = new Date();
        //Date ---- long 的转换
        long time = date.getTime();
        System.out.println(time);
//long --- Date 的转换

        date.setTime(10000);
        System.out.println(date);

    }
}

SimpleDateFormat类实现日期和字符串的相互转换

SimpleDateFormat:可以把一个日期对象格式化成一个文本(字符串)，也可以把一个日期对象解析成一个日期对象

构造方法：
public SimpleDateFormat()：使用默认的模式来创建一个SimpleDateFOrmat对象
public SimpleDateFormat(String pattern):使用指定的模式（规则比yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象

规则的定义

年	y
月	M
天	d
时	H
分	m
秒	s

成员方法：
public String format(Data date):把一个日期对象格式化成一个字符串
public Data Parse(String dateStr):把一个日期字符串解析成一个日期对象，注意要以指定格式解析

package com.itheima.demo8;


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

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

        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat();//空参构造，按照默认格式进行转换。
//format(date)  把日期格式化成一个指定字符串
        String s = sd.format(date);
        System.out.println(s);
        SimpleDateFormat sd1 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//有参构造，根据自己指定的模式进行转换
        String s1 = sd1.format(date);
        System.out.println(s1);

    }
}

package com.itheima.demo8;

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

//	需求：算一下你来到这个世界多少天?
//分析:键盘录入一个生日
//把这个日期字符串对象解析成一个日期对象
//获取日期对象的毫秒值
//获取当前系统的毫秒值
//获取差值
//把差值转换成对应的天数   差值/1000/60/60/24;
package com.itheima.demo8;

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

//	需求：算一下你来到这个世界多少天?
//分析:
public class test6 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的生日");
        String s = sc.nextLine();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy/MM/dd");
        Date p = sd.parse(s);
        long time = p.getTime();
        long now = System.currentTimeMillis();
        long l = (now - time) / 1000 / 60 / 60 / 24;
        System.out.println("您已经来到世界上"+l+"天了");

    }
}

calendar类

calendar类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象。它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

成员方法
public static Calendar getInstance()使用默认时区和语言环境获得一个日历对象
public int get(int field)	获得给定日历字段对应的值 field通过Calendar提供的字段来拿

package com.itheima.demo8;

import java.util.Calendar;

public class test7 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();
       // System.out.println(instance);
        int year = instance.get(Calendar.YEAR);
        //System.out.println(year);
        int month = instance.get(Calendar.MONTH);
        int day = instance.get(Calendar.DAY_OF_MONTH);
        int hour = instance.get(Calendar.HOUR);
        int second = instance.get(Calendar.SECOND);
        int minute = instance.get(Calendar.MINUTE);
        System.out.println(year+"年"+month+"月"+day+"日 "+hour+"时"+second+"分"+minute+"秒");



    }
}

calender类的add()和set()方法

成员方法
public void add(int field,int amount)		根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year,int month,int date)	设置日历时间 年月日

package com.itheima.demo8;

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

//需求：键盘录入任意一个年份，获取任意一年的二月有多少天
       
public class test8 {
    public static void main(String[] args) {
        //键盘录入一个年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个年份");
        //获取键盘录入的数据
        int year = sc.nextInt();
        //创建calender对象
        Calendar instance = Calendar.getInstance();
        //把这个calendar的时间设置为a中录入的年的3月1号
        instance.set(year,2,1);
        //向前推算一天
        instance.add(Calendar.DAY_OF_MONTH,-1);
        //获取月中的天
        int day = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
 if(year%4==0&&year%100!=0||year%400==0){
            System.out.println(year+"年是闰年");
        }


    }
}

BigInterger可以让超过long范围内的数据进行运算

构造方法
public BigInteger(String val)
成员方法
public BigInteger add(BigInteger val)//+
public BigInteger subtract(BigInteger val)//-
public BigInteger multiply(BigInteger val)//*
public BigInteger divide(BigInteger val)//除
public BigInteger[] divideAndRemainder(BigInteger val)//取除数和余数

package com.itheima.demo8;

import java.math.BigInteger;

public class test9 {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("300");
        BigInteger bi2 = new BigInteger("20");
        BigInteger add = bi1.add(bi2);
        BigInteger subtract = bi1.subtract(bi2);
        BigInteger multiply = bi1.multiply(bi2);
        BigInteger divide = bi1.divide(bi2);
        BigInteger[] bigIntegers = bi1.divideAndRemainder(bi2);
        System.out.println(add);
        System.out.println(subtract);
        System.out.println(multiply);
        System.out.println(divide);
        System.out.println(bigIntegers);


    }
}

对象数组

package com.itheima.demo9;

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

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

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", 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;
    }
}
package com.itheima.demo9;
//我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
public class test {
    public static void main(String[] args) {
        student s1 = new student("cherry", 22);
        student s2 = new student("布莱妮", 30);
        student s3 = new student("Lisa", 25);
       student[] arr = new student[]{s1,s2,s3};
        for (int i = 0; i < arr.length; i++) {
            student student = arr[i];
            System.out.println(student);

        }



    }
}
//对象数组即可以存储基本数据类型也可以存储引用数据类型
//数组容器的不好之处：就是对容器的元素，进行操作时，不够方便，比如增删数组中的元素，不太方便，因为数组一旦定义，长度就不能改变

集合框架

面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，java提供了集合类。

数组和集合的区别

数组的长度一旦定义了就是固定的，而集合的长度可变。
数组既可以存储基本数据类型也可以存储引用数据类型；而集合只能存储引用数据类型。
数组只能存储同种数据类型的元素，而集合可以存储不同类型的元素。

Collection集合

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection
的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

添加功能：
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素  (给一个集合添加进另一个集合中的所有元素)
删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 如果没有交集元素 则删除失败 返回false
判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素	
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
比如：1，2，3 containsAll 12=true   1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
获取功能
Iterator<E> iterator()
长度功能
int size():元素的个数
交集功能
例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
把集合转换为数组
Object[] toArray()

package com.itheima.demo9;

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

public class test1 {
    public static void main(String[] args) {
        //定义一个集合
        Collection collection = new ArrayList();
        //往集合中添加元素

        collection.add("Lisa");
        collection.add("Rose");
        collection.add("Jennie");
        collection.add("Jisoo");
        //删除元素
        collection.remove("Lisa");
        //清除集合中的所有元素
       // collection.clear();
        //判断集合中是否包含指定元素
        boolean s = collection.contains("lias");
        System.out.println(s);
        //判断集合是否为空
        boolean s2 = collection.isEmpty();
        System.out.println(s2);
        //获取集合长度
        int i = collection.size();
        System.out.println(i);

        System.out.println(collection);

    }
}

package com.itheima.demo9;

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

public class test2 {
    public static void main(String[] args) {
        Collection collection1 = new ArrayList();
        //往集合中添加元素

        collection1.add("Lisa");
        collection1.add("Rose");
        collection1.add("Jennie");
        collection1.add("Jisoo");


      Collection collection2 = new ArrayList();
      collection2.add("杨幂");
        collection2.add("林允儿");
      collection2.add("cherry");
        collection2.add("Lisa");
//判断两个集合中的元素是否归并到了一个里面
        boolean b = collection1.addAll(collection2);
        System.out.println(b);
        //移除一个集合的交集元素， 删除的元素是两个集合的交集元素
        boolean b1 = collection1.removeAll(collection2);
        System.out.println(b1);
        System.out.println(collection1);//[Rose, Jennie, Jisoo]
        System.out.println(collection2);//[杨幂, 林允儿, cherry, Lisa]
        //判断一个集合中是否包含另一个集合中的所有元素，这个集合 包含 另一个集合中所有的元素才算包含 才返回true
        boolean b2 = collection1.containsAll(collection2);
        System.out.println(b2);

        boolean b3 = collection1.retainAll(collection2);
        System.out.println(b3);
        //A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 ,获取两个集合的交集元素(交集：两个集合都有的元素)
        System.out.println(collection1);
        System.out.println(collection2);

    }
}

集合中定义数组定义成object类

package com.itheima.demo9;

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

public class test3 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        //往集合中添加元素

        collection.add("Lisa");
        collection.add("Rose");
        collection.add("Jennie");
        collection.add("Jisoo");
        Iterator it = collection.iterator();//定义一个迭代器
        //  返回在此 collection 的元素上进行迭代的迭代器。
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }
    }
}

Object object = collection.toArray() //把集合转换成数组。

//将集合元素转换成数组元素
Object[] objects = collection.toArray();

List

概述：元素有序，并且每一个元素都存在一个索引，元素可以重复，

List集合的特有功能概述
	void add(int index,E element):	在指定索引处添加元素
	E remove(int index):移除指定索引处的元素  返回的是移除的元素
	E get(int index):获取指定索引处的元素
	E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
	int indexOf(Object o) 
          返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。 
    int lastIndexOf(Object o) 
          返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

package com.itheima.demo9;

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

public class test6 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("lisa");
        list.add("cherry");
        list.add("sh");
        list.add("lisa");
        list.add(0,"hahah");//在指定索引处添加元素
        list.remove(1);//移除指定索引处的元素  返回的是移除的元素
        Object o = list.get(0);//获取指定索引处的元素
        System.out.println(o);
        list.set(0,"java");//更改指定索引处的元素 返回的而是被替换的元素
        int i = list.lastIndexOf("lisa");// 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
        System.out.println(i);
 Object obj = list.get(list.size() - 1);//获取最后一个位置处的元素
        System.out.println(list);
    }
}

ListIterator

ListIterator 继承自Iterator  可以使用Iterator中的方法
ListIterator的特有功能
boolean hasPrevious():			是否存在前一个元素
E previous():					返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历  这样指针才能移到最后
如果直接反向遍历是没有效果的  因为指针默认位置就在最前面 他前面没有元素

package com.itheima.demo9;

import java.util.ArrayList;
//案例演示
       // 需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，
        //如果有，我就添加一个 "javaee" 元素，请写代码实现。*/
public class test5 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add("word");
        list.add("aa");
        list.add("bb");
        if (list.contains("word")) {
            list.add("javaee");
            System.out.println(list);
        }
    }
}

并发修改异常

package com.itheima.demo9;
import java.util.ArrayList;
import java.util.ListIterator;

public class test7 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add("word");
        list.add("aa");
        list.add("bb");
        //ConcurrentModificationException
        ListIterator iterator =list.listIterator();

        while(iterator.hasNext()){
            Object next = iterator.next();
            if(next.equals("word")){
                iterator.add("javaee");
                System.out.println(list);
            }

        }
    }
}
//ConcurrentModificationException：出现这个的原因：迭代依赖于集合，当我们往集合中添加好了元素之后获取迭代器，那么迭代器就已经知道了集合的元素个数，在遍历的时候又给集合中添加元素，用的是集合的方法，那么迭代器就会报错，，我们用listiterator迭代器遍历，用迭代器自带的元素添加元素，就不会报错了

桟和队列

数据结构其实就是存储数据的格式。

分类：桟，队列，数组，链表。树，哈希表

桟的特点：先进后出

堆的特点：先进先出

数组和链表

数组的特点：查询快，增删慢

链表的特点：查询慢，增删块。

List的三个子类的特点

ArrayList:
		底层数据结构是数组，查询快，增删慢。
		线程不安全，效率高。
Vector:
		底层数据结构是数组，查询快，增删慢。
		线程安全，效率低。
LinkedList:
		底层数据结构是链表，查询慢，增删快。
		线程不安全，效率高。

cherry...a

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
BigDecimal类

BigDecimal类概述：float类型和double很容易丢失精度，为了能精确地表示计算浮点数，java提供了BigDecimal构造方法：public BigDecimal(String val)成员方法：public BigDecimal add(BigDecimal augend)//加public BigDecimal subtract(BigDecimal subtrahend)//减public BigDecimal multiply(BigDecimal multiplican
复制链接

扫一扫