day03-二维数组+字符串相关类+数学相关类+枚举类型

最新推荐文章于 2024-09-17 10:36:22 发布

菜鸟小coder

最新推荐文章于 2024-09-17 10:36:22 发布

阅读量78

点赞数

分类专栏： JavaSE02 文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/2301_76475659/article/details/129290399

版权

JavaSE02 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的二维数组，包括定义、初始化和遍历方法。还探讨了字符串相关类，如String的基本操作，如创建、比较、连接和转换。此外，讲解了Math类提供的数学运算，如随机数生成和四舍五入。最后提到了枚举类型在Java中的应用。

摘要由CSDN通过智能技术生成

day03-二维数组+字符串相关类+数学相关类+枚举类型

字符串相关类

数学相关类

枚举类型

练习

学习任务
1 掌握二维数组的定义与元素访问
2 记住字符串相关类的常用方法
3 记住数学相关类的常用方法

文章目录

day03-二维数组+字符串相关类+数学相关类+枚举类型

二维数组

在定义数组时, 使用一对方括弧,称为一维数组, 一维数组中存储的具体的数据在定义数组时, 使用两对方括弧,称为二维数组, 二维数组中存储的是一维数组

二维数组定义格式: 数据类型 [][] 数组名 = new 数据类型[二维数组长度][一维数组长度];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-br161MyL-1677677566582)(D:\course\03-JavaSE\Note\Day03\03 二维数组.png)]

public class Test01 {
    public static void main(String[] args) {
        //定义数组格式:  数据类型 [] 数组名 = new 数据类型[长度] ;
        int[] ints1 = new int[10];
        //定义数组同时静态初始化:  数据类型 [] 数组名 = new 数据类型[]{值1,值2,值3....};
        int[] ints2 = new int[]{12, 34, 56, 78};
        //数组静态初始化简化形式: 数据类型 [] 数组名 = {值1,值2,值3....};
        int[] ints3 = {5, 6, 7, 8, 9};
        int x = 10, y = 20;
        int[] ints4 = {x, y};      //定义数组,把x,y变量的值保存到数组中
        //数组是一种引用 数据类型, 数组名其实就是一个变量名, 即 ints1, ints2, ints3, ints4 数组名的数据类型是:   int[]
        //定义数组, 把 ints1, ints2, ints3, ints4 这四个变量保存到数组中
        int[][] twoArr1 = {ints1, ints2, ints3, ints4};     //定义数组twoArr1, twoArr1数组名前面一对方括弧表示正在定义数组, 再前面的 int[] 是twoArr1数组中元素的类型, 称twoArr1数组为二维数组,它的每个 元素是一个一维数组, 即二维数组是数组的数组, 有人也把二维数组看作是一个对象数组

        //通过for循环遍历二维数组保存的具体数据
        for (int i = 0; i < twoArr1.length; i++) {
            //twoArr1[i]二维数组元素又是一个一维数组名, 继续通过for循环遍历 twoArr1[i]这个一维数组中的数据
            for (int j = 0; j < twoArr1[i].length; j++) {
                System.out.print(twoArr1[i][j] + "  ");
            }
            System.out.println();
        }

        //使用foreach遍历二维数组中的数据
        for (int[] ints : twoArr1) {
            for (int anInt : ints) {
                System.out.print(anInt + "  ");
            }
            System.out.println();
        }

        //二维数组定义格式: 数据类型 [][] 数组名 = new 数据类型[二维数组长度][一维数组长度];
        int[][] twoArr2 = new int[5][6];       //定义二维数组twoarr2, 有5个元素, 每个 元素初始化长度为6的一维数组
        //在定义二维数组时,可以省略一维数组长度
        int[][] twoarr3 = new int[6][];        //定义二维数组twoarr3, 有6个元素, 每个 元素是int[]类型的一维数组,现在没有指定一维数组长度,所以系统不会给一维数组初始化,即twoarr3数组的6个元素默认初始化为null
        //调用Arrays.deepToString(二维数组)可以把二维数组元素连接为字符串
        System.out.println(Arrays.deepToString(twoArr2));
        System.out.println(Arrays.deepToString(twoarr3));
        //面试
        int[] twoArr3[];
        int twoArr4[][];
        //给二维数组元素赋值,只要赋值相同类型的一维数组即可, 不要求赋值的一维长度必须与原来长度一致
        twoArr2[0] = new int[20];
        twoArr2[1] = new int[]{1, 2, 3, 4};
        //twoArr2[2] = {6,6,7,8,9};       //这种简化形式仅用于数组的静态初始化,不能重新赋值

        //二维数组的静态初始化格式: 数据类型 [][] 数组名 = new 数据类型[][]{ 一维数组1, 一维数组2,.....};
        int[][] twoArr5 = new int[][]{ints1, ints2};
        int[][] twoArr6 = {new int[6], new int[]{1, 2, 3, 4}, {6, 7, 8}};
    }
}

字符串相关类

Java提供的常用类包括: 字符串相关类, 数学相关类, 日期相关类与包装类在学习Java提供的类时, 主要学习如何创建对象, 提供了哪些操作(常用方法)

String

1. 创建对象

直接赋值字符串字面量:String s1 = “hello”;
调用 String(byte[] bytes) 构造方法,根据字节数组创建字符串对象

调用 String(char []chars) 根据字符数组创建String对象

public class Test01Construct {
    public static void main(String[] args) {
        //1 直接赋值字符串字面量
        String s1 = "Hello";        //双引号引起来的字符串字面量"Hello"就是一个String对象, 程序运行后,会在字符串常量池中创建"Hello"对象,把这个对象的引用赋值给s1

        //2 调用 String(byte[] bytes)  构造方法,把字节数组中的字节以默认的编码解析为String对象. 将来可能会从网络中,从文件中读取若干字节保存到字节数组中,通过构造方法把字节数组转换为字符串
        byte[] bytes = {65, 66, 67, 68, -28, -110, -107, -27, -100, -88};
        String s2 = new String(bytes);      //把bytes数组中所有 的字节以默认的UTF-8编码解析为字符串
        System.out.println(s2);       //ABCD䒕在
        //String(byte[] bytes, int offset, int length) 把bytes数组中从offset开始的length个字节解析为字符串
        s2 = new String(bytes, 0, 4); //把bytes数组中从0开始的4个字节解析为字符串
        System.out.println(s2);       //ABCD
        s2 = new String(bytes, 0, 5); //把bytes数组中从0开始的5个字节解析为字符串
        System.out.println(s2);       //ABCD�

        //3 调用 String(char[] value) 可以把value数组中所有 的字符连接为字符串
        char[] chars = {'A', 'b', '5', '@', '汉', '字', 1000, 20000, 30088};
        String s3 = new String(chars);      //把chars数组中所有 的字符连接为字符串
        System.out.println(s3);       //Ab5@汉字Ϩ丠疈
        //String(char[] value, int offset, int count) 把value数组中从offset开始的count个字符连接为字符串
        s3 = new String(chars, 0, 6);        //把chars数组中从0开始的6个字符连接为字符串
        System.out.println(s3);
    }
}

2. 常用操作

char charAt(int index) 返回字符串中index位置的字符 int length() 返回字符串长度,即字符串中字符的数量
int compareTo(String anotherString) 比较当前字符串与参数字符串的大小,如果当前字符串大返回正数, 相等返回0,当前字符串小于参数字符串返回负数 int compareToIgnoreCase(String str) 忽略大小写后再比较两个字符串大小
String concat(String str) 在当前字符串后面连接str,返回连接后的新字符串 boolean contains(CharSequence s) 判断当前字符串是否包含s字符串. CharSequence是一个接口,contains方法形参是接口,在调用方法时,实参可以传递接口的实现类对象, String类, StringBuilder类实现了CharSequence接口 boolean endsWith(String suffix) 判断当前字符串是否以suffix结尾 boolean startsWith(String prefix) 判断当前字符串是否以prefix开始 boolean equals(Object anObject) 判断两个字符串的字符序列是否一样 boolean equalsIgnoreCase(String anotherString) 忽略大小写后再判断字符串的字符序列是否一样
byte[] getBytes() 返回字符串在当前默认编码下对应的字节数组 byte[] getBytes(String charsetName) 返回字符串在指定的charsetName编码下对应的字节数组
int indexOf(String str) 返回当前字符串 str 第一次出现的位置 int lastIndexOf(String str) 返回str在当前字符串中最后一次出现的位置 String substring(int beginIndex) 返回当前字符串从beginIndex开始的字符串 String substring(int beginIndex, int endIndex) 返回当前字符串[beginIndex, endIndex)范围内的子串
String[] split(String regex) 使用regex对当前字符串进行拆分 , 返回拆分后的字符串组成的数组
char[] toCharArray() 把字符串转换为字符数组
String toLowerCase() 把字符串中的大写转换为小写,返回一个新的字符串 //String toUpperCase() 把字符串中的小写字母转换为大写, 原来字符串不变
String trim() 去掉前后的空白符, 返回新的字符串,原来字符串不变

static String valueOf(int i) 可以把其他类型的数据转换为String字符串 //static String valueOf(Object obj)

public class Test02Method {
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*1)
            char charAt(int index)  返回字符串中index位置 的字符
            int length() 返回字符串长度,即字符串中字符的数量
            String类底层定义了private final char value[];字符数组来保存字符串的每个字符. charAt(index)其实就是返回 value[index]数组元素,  length()方法其实就是返回 value.length 属性
         */
        String s = "hello动力节点";     //底层通过value字符数组保存字符串的每个 字符: h e l l o 动 力 节 点
        System.out.println(s.charAt(0));        //返回0位置 的字符:h
        System.out.println(s.length());       //返回value数组长度: 9
        //通过for循环遍历字符串的每个 字符
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i) + "   ");
        }
        System.out.println();

        /*2)
            int compareTo(String anotherString) 比较当前字符串与参数字符串的大小,如果当前字符串大返回正数, 相等返回0,当前字符串小于参数字符串返回负数
            int compareToIgnoreCase(String str) 忽略大小写后再比较两个字符串大小
            java把当前对象与另外一个对象比较大小的功能抽象到Comparable接口中, 当一个类实现了Comparable接口,重写接口的抽象方法,是这个类就具有了接口的功能, 即这个类创建的对象就具有了比较大小的功能. String类实现了Comparable接口,那么String对象就具有了比较大小的功能.
            查看Comparable接口的定义:
                public interface Comparable<T> {
                    public int compareTo(T o);
                }
            在Comparable接口名后面有<T>,这是泛型, 泛型就是把数据类型作为参数传递.当一个类实现Comparable接口时,需要给泛型参数T传递一个数据类型,这个数据类型就是抽象方法compareTo的参数类型,这个类型就是另外一个比较对象的类型
            String类重写了Comparable接口的抽象方法compareTo(),在这个方法中定义了字符串的比较规则: 逐个比较两个字符串的每个字符,遇到第一个不相等的字符,码值相减.如果前面的字符都一样就比较字符串的长度
         */
        System.out.println("hello".compareTo("hehe"));      //4, 正数表示前面第一个字符串大
        System.out.println("hello".compareTo("w"));         //-15, 负数表示前面第一个字符串小
        System.out.println("hello".compareTo("helloworld"));    //-5,
        System.out.println("hello".compareTo("HELLO"));    //32, 区别大小写的
        //如果不区分大小写比较字符串大小调用compareToIgnoreCase()方法
        System.out.println("hello".compareToIgnoreCase("HELLO"));  //0

        /*3)
            String concat(String str)   在当前字符串后面连接str,返回连接后的新字符串
            boolean contains(CharSequence s)    判断当前字符串是否包含s字符串. CharSequence是一个接口,contains方法形参是接口,在调用方法时,实参可以传递接口的实现类对象, String类, StringBuilder类实现了CharSequence接口
            boolean endsWith(String suffix) 判断当前字符串是否以suffix结尾
            boolean startsWith(String prefix)   判断当前字符串是否以prefix开始
            boolean equals(Object anObject) 判断两个字符串的字符序列是否一样
            boolean equalsIgnoreCase(String anotherString)  忽略大小写后再判断字符串的字符序列是否一样
         */
        String s2 = s.concat("nice");       //在s字符串后面连接 "nice",返回连接后的新字符串,原来字符串不变
        System.out.println(s2);           //hello动力节点nice
        System.out.println(s);            //hello动力节点
        System.out.println(s2.contains("nice"));       //true, s2字符串中包含nice
        System.out.println(s2.endsWith("nice"));       //true, s2字符串以nice结尾
        System.out.println(s2.startsWith("hello"));   //true, s2字符串以hello开始
        System.out.println(s2.equals(s));      //false, 两个字符串不一样
        System.out.println("HELLO动力节点".equalsIgnoreCase(s));    //true,忽略大小写后两个字符串一样

        /*4)
            byte[] getBytes()   返回字符串在当前默认编码下对应的字节数组
            byte[] getBytes(String charsetName)  返回字符串在指定的charsetName编码下对应的字节数组
         */
        byte[] bytes = s.getBytes();        //返回s字符串以默认的UTF-8编码下对应的字节数组, 在UTF-8编码中,一个英文字符占1个字节,一个汉字占3个字节
        System.out.println(Arrays.toString(bytes));
        //[104, 101, 108, 108, 111, -27, -118, -88, -27, -118, -101, -24, -118, -126, -25, -126, -71]
        s2 = new String(bytes); //把字节数组转换为字符串
        System.out.println(s2);       //hello动力节点
        //把s字符串以指定的GBK编码转换为字节数组调用 getBytes(String charsetName)构造方法, 提示语法错误:Unhandled exception: java.io.UnsupportedEncodingException未处理的 异常. 调用的这个构造方法有检查异常需要预处理,当前选择抛出处理. Alt + Enter,选择 Add exception to method signature. 运行程序后,如果指定的编码java不支持就会抛出 UnsupportedEncodingException 不支持编码异常
        byte[] gbks = s.getBytes("GBK");
        System.out.println(Arrays.toString(gbks)); //在GBK编码中,一个英文字符占1个字节,一个汉字占2个字节
        //[104, 101, 108, 108, 111, -74, -81, -63, -90, -67, -38, -75, -29]
        s2 = new String(gbks);  //把gbks数组中所有的字节以默认的UTF8编码解析为字符串
        System.out.println(s2);       //hello�����ڵ�
        //调用String( byte [] bytes, String charsetName)构造方法,可以把bytes数组中的字节以指定的charsetName编码解析为字符串
        s2 = new String(gbks, "GBK");
        System.out.println(s2);


        /*5)
            int indexOf(String str) 返回当前字符串 str 第一次出现的位置
            int lastIndexOf(String str) 返回str在当前字符串中最后一次出现的位置
            String substring(int beginIndex)    返回当前字符串从beginIndex开始的字符串
            String substring(int beginIndex, int endIndex)  返回当前字符串[beginIndex, endIndex)范围内的子串
         */
        //定义字符串保存文件路径, 在Windows系统中文件分隔符默认是反斜杠\, 而在String字符串中遇到反斜杠就认为是转义字符的开始,需要使用两个反斜杠\\转义为一个反斜杠\
        String path = "D:\\course\\03-JavaSE\\Code\\Day03\\src\\com\\bjpowernode\\string\\Test01Construct.java";
        //需求: 把文件名, 扩展名分别取出来, 需要确定反斜杠最后一次出现的索引值, 确定小点最后一次出现的索引值
        int slash = path.lastIndexOf("\\");
        int dot = path.lastIndexOf(".");
        String filename = path.substring(slash + 1, dot);
        String suffix = path.substring(dot);
        System.out.println(filename);       //Test01Construct
        System.out.println(suffix);         //.java

        //6) String[] split(String regex)   使用regex对当前字符串进行拆分 , 返回拆分后的字符串组成的数组
        s2 = "Good Good Study Day Day Up";
        //在s2字符串中单词之间使用一个空格进行连接的, 可以使用一个空格对s2字符串拆分, 返回拆分后的字符串组成的数组
        String[] words = s2.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
        String s3 = "girlfriend";
        String[] split = s3.split("");  //使用空串对s3进行拆分
        for (String ss : split) {
            System.out.println(ss);
        }

        //7) char[] toCharArray() 把字符串转换为字符数组
        char[] chars = s.toCharArray();
        for (char aChar : chars) {
            System.out.print(aChar + "        ");
        }
        System.out.println();
        s3 = new String(chars);     //把字符数组转换为字符串
        System.out.println(s3);

        //8) String toLowerCase() 把字符串中的大写转换为小写,返回一个新的字符串
        //String toUpperCase() 把字符串中的小写字母转换为大写, 原来字符串不变
        String lowerCase = s2.toLowerCase();
        String upperCase = s2.toUpperCase();
        System.out.println(lowerCase);        //good good study day day up
        System.out.println(upperCase);        //GOOD GOOD STUDY DAY DAY UP
        System.out.println(s2);               //Good Good Study Day Day Up

        //9) String trim() 去掉前后的空白符, 返回新的字符串,原来字符串不变
        s3 = "   hello   world    ";
        String trim = s3.trim();
        System.out.println("**" + trim + "**");
        System.out.println("**" + s3 + "**");

        //10) static String valueOf(int i) 可以把其他类型的数据转换为String字符串
        //static String valueOf(Object obj)
        int num = 456;
        s3 = String.valueOf(num);
        System.out.println();
    }
}

3. String字符串字面量

双引号引起来的字符串字面量保存在字符串常量池中,采用享元模式
String s1 = “hello”; 程序执行这一行时, 先检查字符串常量池中是否存在"hello"对象,如果字符串常量池中不存在这个对象则在常量池中创建"hello"对象把这个对象的引用赋值给s1String s2 = "hello;程序执行这一行时, 检查到字符串常量池中存在"hello"对象, 直接把这个对象的引用赋值给s2现在 s1 与 s2 两个变量都保存了字符串常量池中同一个"hello"对象的引用

4. String字符串对象是不可变的

String字符串对象不可变指String字符串的字符序列无法修改创建了String字符串对象后, 底层使用private final char value[]字符数组保存字符串的每个字符该数组是private私有的, 我们无法直接访问它, String类也没有提供相应的方法修改value数组元素所以String对象的字符序列无法修改String s3 = “hello”; 程序执行这一行在字符串常量池中创建"hello"对象s3 = “world”; 程序执行这一行时,又在字符串常量池中创建一个"world"对象, 现在字符串常量池中有两个对象并没有把"hello"变为"world"String提供的方法: concat(), toLowerCase(), trim()等都是返回一个新的字符串,原来字符串不变
使用加号+进行字符串连接时, 会创建新的字符串对象频繁进行字符串连接时, 不建议使用加号连接建议使用可变字符串连接

StringBuilder/StringBuffer

StringBuilder/StringBuffer称为可变字符串即它们的字符串中的字符序列可以修改区别在于:StringBuffer是线程安全的, StringBuilder不是线程安全的StringBuilder执行效率更高
创建对象
StringBuilder() 创建一个空字符串
StringBuilder(int capacity) 通过构造方法参数指定底层字符数组的长度
StringBuilder(CharSequence seq) 根据已有的字符串创建新的字符串

常用操作
append(String str) 字符串连接
delete(int start, int end) 删除指定范围内的字符
insert(int offset, String str) 向字符串指定位置插入
replace(int start, int end, String str) 把字符串中[start, end)范围内的字符替换为str

public class Test04StringBuilder {
    public static void main(String[] args) {
        //创建可变字符串对象
        StringBuilder sb = new StringBuilder();     //创建一个空串, 底层字符数组value默认长度为16
        StringBuilder sb2 = new StringBuilder(1000);        //指定底层value数组长度为1000, 当字符串长度比较大时, 可以使用这个构造方法,指定底层数组的长度,避免底层数组的频繁扩容
        StringBuilder sb3 = new StringBuilder("helloworld");        //根据其他的字符串创建新的字符串

        //append()字符串连接
        for (int i = 0; i < 10; i++) {
            sb.append(i);   //把i变量的值连接到sb字符串中
        }
        System.out.println(sb);       //0123456789

        //delelte()删除
        sb.delete(3, 8);        //删除sb字符串中[3, 8 )范围内的字符
        System.out.println(sb);       //01289

        //insert()插入
        sb.insert(1, "hello");       //在索引值为1的位置插入"hello"
        System.out.println(sb);         //0hello1289

        //replace()替换
        sb.replace(3, 6, "world");    //把sb字符串中[3,6)范围内的字符替换为"world"
        System.out.println(sb);       //0heworld1289

        //reverse()逆序
        sb.reverse();
        System.out.println(sb);     //9821dlroweh0

        //转换为String字符串
        String s = sb.toString();
        s = new String(sb);
    }
}

面试题

public class Test03 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2);         //true

        //javac编译器对字符串常量的连接进行优化. 在.java编译为.class字节码文件时, 编译器对字符串常量使用加号的连接优化
        String s3 = "he" + "llo";       //这一行优化为:  String s3 = "hello"
        System.out.println(s1 == s3);         //true

        String s4 = "he";
        String s5 = s4 + "llo";         //s4是变量,程序运行到这一行时才能确定变量的值
        System.out.println(s1 == s5);         //false

        final String s6 = "he";
        String s7 = s6 + "llo";
        System.out.println(s1 == s7);     //true

        //以下两行共创建了多少个String字符串对象?       3个: 一个字符串字面量:"goodgirl", new出来两个
        String s8 = new String("goodgirl");
        String s9 = new String("good" + "girl");
    }
}

数学相关类

java.lang.Math数学类

该类提供一组数学函数相关的方法
random()生成[0, 1)范围内的随机小数
min(x,y)返回两个数中较小的max(x,y)返回两个数中较大的

round(x) 对x四舍五入floor(x) 返回小于等于x的最大整数ceil(x) 返回大于等于x的最小整数

public class Test01Math {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println( Math.random());     //生成[0,1)范围内的随机小数
        }

        System.out.println( Math.max(10, 20));      //20
        System.out.println( Math.min(3.14, 5.0));   //3.14

        System.out.println( Math.ceil(3.14));       //4.0   大于等于x的最小整数
        System.out.println( Math.ceil(-3.14));       //-3.0   大于等于x的最小整数
        System.out.println( Math.floor(3.98));      //3.0   小于等于x的最大整数

        //round(x)其实就是把x加0.5后向下取整
        System.out.println( Math.round(3.5));       //4
        System.out.println( Math.round(-3.6));      //-4
        System.out.println( Math.round(-3.5));      //-3
    }
}

java.util.Random类

专门用于生成随机数的
Random rand = new Random()创建随机数对象

rand.nextDoube()返回 [ 0 ,1) 范围内的随机小数rand.nextInt() 返回随机整数rand.nextInt( limit ) 返回 [ 0 , limit)范围内的随机整数

public class Test02Random {
    public static void main(String[] args) {
        //创建随机数对象
        Random random = new Random();

        //生成随机小数
        for (int i = 0; i < 5; i++) {
            System.out.println( random.nextDouble());       //生成[0,1)范围内的随机小数
        }

        //生成随机整数
        for (int i = 0; i < 5; i++) {
            System.out.println( random.nextInt());      //随机整数
        }

        //生成[0, 100)范围内的随机整数, 调用nextInt(limit)方法指定上限
        for (int i = 0; i < 5; i++) {
            System.out.println( random.nextInt(100));       //
        }
    }
}

java.text.DecimalFormat类

可以把数字转换为指定格式的字符串

DecimalFormat df = new DecimalFormat( “###,###.0000”); 创建对象,通过构造方法指定数字格式串String s = df.format( 1234.56 ); 可以把数字转换为指定格式的字符串

public class Test03DecimalFormat {
    public static void main(String[] args) {
        //调用 DecimalFormat(String pattern)  构造方法创建对象, 通过参数指定数字格式串,常用格式符有: 0数字, #数字, 逗号, 小数点
        DecimalFormat df = new DecimalFormat("###,###.0000");       //格式符#和0都可以表示数字,区别在于使用0时,不足的位数会补0
        //调用format(double)可以把小数转换为字符串
        String s = df.format(1234.45);
        System.out.println(s);            //1,234.4500

        df.applyPattern("000,000.####");
        s = df.format(1234.45);
        System.out.println(s);            //001,234.45
    }
}

java.math.BigIntegerjava.math.BigDecimal

大的整数, 大的小数用于精度要求比较高的场景
进行财务计算, 科学计算时通常使用这两个类
常用操作:add()相加subtract()相减multiply()相乘divide()相除

 * BigInteger大的整数
 * BigDecimal大的小数

public class Test04BigDecimal {
    public static void main(String[] args) {
        //创建大的整数对象
        BigInteger i1 = new BigInteger("7984651498651328946513286451328496513246513248651246514865134651651");
        BigInteger i2 = new BigInteger("7948651349865132948651324896651324651326541326845132");
        //add()相加,  subtract()相减, multiply()相乘, divide()相除
        BigInteger i3 = i1.add(i2);     //加
        System.out.println(i3);
        i3 = i1.subtract(i2);           //i1 减去i2
        System.out.println(i3);
        i3 = i1.multiply(i2);           //乘
        System.out.println(i3);
        i3 = i1.divide(i2);             //i1 除以 i2
        System.out.println(i3);

        //小数在计算机中采用近似值保存,有时不准确
        System.out.println(2 - 1.1);      //0.8999999999999999

        //BigDecimal大的小数
        BigDecimal d1 = new BigDecimal("7948651387946851329465139784651984665132.798798465465132684513");
        BigDecimal d2 = new BigDecimal("7948651389465139784651984665132.798465132684513");
        //小数相除,如果除不断可能会抛出算术异常ArithmeticException
        //BigDecimal d3 = d1.divide(d2);      //d1除以d2, 抛出ArithmeticException
        //小数相除, 通常调用divide( divisor除数, scale小数位数, roundingMode尾数处理方式), 第三个参数RoundingMode是一个枚举类型
        BigDecimal d3 = d1.divide(d2, 10, RoundingMode.DOWN);
        System.out.println(d3);
    }
}

枚举类型

枚举是一种引用数据类型当某个类型的取值只有几个离散常量值时,可以定义为枚举类型
//使用enum关键字定义枚举类型enum Gender{ 男,女 //Gender枚举类型定义的变量只能取值两个常量: 男,女}

//给枚举变量赋值枚举常量 Gender g = Gender.男;

 * 枚举可以简单的看作是一组常量的组合
 * 当某个类型的数据只有几个离散值时,可以定义为枚举类型,
 * 如: 性别, 季节, 星期
public class Test05Enum {
    public static void main(String[] args) {
        //给枚举变量赋值枚举常量
        Gender g = Gender.男;
        /*g = "女";
        g = 1;*/
        Season season = Season.AUTUMN;
    }
}

//使用enum关键字定义枚举类型
enum Gender {
    男, 女         //Gender枚举类型定义的变量只能取值两个常量: 男,女
}

enum Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

练习

定义方法, 返回一个随机的姓名姓名长度由3~10个字符组成姓名由随机的小写字母组成

public class Test {
    public static void main(String[] args) {
        System.out.println( getName());
        System.out.println( getName());
        System.out.println( getName());
        System.out.println( getName());
    }

    //定义方法, 返回一个随机的姓名
    public static String getName(){
        //姓名长度由3~10个字符组成
        Random random = new Random();   //创建随机数对象
        int len = random.nextInt(8) + 3 ;   //生成 3 ~10范围内的随机长度
        //生成len个随机小写字母连接为字符串
        StringBuilder sb = new StringBuilder();     //创建可变字符串
        for (int i = 0; i < len; i++) {
            int n = random.nextInt(26);         //生成[0,26)范围内的随机整数
            char cc = (char)('a' + n);      //把整数n转换为小写字母
            sb.append( cc );                //字符连接
        }
        return sb.toString();
    }
}

public static String getName(){
    //姓名长度由3~10个字符组成
    Random random = new Random();   //创建随机数对象
    int len = random.nextInt(8) + 3 ;   //生成 3 ~10范围内的随机长度
    //生成len个随机小写字母连接为字符串
    StringBuilder sb = new StringBuilder();     //创建可变字符串
    for (int i = 0; i < len; i++) {
        int n = random.nextInt(26);         //生成[0,26)范围内的随机整数
        char cc = (char)('a' + n);      //把整数n转换为小写字母
        sb.append( cc );                //字符连接
    }
    return sb.toString();
}

}