java学习笔记--常用类

一、Math类：针对数学运算进行操作的类

　　1、常用的方法

　　　　A:绝对值   public static int abs(int a)
　　　　B:向上取整  public static double ceil(double a)
　　　　C:向下取整　public static double floor(double a)
　　　　D:两个数据中的大值 public static int max(int a, int b)
　　　　E:a的b次幂 public static double double pow(double a ,double b)
　　　　F:随机数 public static double random()
　　　　G:四舍五入 public static int round(float a)
　　　　H:正平方根 public static doule sqrt(double)

/**
 *
 * Math类：、
 *       A:绝对值   public static int abs(int a)
　　　　B:向上取整  public static double ceil(double a)
　　　　C:向下取整　public static double floor(double a)
　　　　D:两个数据中的大值 public static int max(int a, int b)
　　　　E:a的b次幂 public static double double pow(double a ,double b)
　　　　F:随机数 public static double random()
　　　　G:四舍五入 public static int round(float a)
　　　　H:正平方根 public static doule sqrt(double)
 */

public class Demo {
    public static void main(String[] args) {
        //取绝对值
        System.out.println(Math.abs(-10));
        //向上取整
        System.out.println(Math.ceil(12.3));//13.0
        System.out.println(Math.ceil(12.66));//13.0
        //向下取整
        System.out.println(Math.floor(12.3));//12.0
        System.out.println(Math.floor(12.66));//12.0
        //求2个数的最大值
        System.out.println(Math.max(3, 4));
        //求2个数的最小值
        System.out.println(Math.min(3, 4));
        //求a的b次幂
        System.out.println(Math.pow(2, 3));//相当于2的3次方
        //产生一个随机随
        System.out.println(Math.random());//随机随范围0.0<=x<1.0
        //四舍五入
        System.out.println(Math.round(3.4));//3
        System.out.println(Math.round(3.5));//4
        //正平方跟
        System.out.println(Math.sqrt(4)); //相当于 Math.pow(4,0.5)
    }
}
/**
 *
 * 需求：请设计一个方法，可以实现获取任意范围内的随机数。
 *
 * 分析：
 *         A:键盘录入两个数据。
 *             int strat;
 *             int end;
 *         B:想办法获取在start到end之间的随机数
 *             我写一个功能实现这个效果，得到一个随机数。(int)
 *         C:输出这个随机数
 */

public class Demo {
    public static void main(String[] args) {
        //键盘输入2个数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入start:");
        int start = sc.nextInt();
        System.out.println("请输入end：");
        int end = sc.nextInt();
        //在start到end之间产生一个随机数
        for(int x =0;x<100;x++){
         int c = random(start,end);
         //输出随机数
         System.out.println(c);}
    }

    //产生随机数的方法
    private static int random(int start, int end) {
        int num = (int) (Math.random()*(end-start+1))+start;
        return num;
    }
}

二、Random类：产生随机数的类

/*
 * Random:产生随机数的类
 *
 * 构造方法：
 *         public Random():没有给种子，用的是默认种子，是当前时间的毫秒值
 *        public Random(long seed):给出指定的种子
 *
 *        给定种子后，每次得到的随机数是相同的。
 *
 * 成员方法：
 *         public int nextInt()：返回的是int范围内的随机数
 *        public int nextInt(int n):返回的是[0,n)范围的内随机数
 */
public class RandomDemo {
    public static void main(String[] args) {
        // 创建对象
        // Random r = new Random();
        Random r = new Random(1111);

        for (int x = 0; x < 10; x++) {
            // int num = r.nextInt();
            int num = r.nextInt(100) + 1;
            System.out.println(num);
        }
    }
}

三、System类：System 类包含一些有用的类字段和方法。它不能被实例化。

　　

public class Demo3_System {

    /**
     * * A:System类的概述
            * System 类包含一些有用的类字段和方法。它不能被实例化。
        * B:成员方法
            * public static void gc()：运行垃圾回收器
            * public static void exit(int status)：终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
            * public static long currentTimeMillis()获取当前时间的毫秒值从1970年1月1日 00：00：00 开始
            * pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)复制数组
        * C:案例演示
            * System类的成员方法使用
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();

        int[] src = {11,22,33,44,55};
        int[] dest = new int[8];
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        System.out.println("--------------------------");
        System.arraycopy(src, 0, dest, 0, src.length);        //将数组内容拷贝

        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

    public static void demo3() {
        long start = System.currentTimeMillis();        //1秒等于1000毫秒
        for(int i = 0; i < 1000; i++) {
            System.out.println("*");
        }
        long end = System.currentTimeMillis();            //获取当前时间的毫秒值

        System.out.println(end - start);
    }

    public static void demo2() {
        System.exit(1);                            //非0状态是异常终止,退出jvm
        System.out.println("11111111111");
    }

    public static void demo1() {
        for(int i = 0; i < 100; i++) {
            new Demo();
            System.gc();                        //运行垃圾回收器,相当于呼喊保洁阿姨
        }
    }

}

class Demo {                                    //在一个源文件中不允许定义两个用public修饰的类

    @Override
    public void finalize() {
        System.out.println("垃圾被清扫了");
    }                            

}

四、BigInteger类：可以让超过Integer范围内的数据进行运算

/**
     ** A:BigInteger的概述
            * 可以让超过Integer范围内的数据进行运算
        * B:构造方法
            * public BigInteger(String val)
        * C:成员方法
            * 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) 取除法运算后的结果（商）和余数
     */
public class Demo {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("5");
        BigInteger bi2 = new BigInteger("2");

        System.out.println(bi1.add(bi2));//bi1+bi2
        System.out.println(bi1.subtract(bi2));//bi1-bi2
        System.out.println(bi1.multiply(bi2));//bi1*bi2
        System.out.println(bi1.divide(bi2));//bi1/bi2
        BigInteger[] arr = bi1.divideAndRemainder(bi2);//取商和余数
        for(int x=0;x<arr.length;x++){
            System.out.println(arr[x]);// 商：2  余数;1
        }

    }

}

五、BigDecimal类：不可变的、任意精度的有符号十进制数,可以解决数据丢失问题

public class Demo5_BigDecimal {

    /**
     * * A:BigDecimal的概述
            * 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
            * 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

            * 不可变的、任意精度的有符号十进制数。
        * B:构造方法
            * public BigDecimal(String val)
        * C:成员方法
            * 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):商，几位小数，如何舍取 */
        * D:案例演示
            * BigDecimal类的构造方法和成员方法使用
        十进制表示1/3
        0.3333333333333333333333333333333333333333
             */
    public static void main(String[] args) {
        //System.out.println(2.0 - 1.1);
        /*BigDecimal bd1 = new BigDecimal(2.0);        //这种方式在开发中不推荐,因为不够精确
        BigDecimal bd2 = new BigDecimal(1.1);

        System.out.println(bd1.subtract(bd2));*/

        /*BigDecimal bd1 = new BigDecimal("2.0");        //通过构造中传入字符串的方式,开发时推荐
        BigDecimal bd2 = new BigDecimal("1.1");

        System.out.println(bd1.subtract(bd2));*/

        BigDecimal bd1 = BigDecimal.valueOf(2.0);    //这种方式在开发中也是推荐的
        BigDecimal bd2 = BigDecimal.valueOf(1.1);

        System.out.println(bd1.subtract(bd2));　　　　　System.out.println("divide:"　　　　　　　　　　　　　　　　　　　　+ bd1.divide(bd2, 3, BigDecimal.ROUND_HALF_UP));
    }

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

　　　　构造方法：
　　　　　　 Date():根据当前的默认毫秒值创建日期对象
　　　　　　 Date(long date)：根据给定的毫秒值创建日期对象

　　　　成员方法：

　　　　　　public long getTime():获取时间，以毫秒为单位
　　　　　　public void setTime(long time):设置时间
　　
　　　　     从Date得到一个毫秒值
　　　　　　　　getTime()
　　　　　　把一个毫秒值转换为Date
　　　　　　　　 构造方法
　　　　　　　　setTime(long time)

/**
 * Date类：表示特定的瞬间，精确到毫秒
      构造方法：
　　　　　　 Date():根据当前的默认毫秒值创建日期对象
　　　　　　 Date(long date)：根据给定的毫秒值创建日期对象
　　　　成员方法：
　　　　　　public long getTime():获取时间，以毫秒为单位
　　　　　　public void setTime(long time):设置时间
　　
　　　　     从Date得到一个毫秒值
　　　　　　　　getTime()
　　　　　　把一个毫秒值转换为Date
　　　　　　　　 构造方法
　　　　　　　　setTime(long time)
*/

public class Demo {
    public static void main(String[] args) {
        /*Date d = new Date();
        System.out.println(d);//输出当前时间 年月日  小时 ：分：秒

        Date d = new Date(1000);//输入的毫秒数
        System.out.println(d);//得到的结果是从1970年1月1日 00：00：00秒后加上给定的毫秒数后的时间
        */
        /*Date d = new Date();
        d.setTime(1000);
        System.out.println(d);//和Date(long time)一样
        */
        Date d = new Date();
        System.out.println(d.getTime());//获取从1970年1月1日到当前时间的毫秒数，相当于System.currentTimeMills()
        System.out.println(System.currentTimeMillis());
    }

}

七、DateForamt类：可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。

　　SimpleDateFormat的构造方法：
　　　　　　　　　　 SimpleDateFormat():默认模式
　　　　　　　　　　 SimpleDateFormat(String pattern):给定的模式

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

　　　　DateForamt类的成员方法
   　　　　　　　　public final String format(Date date)：将一个 Date 格式化为日期/时间字符串。
　　　　　　　　   public Date parse(String source)： 将自定义的时间格式字符串转成 英文格式的时间 时间字符串必须与构造函数中的格式一致

public class Demo {

    public static void main(String[] args) throws ParseException {
            Date d = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
            System.out.println(sdf.format(d));

            String str = "2017/12/33 22:90:20";
            Date d2 = sdf.parse(str);
            System.out.println(d2);

　　　　　　　Date d3 = new Date();            SimpleDateFormat sdf2 = new SimpleDateFormat();//默认格式            System.out.println(sdf2.format(d3));

    }

结果：2017/04/05 17:00:21Tue Jan 02 23:30:20 CST 201817-4-5 下午5:00
时间： 2024-10-11 00:06:12

java学习笔记--常用类的相关文章

Java学习笔记_25_Collections类

25.Collections类: Collections类是一个工具类,用来对集合进行操作,它主要是提供一些排序算法,包括随机排序.反相排序等. Collections类提供了一些静态方法,实现了基于List容器的一些常用算法. Collections的一些方法列表: · void sort(List): 对List内的元素进行排序. · void shuffle(List): 对List内的元素随机排序. · void reverse(List): 对List内的元素进行逆序排列. · voi

Java学习笔记——File类之文件管理和读写操作、下载图片

Java学习笔记——File类之文件管理和读写操作.下载图片 File类的总结: 1.文件和文件夹的创建 2.文件的读取 3.文件的写入 4.文件的复制(字符流.字节流.处理流) 5.以图片地址下载图片 文件和文件夹 相关函数 (boolean) mkdir() 创建此抽象路径名指定的目录  (boolean) mkdirs() 创建此抽象路径名指定的目录,包括所有必需但不存在的父目录. (boolean) delete() 删除此抽象路径名表示的文件或目录 (boolean) createNe

Java学习笔记_19_String类

19.String类: 1>String类的构造方法: · 利用字符串构造一个字符串对象: String str = "HelloWorld": · 无参构造一个字符串对象: String str = new String(); · 传递参数生成一个字符串对象: String str = new String("HelloWorld"); · 由字符数组生成一个字符串对象: String str = new String(char s[ ]); · 由字符数组

Java学习笔记—复用类

复用代码是Java众多引人注目的功能之一. 一般而言,实现代码重用java提供了两种方式:组合以及继承. 组合:新的类由现有类的对象所组成.(复用现有代码的功能,而非它的形式) 继承:按照现有类的类型组建新类.(在不改变现有类的基础上,复用现有类的形式并在其中添加新代码). 组合 class Engine{ public void start(){} public void stop(){} } class Door{ public void open(){} public void close

Java学习笔记1——类和对象

面向对象 对象:万物皆对象 面向对象 类:模子,属性+方法,类是对象的类型,是具有相同属性和方法的一组对象的集合 对象属性:对象拥有的各种特征,"对象有什么" 对象方法:对象执行的操作,"对象能干什么" 类与对象的关系/区别:类是抽象的,仅仅是模版:对象是看得到,摸得着的具体实体.例如:'手机'类,对象为iPhone6,Lumia920 Java中的类 定义类:Java程序都以类class为组织单元 创建一个对象 //1.定义一个类 public class Tel

Java学习笔记-3.类与对象

一.面向对象程序设计 1.概念:   OOA:面向对象的分析,将现实世界进行抽象的分析 OOD:面向对象的设计 OOP:面向对象的程序 2.面向对象的特点: (1)封装性:一是把对象的全部状态和行为结合在一起,形成一个不可分割的整体,对象的私有属性只能由对象的行为来修改和读取 二是尽可能隐藏对象的内部细节,与外界的联系只能够通过外部接口来实现 (2)继承性:特殊类的对象拥有其一般类的属性和行为 (3)多态性:指同一个实体同时具有多种形式,体现在不同的对象可以根据相同的消息产生各自不同的动作 二.

java学习笔记——String类

一.概述 ·字符串是一个特殊的对象 ·字符串一旦初始化就不可以被改变 ·String str = "abc"; ·String str1 = new String("abc"); 有什么区别? package com.java.study.StringDemo; public class StringDemo { public static void main(String[] args) { String s1 = "abc"; //s1是一个

JAVA学习笔记-Date类

在标准Java类库中包含一个Date类.它的对象表示一个特定的瞬间,精确到毫秒. Java中时间的表示说白了也是数字,是从:标准纪元1970.1.1 0点开始到某个时刻的毫秒数,类型是long. jdk:  //返回一个当前的时间 Date d = new Date(); long t = System.currentTimeMillis();//返回一个当前的时间 System.out.println(t);

[Java学习笔记]JFrame类的pack()与validate()方法的区别（待补充）

每次写图形化程序的时候,只有手动调整JFrame框架大小才能显示出里面的内容.用了validate()不行,而pack()可以解决这个问题. pack()//是自动适应大小.在写程序的时候,如果定义了preferred size,则会按照首选大小画框架大小:或者按照容器内组件的大小来自适应大小.vailate()//是重新调整大小,前提是已经设置大小(已经调用了setSize()),且大小发生变化.如最大最小化窗口. 待补充...