JavaSE——常用类

最新推荐文章于 2023-03-08 16:13:03 发布

CoolEr3022

最新推荐文章于 2023-03-08 16:13:03 发布

阅读量1.8k

点赞数

分类专栏：笔记文章标签：语音识别 java spring

本文链接：https://blog.csdn.net/weixin_56341892/article/details/121478812

版权

笔记专栏收录该内容

35 篇文章 0 订阅

订阅专栏

常用类

一、String类

(这部分只需要翻阅API文档)

(一)关于Java JDK 中内置的一个类：java.lang.String

String表示字符串类型，属于引用数据类型，不属于基本数据类型。
在java 中随便使用双引号括起来的都是String对象。例如：“abc”，“def”，“hello world!”，这是3个String对象。
java中规定，双引号括起来的字符串，是不可变的。也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"。
在JDK当中双引号括起来的字符串，例如：“abc” "def"都是直接存储在**“方法区”的“字符串常量池”**当中的。
为什么SUN公司把字符串存储在一个“字符串常量池”当中呢。因为字符串在实际的开发中使用太频繁。为了执行效率，
所以把字符串放到了方法区的字符串常量池当中。

public class StringTest01 {
    public static void main(String[] args) {
        // 这两行代码表示底层创建了3个字符串对象，都在字符串常量池当中。
        String s1 = "abcdef";
        String s2 = "abcdef" + "xy";

        // 分析：这是使用new的方式创建的字符串对象。这个代码中的"xy"是从哪里来的？
        // 凡是双引号括起来的都在字符串常量池中有一份。
        // new对象的时候一定在堆内存当中开辟空间。
        String s3 = new String("xy");

        // s变量中保存的是字符串对象的内存地址。
        // s引用中保存的不是"abc"，是0x1111
        // 而0x1111是"abc"字符串对象在“字符串常量池”当中的内存地址。
        String s = "abc";
    }
}

画内存图：

在这里插入图片描述

public class User {
    private int id;
    private String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    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 class UserTest {
    public static void main(String[] args) {

        User user = new User(110, "张三");

    }
}

内存图：

在这里插入图片描述

String相关面试题(一)：

public class StringTest02 {
    public static void main(String[] args) {
        String s1 = "hello";
        // "hello"是存储在方法区的字符串常量池当中
        // 所以这个"hello"不会新建。（因为这个对象已经存在了！）
        String s2 = "hello";
        // 分析结果是true还是false？
        // == 双等号比较的是不是变量中保存的内存地址？是的。
        System.out.println(s1 == s2); // true

        String x = new String("xyz");
        String y = new String("xyz");
        // 分析结果是true还是false？
        // == 双等号比较的是不是变量中保存的内存地址？是的。
        System.out.println(x == y); //false

        // 通过这个案例的学习，我们知道了，字符串对象之间的比较不能使用“==”
        // "=="不保险。应该调用String类的equals方法。
        // String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。
        System.out.println(x.equals(y)); // true

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

在这里插入图片描述

String相关面试题(二)：

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

public class StringTest03 {
    public static void main(String[] args) {
        
        String s1 = new String("hello");
        String s2 = new String("hello");
    }
}

一共3个对象：
方法区字符串常量池中有1个：“hello”
堆内存当中有两个String对象。

(二)String类的构造方法（查阅文档）

第一个：String s = new String("");
第二个：String s = “”; 最常用
第三个：String s = new String(char数组);
第四个：String s = new String(char数组,起始下标,长度);
第五个：String s = new String(byte数组);
第六个：String s = new String(byte数组,起始下标,长度)

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

        // 创建字符串对象最常用的一种方式
        String s1 =  "hello world!";
        // s1这个变量中保存的是一个内存地址。
        // 按说以下应该输出一个地址。
        // 但是输出一个字符串，说明String类已经重写了toString()方法。
        System.out.println(s1);//hello world!
        System.out.println(s1.toString()); //hello world!

        // 这里只掌握常用的构造方法。
        byte[] bytes = {97, 98, 99}; // 97是a，98是b，99是c
        String s2 = new String(bytes);

        // 前面说过：输出一个引用的时候，会自动调用toString()方法，默认Object的话，会自动输出对象的内存地址。
        // 通过输出结果我们得出一个结论：String类已经重写了toString()方法。
        // 输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身。
        System.out.println(s2.toString()); //abc
        System.out.println(s2); //abc

        // String(字节数组,数组元素下标的起始位置,长度)
        // 将byte数组中的一部分转换成字符串。
        String s3 = new String(bytes, 1, 2);
        System.out.println(s3); // bc

        // 将char数组全部转换成字符串
        char[] chars = {'我','是','中','国','人'};
        String s4 = new String(chars);
        System.out.println(s4);
        // 将char数组的一部分转换成字符串
        String s5 = new String(chars, 2, 3);
        System.out.println(s5);

        String s6 = new String("helloworld!");
        System.out.println(s6); //helloworld!
    }
}

(三)String的常用方法

1.charArt(int index)（掌握）

（返回指定索引处的 char 值。）

package String;

public class StringTest01 {
    public static void main(String[] args) {
        
        char c = "我是中国人".charAt(3);
        System.out.println(c);//国
        
    }
}

2.compareTo(String anotherString)（了解）

（按字典顺序比较两个字符串。）

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

       int result = "acd".compareTo("adc");
        System.out.println(result);    //-1 说明"acd" - "adc" < 0.即"acd"小于"adc"。前小后大

        int result2 = "abc".compareTo("abc");
        System.out.println(result2);   //0 说明"abc" - "abc" = 0.即"abc" 等于"abc" 前后一致

        int result3 = "cda".compareTo("cad");
        System.out.println(result3);  // 3说明"cda" - "cad" > 0.即"cda" 大于"cad" 前大后小
        
    }
}

3.boolean contains(CharSequence s)（掌握）

（当且仅当此字符串包含指定的 char 值序列时，返回 true。）

package String;

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

        System.out.println("Hello World".contains("Hello"));//true
        System.out.println("Hello World".contains("Java"));//false
    }
}

4.boolean endsWith(String suffix)

（测试此字符串是否以指定的后缀结束。）

package String;

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

        System.out.println("www.baidu.com".endsWith(".com"));//true
        System.out.println("Hello.java".endsWith(".text"));//false
    }
}

5.boolean equals(Object anObject)

（将此字符串与指定的对象比较）比较两个字符串必须使用equals方法，不能使用“==”
equals只能看出相等不相等。compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小。

package String;

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

        System.out.println("abc".equals("abc"));//true
    }
}

6.boolean equalsIgnoreCase(String anotherString)

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

package String;

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

        System.out.println("ABc".equalsIgnoreCase("abC")); // true
    }
}

7.byte[] getBytes()

（使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。）

package String;

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

        byte[] bytes = "abcdef".getBytes();
        for(int i = 0; i < bytes.length; i++){
            System.out.println(bytes[i]);//97 98 99 100 101 102
        }
    }
}

8.int indexOf(String str)

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

package String;

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

        System.out.println("abcdefghijklmn".indexOf("cd"));//2
    }
}

9.boolean isEmpty()

（判断某个字符串是否为“空字符串”。底层源代码调用的应该是字符串的length()方法。）

package String;

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

       String s = "";
       String s1 = "a";
        System.out.println(s.isEmpty());//true 为空
        System.out.println(s1.isEmpty());//false 不为空
    }
}

10.int length()

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

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

package String;

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

        System.out.println("abc".length());//3
        System.out.println("Hello World".length());//11
    }
}

11.int lastIndexOf(String str)

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

package String;

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

        System.out.println("abcdeabcghjikg".lastIndexOf("abc"));//5

    }
}

12.String replace(CharSequence target, CharSequence replacement)

（替换。）String的父接口就是：CharSequence

package String;

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

        String ns = "name=ddage=12sex=girl".replace("=",":");
        System.out.println(ns);//name:ddage:12sex:girl

    }
}

13.String[] split(String regex)

（拆分字符串）

package String;

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

        String[] ns = "1999-09-25".split("-");
        for (int i = 0; i < ns.length; i++) {
            System.out.println(ns[i]);//1999 09 25
        }

    }
}

14.boolean startsWith(String prefix)

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

package String;

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

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

    }
}

15.String substring(int beginIndex) 参数是起始下标。

（截取字符串）

package String;

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

        System.out.println("www.baidu.com".substring(4));//baidu.com

    }
}

16.String substring(int beginIndex, int endIndex)

（返回一个新字符串，它是此字符串的一个子字符串。）

beginIndex起始位置（包括）
endIndex结束位置（不包括）

package String;

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

        System.out.println("www.baidu.com".substring(4,9));//baidu

    }
}

17.char[] toCharArray()

（将字符串转换成char数组）

package String;

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

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

    }
}

18.String toLowerCase()

（转换为小写。）

package String;


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

        System.out.println("AbcDDEF".toLowerCase());//abcddef

    }
}

19.String toUpperCase();

（转换为大写）

package String;

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

        System.out.println("AbcDDEF".toUpperCase());//ABCDDEF

    }
}

20.String trim();

（去除字符串前后空白）

package String;

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

        System.out.println("      Hello World      ".trim());//Hello World

    }
}

21.String中只有一个方法是静态的，不需要new对象，这个方法叫做valueOf

（将“非字符串”转换成“字符串”）

package String;

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

        // 这个静态的valueOf()方法，参数是一个对象的时候，会自动调用该对象的toString()方法吗？
        String s1 = String.valueOf(new Customer());
        System.out.println(s1); //我是一个VIP客户！！！！

        // 我们是不是可以研究一下println()方法的源代码了？
        System.out.println(100);
        System.out.println(3.14);
        System.out.println(true);

        Object obj = new Object();
        // 通过源代码可以看出：为什么输出一个引用的时候，会调用toString()方法!!!!
        //　本质上System.out.println()这个方法在输出任何数据的时候都是先转换成字符串，再输出。
        System.out.println(obj);//没有重写toString()，所以输出为内存地址

        System.out.println(new Customer());
    }
}

class Customer {
    // 重写toString()方法

    @Override
    public String toString() {
        return "我是一个VIP客户！！！！";
    }
}

二、StringBuffer

（一）StringBuffer

因为java中的字符串是不可变的，每一次拼接都会产生新字符串，这样会占用大量的方法区内存，造成空间的浪费。

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

java.lang.StringBuffer

java.lang.StringBuilder

【StringBuffer()构造一个不带字符的字符缓冲区，初始容量为16个字符。】

StringBuffer底层实际上是一个byte[]数组，往StringBuffer中放字符实际上是放到了byte数组中

package String;

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

        StringBuffer stringbuffer = new StringBuffer();
        stringbuffer.append("a");
        stringbuffer.append("b");
        stringbuffer.append("c");
        stringbuffer.append(3.14);
        stringbuffer.append("true");
        stringbuffer.append(100L);

        System.out.println(stringbuffer);// 输出为abc3.14true100
    }
}

如何优化StringBuffer的性能——在创建StringBuffer的时候尽可能给定一个初始化容量。最好减少底层数组的扩容次数。预估计一下，给一个大一点的初始化容量。

（二）StringBuilder

StringBuilder也可以完成字符串的拼接。

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

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

三、包装类

（一）包装类存在的意义

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

比如有这种需求：调用某方法时需要传一个数字，但是该方法的方法参数的类型是Object，该方法无法接收基本数据类型，可以传一个数字对应的包装类进去。

（二）八种包装类

基本数据类型	包装类型
byte	java.lang.Byte（父类Number）
short	java.lang.Short（父类Number）
int	java.lang.Integer（父类Number）
long	java.lang.Long（父类Number）
float	java.lang.Float（父类Number）
double	java.lang.Double（父类Number）
char	java.lang.Character（父类Object）
boolean	java.lang.Boolean（父类Object）

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

（三）拆箱和装箱

package String;

public class IntegerTest01 {
    public static void main(String[] args) {
        
        //将基本数据类型——（转换为）——>引用数据类型(装箱)
        Integer i = new Integer(123);
        
        //将引用数据类型——（转换为）——>基本数据类型（拆箱）
        float f = i.floatValue();
        System.out.println(f);//123.0
        //将引用数据类型——（转换为）——>基本数据类型
        int in = i.intValue();
        System.out.println(in);//123
    }
}

Number类中有这样的方法：
byte byteValue() 以 byte 形式返回指定的数值。
abstract double doubleValue()以 double 形式返回指定的数值。
abstract float floatValue()以 float 形式返回指定的数值。
abstract int intValue()以 int 形式返回指定的数值。
abstract long longValue()以 long 形式返回指定的数值。
short shortValue()以 short 形式返回指定的数值。

这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。

（四）Integer的方法

关于Integer的构造方法有两个：

Integer(int)

Integer(String)

package String;

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

        Integer i = new Integer(10);
        System.out.println(i);
        //将String类型的数字转换为Integer包装类型
        Integer s = new Integer("123");
        System.out.println(s);

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

通过常量获取最大值和最小值

 package String;

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

      System.out.println("int的最大值："+ Integer.MAX_VALUE);//int的最大值：2147483647
      System.out.println("int的最小值："+ Integer.MIN_VALUE);//int的最小值：-2147483648
      System.out.println("byte的最大值："+ Byte.MAX_VALUE);//byte的最大值：127
      System.out.println("byte的最小值：" +Byte.MIN_VALUE);//byte的最小值：-128
  }
}

自动装箱和自动拆箱

package String;

public class IntegerTes04 {
  public static void main(String[] args) {
      
      //自动装箱  int--自动转换为-->Integer
      Integer x = 100;
      //自动拆箱  Integer--自动转换为-->int
      int  y = x;
  }
}

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

package String;

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

      Integer z = 100;
      System.out.println(z + 1);//该过程中也发生了自动拆箱

      Integer a = 1000;
      Integer b = 1000;
      System.out.println(a == b);//false 双等于比较内存地址，不会触发自动拆箱机制

      Integer d = 127;
      Integer y = 127;
      System.out.println(d == y);//true

      Integer e = 128;
      Integer f = 128;
      System.out.println(e == f);//false
  }
}

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

在这里插入图片描述

Integer常用方法

   package String;

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

        //手动装箱
        Integer x = new Integer(1000);

        //手动拆箱
        int y = x.intValue();
        System.out.println(y);

        Integer a = new Integer("abc");//java.lang.NumberFormatException 不是“数字”不可以包装成Integer
    }
}

(

经典异常：

空指针异常：NullPointerException

类型转换异常：ClassCastException

数组下标越界异常：ArrayIndexOutOfBoundsException

数字格式化异常:NumberFormatException

)

**重点方法：**static int parseInt ( String s)

静态方法，传参String，返回int
网页上文本框中输入的100实际上是"100"字符串。后台数据库中要求存储100数字，此时java程序需要将"100"转换成100数字。

   package String;

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

        int retValue = Integer.parseInt("123");
        System.out.println(retValue + 100);
    }
}

其他包装类也是一样的

   package String;

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

        double retValue2 = Double.parseDouble("3.14");
        System.out.println(retValue2 + 1);//4.140000000000001精度问题
    }
}

其他方法了解一下

  package String;

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

       // static String toBinaryString(int i)
        // 静态的：将十进制转换成二进制字符串。
        String binaryString = Integer.toBinaryString(3);
        System.out.println(binaryString); //"11" 二进制字符串

        // static String toHexString(int i)
        // 静态的：将十进制转换成十六进制字符串。
        String hexString = Integer.toHexString(16);
        System.out.println(hexString); // "10"

        // 十六进制：1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a
        hexString = Integer.toHexString(17);
        System.out.println(hexString); // "11"

        //static String toOctalString(int i)
        // 静态的：将十进制转换成八进制字符串。
        String octalString = Integer.toOctalString(8);
        System.out.println(octalString); // "10"

        System.out.println(new Object()); //java.lang.Object@6e8cf4c6
		/*public String toString() {
       		 return getClass().getName() + "@" + Integer.toHexString(hashCode());
    	}*/
    	
        // valueOf方法作为了解
        //static Integer valueOf(int i)
        // 静态的：int-->Integer
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        // static Integer valueOf(String s)
        // 静态的：String-->Integer
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}

String int Integer类型互换

在这里插入图片描述

package String;

public class IntegerTest06 {
    public static void main(String[] args) {
        
        //String--->int
        String s1 = "100";
        int i1 = Integer.parseInt(s1);//i1是数字100
        System.out.println(i1 + 1);//101
        
        //int--->String
        String s2 = i1 +"";//"100"字符串
        System.out.println(s2 + 1);//1001
        
        //int--->Integer
        //自动装箱
        Integer x = 1000;
        
        //Integer--->int
        //自动拆箱
        int y = x;
        
        //String--->Integer
        Integer k = Integer.valueOf("123");
        
        //integer--->String
        String s = String.valueOf(k);
    }
}

四、日期相关类

在这里插入图片描述

package 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);//Sun Nov 21 16:24:23 CST 2021

        //将Date按照指定格式进行转换
        //Date--->String
        //在日期格式中，除 y M d H m s S 这些字符不能随便写，剩下的符号格式自己随意组织
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");//专门负责日期格式化
        System.out.println(sdf.format(nowTime));

        //假设现在有一个日期字符串String,如何转换成Date类型?
        //String--->Date
        String time = "2008-08-08 08:08:08 888";
        //格式不能随便写，需要对应一致
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        Date dateTime = sdf2.parse(time);
        System.out.println(dateTime);

    }

以上程序：

知识点1：如何获取系统当前时间

知识点2：String—>Date

知识点3：Date—>String

package date;

public class dateTest02 {
    public static void main(String[] args) {
        //获取自1970年1月1日 00:00:00 000 到当前系统时间的总毫秒数
        long nowTimeMillis = System.currentTimeMillis();
        System.out.println(nowTimeMillis);

        //在调用一个方法之前记录一个毫秒数
        long begin = System.currentTimeMillis();
        print();
        //在执行目标方法后也记录一个毫秒数
        long end = System.currentTimeMillis();

        System.out.println("耗费时长为：" +(end - begin) + "毫秒");
    }
    //需求：统计一个方法执行所耗费的时长
    public static void print(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("i = " + i);//如果不打印，耗费时间极短
        }
    }
}

简单总结一下System类的相关属性和方法：(后面无括号的为属性，有括号的为方法)
System.out 【out是System类的静态变量。】
System.out.println() 【println()方法不是System类的，是PrintStream类的方法。】
System.gc() 建议启动垃圾回收器
System.currentTimeMillis() 获取自1970年1月1日到系统当前时间的总毫秒数。
System.exit(0) 退出JVM。

package date;

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

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

        //这个时间为 1970-01-01 00:00:00 001
        Date time = new Date(1);//参数为毫秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        System.out.println(sdf.format(time));//1970-01-01 08:00:00 001  北京是东八区 差八个小时

        //获取昨天的此时的时间
        Date time2 = new Date(System.currentTimeMillis()-1000 * 60 * 60 * 24);
        System.out.println(sdf.format(time2));
        
    }
}

五、数字类

java.text.DecimalFormat专门负责数字格式化的。

数字格式有：

#代表任意数字

，代表千分位

. 代表小数点

0代表不够时补0

package Number;

import java.text.DecimalFormat;

public class NumberTest01 {
    public static void main(String[] args) {
        //DecimalFormat专门负责数字格式化的
        DecimalFormat df = new DecimalFormat("###,###.##");//表示加入千分位，保留两个小数
        String s = df.format(1234.56);
        System.out.println(s);//1,234.56

        DecimalFormat df2 = new DecimalFormat("###,##.0000");
        String s2 = df2.format(1234.56);
        System.out.println(s2);//12,34.5600
    }
}

BigDecimal

BigDecimal属于大数据，精度极高，不属于基本数据类型，属于java对象（引用数据类型）

是sun提供的一个类，专门用在财务软件中。

package Number;

import java.math.BigDecimal;

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

        //这个100不是普通的100，而是精度极高的100
        BigDecimal bd = new BigDecimal(100);
        BigDecimal bd2 = new BigDecimal(200);

        //求和
        BigDecimal bd3 = bd.add(bd2);///调用方法求和
        System.out.println(bd3);

        BigDecimal bd4 = bd2.divide(bd);
        System.out.println(bd4);
    }
}

六、Random

package random;

import java.util.Random;

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

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

        //产生0~10的随机数，不能产生10
       int i2 = rd.nextInt(10);
        System.out.println(i2);
    }
}

小测试：

生成5个不重复的随机数（数字范围是0~100），重复的话重新生成。最终生成的5个随机数放到数组当中。

思路：

（1）创建Random对象

（2）准备一个长度为5的一维数组。因为数字范围是0到100，可以先给数组中元素默认赋值为-1

（3）循环生成随机数组

——可以先假设一个死循环，循环中判断数组中是否包含随机产生的这个数，如果不包含这个数，则将这个数赋值给a[下标]（这个判断是否包含的情况可以写一个方法，应该为布尔值，所以方法返回类型为布尔类型public static boolean contains(int[] a,num),方法中循环遍历数组，判断是否包含），此时可以判断出，跳出循环的条件为当产生的数大于数组长度，即下标大于数组长度时，循环应该结束。

package random;

import java.util.Random;

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

        //创建Random对象
        Random rd = new Random();

        //准备一个长度为5的一维数组
        int[] a = new int[5];
        for (int i = 0; i < a.length; i++) {
            a[i] = -1;
        }

        //循环生成随机数
        int index = 0;
        while(index < a.length){
            int num = rd.nextInt(101);
            if(!contains(a, num)){
                a[index++] = num;
            }
        }
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);
        }
    }
    public static boolean contains(int[] a,int key){
        for(int i = 0; i < a.length; i++){
            if(a[i] == key){
                // 条件成立了表示包含，返回true
                return true;
            }
        }
        return false;
    }
}

七、Enum

枚举是一种引用数据类型
枚举类型怎么定义，语法是？
enum 枚举类型名{
枚举值1,枚举值2
}
结果只有两种情况的，建议使用布尔类型。

结果超过两种并且还是可以一枚一枚列举出来的，建议使用枚举类型。
例如：颜色、四季、星期等都可以使用枚举类型。

package enum2;

import static enum2.Season.SPRING;

public class EnumTest01 {
    public static void main(String[] args) {
        switch (SPRING){
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
        }

    }
}

package enum2;

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}

CoolEr3022

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录