JavaSE进阶-常用类

1、String类。

1.1、对String在内存存储方面的理解：

• 字符串一旦创建不可变。
• 双引号括起来的字符串存储在字符串常量池中。
• 字符串的比较必须使用equals方法。
• String已经重写了toString()和equals()方法。

String s1 = "abc";
//s1里面存储的不是"abc"本身
//s1里面保存的是"abc"字符串对象的内存地址

注意：垃圾回收器不会释放常量

例：

package com.bjpowermode.javase.String;

public class StringTest02 {
    public static void main(String[] args) {
        String s1 = "hello";
        //"hello"是存储在方法区的字符串常量池当中
        //所以这个"hello"不会新建
        String s2 = "hello";
        System.out.println(s1 == s2);//结果是true
        //== 双等号比较的是变量中保存的内存地址

        String x = new String("xyz");
        String y = new String("xyz");

        System.out.println(x == y);//结果为 false
        //字符串对象之间的比较不能用 双等号
        //应该调用String类的equals()方法  String类已经重写过了equals方法，可以直接调用
        //创建的String对象会在堆区中开辟空间，对象内存储的是一个指向字符串常量池的新的内存地址

        String k = new String("testString");
        //"testString"这个字符串可以调用equals方法
        //因为"testString"是一个String字符串对象。只要是对象都能调用方法
        System.out.println("testString".equals(k));//建议使用这种方法，可以避免空指针异常
        System.out.println(k.equals("testString"));//存在空指针异常的风险。不建议这样写
    }
}

分析以下程序，一共创建了几个对象

public class StringTest03{
    public static void main(String[] args){
        /*
        一共3个对象：
        	方法区字符常量池中有1个:"hello"
        	堆内存当中有两个String对象
        	一共3个对象
        */
        String s1 = new String("hello");
        String s2 = new String("hello");
    }
}

1.2、String的构造方法。

	//创建字符串对象最常用的一种方式
	String s = "abc";

	String s = new String("abc");

	String s = new String(byte数组);

	String s = new String(byte数组, 起始下标, 长度);

	String s = new String(char数组);

	String s = new String(char数组, 起始下标, 长度);

1.3、String类常用的21个方法。

1.charAt方法

char charAt(int index)

返回指定下标的char值

//返回指定下标的char值
//char charAt(int index) 
    char c = "中国人".charAt(1);
	System.out.println(c); //输出结果  国

2.compareTo方法

int compareTo(Strinig anotherString)

比较前后两个字符串大小

//比较前后两个字符串大小
//字符串之间比较大小不能直接使用 > < == 比较 ，必须用compareTo方法

int result = "abc".compareTo("abc");
System.out.println(result);   //结果 0   前后一致

int result2 = "abcd".compareTo("abce");
System.out.println(result2);  //结果 -1 前小后大

int result3 = "abce".compareTo("abcd");
System.out.println(result3);  //结果 1  前大后小

int result4 = "xyz".compareTo("yzx");
System.out.println(result4);  //结果 -1   
//拿着字符串第一个字母和后面字符串第一个字母比较。能分出大小就停止比较。
//如果第一个字符没有比较出大小，则开始从第二个字符比较，直到比出结果

3.contains方法

boolean contains(CharSequence s)

判断字符串"abc" 是否包含 "a"字符串

System.out.println("HelloWorld.java".contains(".java"));
//判断字符串 HelloWorld.java字符串 中是否包含.java 字符串
//结果为true

System.out.println("http://www.baidu.com".contains("https://"));
//解过为false

4.endsWith方法

boolean endWith(String suffix)

判断当前字符串是否以某个字符串结尾

//判断当前字符串是否以某个字符串结尾
//boolean endWith(String suffix)
System.out.println("test.txt".endsWith(".java"));  //false
System.out.println("test.txt".endsWith(".txt"));  //true
System.out.println("avscvxvfweawe".endsWith("we")) //true

5.equals方法

boolean equals(Object anObject)

比较两个字符串必须使用equals方法，不能使用" == "

String类中的equals方法比较的是变量的内容

//比较两个字符串必须使用equals方法，不能使用" == "

6.equalsIgnoreCase方法

boolean equalsIgnoreCase(String anotherString)

判断两个字符串是否相等，并且同时忽略大小写

//判断两个字符串是否相等，并且同时忽略大小写
System.out.println("ABc.equalsIgnoreCase("abc")"); // true 

7.getBytes方法

byte[] getBytes()

将字符串对象转换成字节数组

byte[] bytes = "abcdef".getBytes();
for(int i = 0; i < bytes.length; i++){
    System.out.println(bytes[i]);
}

8.indexOf方法

int indexOf(String str)

判断某个子字符串在当前字符串中第一次出现处的索引(下标)

System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java")); 
//结果为6

9. isEmpty方法

boolean isEmpty()

判断某个字符串是否为空字符串

String s = "";
System.out.println(s.isEmpty());
//true

10.length方法

int length()

System.out.println("abc".length()); //3

面试题：判断数组长度和判断字符串长度不一样

判断数组长度是length属性，判断字符串长度是length()方法。

11.lastIndexOf方法

int lastIndexOf(String str)

判断某个字符串在当前字符串中最后一次出现的索引(下标)

System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".lastIndexOf("java"));
//28

12.replace方法

String replace(CharSequence target, CharSequence replacement)

String的父接口就是: CharSequence

String newString = "http://www.baidu.com".replace("http://","https://");
System.out.println(newString);
//https://www.baidu.com

13.split方法

String[] split(String regex)

拆分字符串

 String[] ymd = "1980-10-11".split("-");
        //"1980-10-11"以"."分隔符进行拆分
        for(int i = 0; i < ymd.length; i++){
            System.out.println(ymd[i]);
            //输出结果
            //1980
            //10
            //11
            
String[] ymd2 = "abcd/efg/hijklmn/opq".split("/");
        for(int i = 0; i < ymd2.length; i++){
            System.out.println(ymd2[i]);
        }

14.startWith方法

boolean startWith(String prefix)

判断某个字符串是否以某个字符串开始。

        System.out.println("http://baidu.com".startsWith("http://")); //true
        System.out.println("http://baidu.com".startsWith("https://")); //false

15.substring方法1

String substring(int beginIndex) 参数是其实下标

截取字符串

 System.out.println("http://baidu.com".substring(7));
//输出结果 baidu.com

16.substring方法2

String substring(int beginIndex,int endIndex)

截取字符串(起始下标,结束下标)

beginIndex起始位置(包括)

endIndex结束位置(不包括)

System.out.println("http://baidu.com".substring(7,10));
//输出结果 bai

17.toCharArray方法

char[] toCharArray()

将字符串转换成char数组

char[] chars = "我是中国人".toCharArray();
        for(int i = 0; i < chars.length; i++ ){
            System.out.println(chars[i]);
        }
//输出结果
//我
//是
//中
//国
//人

18.toLowerCase方法

String toLowerCase()

转换成小写

 System.out.println("ABCDefGhI".toLowerCase());
//abcdefghi

19.toUpperCase方法

String toUpperCase()

转化成大写

 System.out.println("AbcdEfghi".toUpperCase());
//ABCDEFGHI

20.trim方法

String trim()

去除字符串前后空白

  System.out.println("              甘雨我 老婆       ".trim());
//甘雨我 老婆

21.valueOf方法

String中只有一个方法是静态的，不需要new对象

该方法叫 valueOf

将 非字符串 转换成 字符串

String s1 = String.valueOf(true);
System.out.println(s1); 
// true  输出结果是字符串
String s2 = String.valueOf(100);
System.out.println(s2); 
// 100   输出结果是字符串
String s3 = String.valueOf(3.14);
System.out.println(s3); 
// 3.14  输出结果是字符串

//当valueOf方法的参数是一个对象的时候，会自动调用toString方法

//****************************
//valueOf源码
  public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

//************************

String s4 = String.valueOf(new Customer());
System.out.println(s4);
//com.bjpowermode.javase.String.Customer@1540e19d
class Customer{
    
}

System.out.println() 这个方法在输出任何数据的时候都是先转换成字符串，再输出
控制台上的数据都是字符串

2、StringBuffer和StringBuilder

1.StringBuffer

Java中的字符串是不可变的，每次拼接都会产生新字符串。

这样会占用大量的方法区内存。造成内存空间的浪费。

String s = "abc";
s += "Hello";
//以上代码导致在方法区中创建了三个字符串对象
// "abc"   "Hello"  "abcHello"

需要进行大量字符串的拼接操作，建议使用JDK中自带的：

java.lang.StringBuffer
java.lang.StringBUilder

StringBuffer底层实际上是一个byte[]数组。

往StringBuffer中放字符串，实际上是放到byte数组当中了。

StringBuffer的初始化容量是16.

public class stringBufferTest01 {
    public static void main(String[] args) {
        //创建一个初始化容量为16个byte[] 数组（字符串缓冲区）
        StringBuffer s = new StringBuffer();
//**************************************************************       
        //如何优化StringBuffer的性能
        //在创建StringBuffer的时候尽可能的给定一个初始化容量
        //最好减少底层数组的扩容次数。预估计一下，给一个大一初始化容量
        //给一个合适的初始化容量，可以提高程序效率
//**************************************************************  
        //拼接字符串，以后拼接字符串统一调用 append()方法
        //append是追加的意思
        //append方法底层在进行追加的时候，如果byte数组满了，会自动扩容。
        s.append("a");
        s.append("b");
        s.append("c");
        s.append(3.14);
        s.append(true);
        s.append(100L);

        System.out.println(s.toString()); //String类已经重写了toString方法

        //指定初始化容量的StringBuffer对象（字符串缓冲区）
        StringBuffer s1 = new StringBuffer(100);
        
        s1.append("Hello");
        s1.append("甘雨");
        s1.append("forever");
        s1.append("love");
        s1.append("me");
        System.out.println(s1);
    }
}

2.StringBuilder

public class stringBuilderTest01 {


    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();

        s.append("Hello");
        s.append("甘雨");
        s.append("forever");
        s.append("love");
        s.append("me");

        System.out.println(s);
    }
}

StringBuilder也能够实现大量字符串拼接

语法和StringBuffer基本一致

3.StringBuffer 和 StringBuilder 的区别

StringBuffer中的方法都有：synchronized关键字修饰。表示StringBuffer在多线程环境下运行是安全的。

StringBuilder中的方法都没有：没有synchronized关键字修饰。表示StringBuilder在多线程环境下运行是不安全的。

StringBuffer是线程安全的。

StringBuilder是非线程安全的。

3、基本数据类型对应的包装类

1.java中为8种基本数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object。

2.基本类型的包装类主要提供了更多的实用操作，这样更容易处理基本类型。

3.所有的包装类都是 final 的，所以不能创建其子类，包装类都是不可变对象

public class integerTest01 {
    public static void main(String[] args) {
        //有一个需求：调用doSome()方法的时候需要传一个数字进去。
        //但是数组属于基本数据类型，而doSome()方法参数的类型是object.
        //doSome()方法无法接受基本数据类型的数字，因此可以传一个数字对应的包装类进去。

        //把100这个数字经过构造方法包装对象
        MyInt myInt = new MyInt(100);
        //doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类型。
        doSome(myInt);
    }


    public static void doSome(Object obj) {
        System.out.println(obj);
    }
}

package com.bjpowermode.javase.integer;

public class MyInt {
    int value;

    public MyInt(){

    }

    public MyInt(int value){
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

1.八种基本数据类型对应的包装类

基本数据类型 包装类型

byte Byte（父类都是Number）

short Short

int Integer

long Long

float Float

double Double

boolean Boolean

char Character

以Integer类型为主，其他类型照葫芦画瓢就行

2.八种包装类当中其中6个都是数字对应的包装类，他们的父类都是Number

Number是一个抽象类，无法实例化对象。

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

        //123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换。
        //基本数据类型 ->(转换) ->引用数据类型  (装箱)
        Integer i = new Integer(123);

        //将引用数据类型->(转换)->基本数据类型  
        float f = i.floatValue();
        System.out.println(f);//123.0

        //将引用数据类型->(转换)->基本数据类型  （拆箱）
        int result = i.intValue();
        System.out.println(result);//123
    }
}

3.Integer

Integer的构造方法有两个：

Integer(int)

Integer(String)

package com.bjpowermode.javase.integer;

public class integerTest03 {
    public static void main(String[] args) {
       //java9之后不建议使用这个构造方法，出现横线表示已经过时了
       //将数字100转换成Integer包装类型 (int---> Integer)
        Integer x = new Integer(100);
        System.out.println(x);

        //将String类型的数字，转换成Integer包装类型 (String ---> Integer)
        Integer y = new Integer("123");
        System.out.println(y);
        
        Double d = new Double(150.5);
        System.out.println(d);

        Double e = new Double("3.14");
        System.out.println(e);
    }
}

1.通过常量获取最大最小值

包装类中有 MAX_VALUE属性和 MIN_VALUE属性

可以输出最大值和最小值

2.自动拆箱和自动装箱

public static void main(String[] args){
	//手动装箱
    Integer x = new Integer(1000);
    
    //手动拆箱
    int y = x.intValue();
    System.out.println(y);
}

jdk1.5之后支持自动拆箱和自动装箱

自动装箱：基本数据类型自动转换成包装类

自动拆箱：包装类自动转换成基本数据类型

有了自动拆箱之后，Number类的方法就用不着了

package com.bjpowermode.javase.integer;

public class integerTest05 {
    public static void main(String[] args){
        //自动装箱
        //x是包装类型
        //int类型 -自动转换为->Integer
        Integer x = 100;

        //自动拆箱
        //x是包装类型
        //y是基本数据类型
        //Integer -自动转换为-> int 类型
        int y = x;

        //z是一个引用，z是一个变量,z还是保存了一个对象的内存地址
        Integer z = 1000;
        //等同于 Integer z = new Integer(1000);
        //+号两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱，将z转换成基本数据类型
        System.out.println(z + 1);

        Integer a = 1000;
        //Integer a = new Integer(1000); a是一个引用，保存内存地址指向对象
        Integer b = 1000;
        //Integer b = new Integer(1000); b是一个引用，保存内存地址指向对象
        System.out.println(a == b);
        //==比较的是对象的内存地址，a和b两个引用中保存的对象内存地址不同
        //== 这个运算符不会触发自动拆箱机制（只有+ _ * / 等运算的时候才会）
        System.out.println(a.equals(b));
        //false
    }
}

package com.bjpowermode.javase.integer;

import java.sql.SQLOutput;

public class integerTest06 {
    public static void main(String[] args) {
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);//false

        /*
        * java中为了提高程序的执行效率，将[-128到127]之间的所有的包装对象提前创建好，
        * 放到一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据，不需要再new了，
        * 直接从整数型常量池当中取出来。
        * */

        //原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。
        Integer x = 127;
        Integer y = 127;
        System.out.println(x == y);//true
    }
}

3.parseInt方法(重要)

static int parseInt(String s)
//作用  静态方法，传参String ,返回int类型数据

int retValue = Integer.parseInt("123");  //String ---转换---->int
System.out.println(retValue + 100);

Double类型 有parseDouble方法

Float类型 有parseFloat方法

依次类推

4.Integer常用方法

5.Integer\String\Int之间的类型转换

package com.bjpowermode.javase.integer;

public class integerTest07 {
    public static void main(String[] args) {
        
        //String ---> int
       int i1 = Integer.parseInt("100");
        System.out.println(i1);

        //int -----> String
        String s1 = i1 +""; //"100"字符串
        System.out.println(s1 + 1); //"1001"

        //int -----> Integer
        //自动装箱
        Integer x = 1000;

        //Integer -----> int
        //自动拆箱
        int y = x;

        //String -----> Integer
        Integer i2 = Integer.valueOf("123");

        //Integer ------> String
        String s2 = String.valueOf(i2);
    }
}

4.java日期处理

1.获取当前系统时间

获取当前系统时间（精确到毫秒的系统当前时间）

该功能需要用到java.util.Date类包

步骤

1.先导包 import java.util.Date;

2.直接调用Date类的无参数构造方法即可

package com.bjpowermode.javase.Date;
import java.util.Date;
public class DateTest01 {
    public static void main(String[] args) {
        Date nowTime = new Date();
        System.out.println(nowTime);
        //Sun Oct 31 13:51:14 CST 2021
        //java.util.Date类的toString()方法已经重写了。
        //输出的应是一个日期字符串
    }

}

2.日期格式化

将日期类型Date，按照指定的格式进行转换：Date--转换成具有一定格式的日期字符串---> String

使用SimpleDateFormat类

SimpleDateFormat是java.text包下的，专门负责日期格式化的。

SimpleDateFormat类 的有参构造方法

SimpleDateFormat(String pattern) 
          用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

package com.bjpowermode.javase.Date;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest01 {
    public static void main(String[] args) {
        Date nowTime = new Date();
        System.out.println(nowTime);


        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //调用SimpleDateFormat类中的format方法,传入Date类型参数 返回一个String类型的日期
        String nowTime1 = sdf.format(nowTime);
        System.out.println(nowTime1);
    }

}

3.String类型时间转换成Date类型

package com.bjpowermode.javase.Date;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest01 {
    public static void main(String[] args) throws Exception {
        Date nowTime = new Date();
        System.out.println(nowTime);


        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //调用SimpleDateFormat类中的format方法  返回一个String类型的日期
        String nowTime1 = sdf.format(nowTime);
        System.out.println(nowTime1);

        //现有一个日期字符串String,需要转换成Date类型
        //String ----> Date
        String time = "2008-08-08 08:08:08 888";
        //SimpleDateFormat sdf2 = new SimpleDateFormat("格式不能乱写，要和日期字符串格式相同")
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss SSS");
        Date dateTime = sdf2.parse(time); //注意这里使用parse方法要抛出异常
        System.out.println(dateTime);
    }

}

4.日期模式字母

字母	日期或时间元素	表示	示例
G	Era 标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

5.format方法

将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。

public StringBuffer format(Date date,
                           StringBuffer toAppendTo,
                           FieldPosition pos)

6.统计方法执行所耗费时长

获取自1970年1月1日00:00:00 000 到当前系统时间的总毫秒数。

调用System包中的currentTimeMillis()方法 最好用long类型

1秒 = 1000毫秒

package com.bjpowermode.javase.Date;

public class DateTest02 {
    public static void main(String[] args) {
        long nowTimeMillis = System.currentTimeMillis();
        System.out.println(nowTimeMillis);
    }
}

需求：统计一个方法执行所耗费的时长

package com.bjpowermode.javase.Date;

public class DateTest02 {
    public static void main(String[] args) {
        /*
        long nowTimeMillis = System.currentTimeMillis();
        System.out.println(nowTimeMillis);
        */

        //记录开始时间
        long begin = System.currentTimeMillis();;
        DateTest02.demo();
        //记录结束时间
        long end = System.currentTimeMillis();;
        System.out.println("耗费时长:" + (end - begin) + "毫秒");
    }
    public static void demo(){
        for(int i = 0; i < 10000; i++){
            i = i + 1;
            System.out.println(i);
        }
    }
}

7.通过毫秒构造Date对象

Date  time = new Date(long date)；

public Date(long date)

分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

参数：
date - 自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数

package com.bjpowermode.javase.Date;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest03 {
    public static void main(String[] args) {
        Date nowTime = new Date(1);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss sss ");
        String time = sdf.format(nowTime);
        System.out.println(time);

/*        String time01 = sdf.format(nowTime);
        System.out.println(time01);*/

        Date nowTime02 = new Date(System.currentTimeMillis() - (3650 * 24 * 60 * 60 * 1000L ));
        //注意毫秒运算的时候要把数据类型转换成 long类型 防止数据溢出
        String time02 = sdf.format(nowTime02);
        System.out.println(time02);
    }
}

5.数字相关类

1.数字格式化

java.text.DecimalFormat 专门负责数字格式化的
DecimalFormat df = new DecimalFormat("数字格式");

数字格式种类

符号	位置	本地化？	含义
0	数字	是	阿拉伯数字 ，如果不存在则显示为 0
#	数字	是	阿拉伯数字
.	数字	是	小数分隔符或货币小数分隔符
-	数字	是	减号
,	数字	是	分组分隔符
E	数字	是	分隔科学计数法中的尾数和指数。在前缀或后缀中无需加引号。
;	子模式边界	是	分隔正数和负数子模式
%	前缀或后缀	是	乘以 100 并显示为百分数
\u2030	前缀或后缀	是	乘以 1000 并显示为千分数
¤ (\u00A4)	前缀或后缀	否	货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符。
'	前缀或后缀	否	用于在前缀或或后缀中为特殊字符加引号，例如 "'#'#" 将 123 格式化为 "#123"。要创建单引号本身，请连续使用两个单引号："# o''clock"。

package com.bjpowermode.javase.Number;
import java.text.DecimalFormat;
public class numberTest01 {
    public static void main(String[] args) {
        DecimalFormat df = new DecimalFormat("###,###.0000");
        //表示 加入千分位，保留2个小数点
        String s = df.format(1234.56121323);
        //如果小数点后面字数多了，会自动四舍五入
        System.out.println(s);//1,234.5612

        String s1 = df.format(1234.52);
        //如果小数点后不够，补0
        System.out.println(s1);//1,234.5200
    }
}

2.BigDecimal

1.BigDecimal 属于大数据，精度极高。不属于基本数据类型，属于Java对象(引用数据类型)

这是SUN公司提供的一个类，专门用在财务与软件当中。

2.注意：财务软件中double是不够的，面试官会问你处理过财务数据吗，用什么类型。

要说java.util.BigDecimal

package com.bjpowermode.javase.Number;

import java.math.BigDecimal;

public class numberTest02 {
    public static void main(String[] args) {
        //这个不是普通的100,是精度极高的100
        BigDecimal v1 = new BigDecimal(100);
        //精度极高的200
        BigDecimal v2 = new BigDecimal(200);

        //引用数据类型之间的加减乘除不能直接进行，都需要调用方法
        //求和 调用方法求和
        BigDecimal v3 = v1.add(v2);
        System.out.println(v3);
        //减法
        BigDecimal v6 = v2.subtract(v1);
        System.out.println(v6);
        //乘法
        BigDecimal v5 = v2.multiply(v1);
        System.out.println(v5);
        //除法
        BigDecimal v4 = v2.divide(v1);
        System.out.println(v4);

    }
}

3.随机数

java.util.Random

package com.bjpowermode.javase.Number;
import java.util.Random;
public class numberTest03 {
    public static void main(String[] args) {
        //创建一个随机数对象
        Random random = new Random();

        //随机产生一个int类型取值范围内的数字;
        int num1 = random.nextInt();
        System.out.println(num1);

        //产生[0-100]之间的随机数。不能产生101
        //nextInt ：意思为 下一个int类型的数据是101,表示只能取到100
        int num2 = random.nextInt(101);//不包括101
        System.out.println(num2);
    }
}

例题：生成5个不重复的随机数。重复的话重新生成

最终生成的5个随机数放到数组中，要求数组中这5个数随机数不重复

自己写的代码：

package com.bjpowermode.javase.Number;
import com.sun.javaws.IconUtil;

import java.util.Random;
public class numberTest03 {
    public static void main(String[] args) {
        Random random = new Random();
        int[] array = new int[5];
        //循环赋值随机数
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(100);
            //if判断，从第二个数开始判断
            if (i > 0) {
                for (int j = 0; j < i; j++) {
                    //遍历判断 新生成的随机数，和前面生成的随机数是否重复，如果重复，则重新赋值
                    if (array[i] == array[j]) {
                        System.out.println("数据下标"+ i +"重复" + "重复数据为" + array[i] +"重新赋值中");
                        array[i] = random.nextInt(100);
                    }
                }
            }
        }
        for (int j = 0; j < array.length; j++) {
            System.out.println(array[j]);
        }
    }
}

老师的代码

package com.bjpowermode.javase.Number;

import java.util.Random;

public class numberTest04 {
    public static void main(String[] args) {
        Random random = new Random();
        int[] array = new int[5];
        int index = 0;
     while(index < array.length){
         //生成随机数
         int num = random.nextInt(100);
         //判断array数组中有没有num相同的值
         if(!contains(array,num)){
           array[index++] = num;
         }
     }
     for(int i = 0; i < array.length; i++){
         System.out.println(array[i]);
     }
    }
    /**
     * 单独编写一个方法,用来判断数组中是否包含某个元素
     * @param  arr 数组
     * @param  key 元素
     * @return true表示包含, false表示不包含
    */
    public static boolean contains(int[] arr,int key){
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == key) {
                //条件成立返回true
                return true;
            }
        }
        return false;
    }
}

6.枚举类型

• 枚举编译之后生成class文件。
• 枚举也是一种引用数据类型。
• 枚举中的每一个值可以看做是常量。
• 结果只有两种情况的，建议使用布尔类型。结果超过两种还是可以一枚一枚列举出来的，建议使用枚举类型。

枚举类型定义：语法

[public] enum 枚举类型{
	枚举对象1，枚举对象2，...枚举对象 n;
}