Java实验04 JavaAPI

曾经终败给现在 2022-12-23 01:56 52阅读 0赞

第六章 JavaAPI  
实验6-1 常见的创建字符串的方式  
一、实验描述  
1、 考核知识点  
名称：String类的初始化  
2、 练习目标  
 掌握创建String对象的两种方式  
 掌握如何使用String类的构造方法初始化String对象  
3、 需求分析  
String类中有很多重载的构造方法，由于每个构造方法有其不同的作用，所以在不同场景下如何选择正确的构造方法，对于初学者来说显得尤为重要。为了让初学者能熟悉每个构造方法的用法，本实验将使用不同的构造方法创建字符串，以加深对字符串初始化的理解。  
4、 设计思路（实现原理）

1.  编写Example01类。
2.  在main()方法中分别使用不同的构造方法创建字符串对象。通过String()方法创建的字符串s1，通过String(byte\[\] bytes)方法创建的字符串s2，通过String(byte\[\] bytes, int index, int length)方法创建的字符串s3，通过String(char\[\] value)方法创建的字符串s4，通过String(char\[\] value, int index, int length)方法创建的字符串s5，通过String(String str)方法创建的字符串s6，直接给字符串对象赋值s7。
3.  将字符串内容输出，根据打印结果观察字符串之间的区别，熟悉不同构造方法的用途。  
    二、实验实现

package Example01;
    
    public class Example01 {
        
        public static void main(String[] args) {
        
            // 方式1
            String s1 = new String("abcdefg");
            // 方式2
            byte[] bytes = {
        'a','b','c','d','e','f','g'};
            String s2 = new String(bytes);
            // 方式3
            String s3 = new String(bytes,2,5);
            // 方式4
            char[] c = {
        'a','b','c','d','e','f','g'};
            String s4 = new String(c);
            //方式5
            String s5 = new String(c,2,5);
            //方式6
            String str = "abcdefg";
            String s6 = new String(str);
            //方式7
            String s7 = s6;
            System.out.println("s1 = "+ s1);
            System.out.println("s2 = "+ s2);
            System.out.println("s3 = "+ s3);
            System.out.println("s4 = "+ s4);
            System.out.println("s5 = "+ s5);
            System.out.println("s6 = "+ s6);
            System.out.println("s7 = "+ s7);
        }
    }

运行结果如图6-1所示。

图6-1 运行结果

三、实验总结  
上面介绍过了String类的常用构造方法，一般情况下，常用的创建String对象的方式如下所示：  
String str1 = “string”;  
String str2 = new String(“string”);  
这两种创建方式是有区别的，这和java的内存管理有关。因为String对象创建后不可变，所以按照第一种方式创建的字符串会放在栈里，更确切的是常量池中，常量池就是用来保存在编译阶段确定好了大小的数据，一般我们定义的int等基本数据类型就保存在这里。  
使用第一种创建字符串的方法时，编译器首先检查常量池，看看有没有一个“string”，如果没有则创建。如果有的话，则直接把str1指向那个位置。  
而第二种创建字符串的方法是通过new关键字，java会将new的对象放在堆中，这一部分对象是在运行时创建的对象。所以我们每一次new的时候，即便堆中已经有了一个一模一样的，都会创建不同的对象。接下来，通过一个例子来演示这两种创建字符串方式的区别。

public class Example {
        
    	public static void main(String[] args) {
        
    		String str1 = "string";
    		String str2 = new String("string");
    		String str3 = new String("string");
    		String str4 = "string";
    
    		/* 用于测试两种创建字符串方式的区别 */
    		System.out.println("(str1 == str4): "+(str1 == str4));
    		System.out.println("(str2 == str3): "+(str2 == str3));
    		System.out.println("(str3 == str1): "+(str3 == str1));	}
    }

运行结果如图6-2所示。

图6-2 运行结果  
实验6-2 字符串的判断操作  
一、实验描述  
1、 考核知识点  
名称：String类的常见操作  
2、 练习目标  
 掌握如何使用String类中的判断方法对字符串进行操作。  
3、 需求分析  
String类中提供了许多对字符串进行判断操作的方法，每个判断操作都有其自己的使用场景，为了让初学者能快速熟悉每个判断方法的用法，本实验将针对不同场景使用不同的判断方法，并根据判断操作输出的结果进行对比学习。  
4、 设计思路（实现原理）

1.  编写Example02类。
2.  在main()方法中，使用String类中的几种常见判断操作方法，依次实现对字符串的判断操作。定义String s = “HelloWorld”;判断s是否和HelloWorld相等，（不区分大小写）字符串s是否和’helloworld’相等，字符串s中是否包含’or’，字符串s是否以’Hel’开头，字符串s是否为空。
3.  将判断结果输出，根据打印结果，熟悉不同判断方法的作用。  
    二、实验实现

package Example02;
    
    public class Example02 {
        
        public static void main(String[] args) {
        
            String s = "HelloWorld";
            System.out.println(s == "HelloWorld" ? "s == HelloWorld" : "s != HelloWorld");
            System.out.println(s == "hellohorld" ? "s == hellohorld" : "s != hellohorld");
            System.out.println(s.contains("or") ? "s 包含'or'" : "s 不包含'or'");
            System.out.println(s.startsWith("Hel") ? "s 以'Hel'开头" : "s 不以'Hel'开头");
            System.out.println(s.isEmpty() ? "s 为空" : "s 不为空");
        }
    }

运行结果如图6-3所示。

图6-3 运行结果  
三、实验总结  
equals()方法比较的是两个字符串的引用是否相同；而“”比较的是两个对象的地址是否相同。接下来，通过一个例子来对比 “”和“equals”的区别。

public class Example {
        
    	public static void main(String[] args) {
        
    		String s1 = "Monday";
    		String s2 = new String("Monday");
    		if (s1 == s2) {
        
    			System.out.println("s1 == s2");
    		} else {
        
    			System.out.println("s1 != s2");
    		}
    		if (s1.equals(s2)) {
        
    			System.out.println("s1 equals s2");
    		} else {
        
    			System.out.println("s1 not equals s2");
    		}
    	}
    }

运行结果如图6-4所示。

图6-4 运行结果  
在上述代码中，==比较的是地址值，equals()方法比较的是字符串的引用。  
实验6-3 字符串的获取操作  
一、实验描述  
1、 考核知识点  
名称：String类的常见操作  
2、 练习目标  
 掌握如何使用String类的获取方法对字符串进行操作。  
3、 需求分析  
String类中提供了许多对字符串进行获取操作的方法，每个获取操作方法都有其各自的使用场景，为了让初学者能快速熟悉每个获取方法的用法，本实验将针对不同场景使用不同的获取方法，并根据获取结果进行参照学习。  
4、 设计思路（实现原理）

1.  编写Example03类。
2.  在main()方法中，使用String类中几种常见的获取方法，依次实现对字符串的获取操作。定义String s = “HelloWorld”; 获取：字符串s的长度，字符串s中第3个字符，字符串s中第一次出现’l’字符的索引，从字符串s的第5个字符开始，出现字符’l’的索引，字符串s中第5个字符到结尾组成的新字符串，字符串s中由第5个到第9个字符组成的新串。
3.  将获取结果输出，根据打印结果，熟悉不同获取方法的作用。  
    二、实验实现

package Example03;
    
    public class Example03 {
        
        public static void main(String[] args) {
        
            String s = "HelloWorld";
            int len = s.length();
            System.out.println("s的长度:"+len);
            char c = s.charAt(2);
            System.out.println("字符串s中第3个字符:"+c);
            int a1 = s.indexOf('l');
            System.out.println("字符串s中第一次出现'l'字符的索引:"+a1);
            int a2 = s.indexOf('l',4);
            System.out.println("从字符串s的第5个字符开始，出现字符'l'的索引:"+a2);
            String s1 = s.substring(4);
            System.out.println("字符串s中第5个字符到结尾组成的新字符串:"+s1);
            String s2 = s.substring(4,8);
            System.out.println("字符串s中由第5个到第9个字符组成的新串:"+s2);
        }
    }

运行结果如图6-5所示。

图6-5 运行结果  
从运行结果可知，字符串中索引的大小是从0开始的，其他方法运行正常。  
三、 实验总结  
访问字符串中的字符时，不能超出字符的索引范围，否则会出现图6-6所示的异常。

图6-6 运行结果  
实验6-4 字符串的转换和拼接操作  
一、实验描述  
1、 考核知识点  
名称：String类的常见操作  
2、 练习目标  
 掌握如何使用String类的转换和拼接方法对字符串进行操作  
3、 需求分析  
String类中提供了许多对字符串进行转换和拼接操作的方法，每个转换或拼接操作都有其各自的作用，为了让初学者能快速熟悉转换和拼接方法的用法，本实验将针对不同需求使用不同的转换和拼接方法，并根据输出结果进行参照学习。  
4、 设计思路（实现原理）

1.  编写Example04类。
2.  在main()方法中，使用String类中的转换和拼接方法，对字符串操作。定义String s = “HelloWorld”; 将字符串s转换为字符数组char \[\] chs，遍历chs数组，定义char\[\] chs2 = \{ ‘a’, ‘b’, ‘c’, ‘中’, ‘国’ \};通过String类的copyValueof()方法将字符数组chs2转换成字符串，通过String类的valueOf ()方法将字符数组chs2转换成字符串，定义int i = 100; 通过String类的valueOf ()方法将int类型的100转换成字符串，输出字符串s的小写形式，输出字符串s的大写形式， 字符串s拼接’world’后，输出生成的新字符串。
3.  将操作结果输出，根据打印结果，熟悉上述转换和拼接方法的作用。  
    二、实验实现

package Example04;
    
    import static java.lang.String.*;
    
    public class Example04 {
        
        public static void main(String[] args) {
        
            String s = "HelloWorld";
            char[] chs = s.toCharArray();
            System.out.println("chs数组:");
            for(int i = 0; i < s.length(); i++){
        
                System.out.print(chs[i] + ' ');
            }
            System.out.println();
            char[] chs2 = {
         'a', 'b', 'c', '中', '国' };
            String s1 = copyValueOf(chs2);
            System.out.println("通过String类的copyValueof()方法将字符数组chs2转换成字符串:"+s1);
            String s2 = valueOf(chs2);
            System.out.println("通过String类的valueOf ()方法将字符数组chs2转换成字符串:"+s2);
            int i = 100;
            String s3 = valueOf(i);
            System.out.println("通过String类的valueOf ()方法将int类型的100转换成字符串:"+s3);
            System.out.println("输出字符串s的小写形式:"+s.toLowerCase());
            System.out.println("输出字符串s的大写形式:"+s.toUpperCase());
        }
    }

运行结果如图6-7所示。

图6-7 运行结果  
从运行结果可知，copyValueOf(char\[\] chs)方法和new String(char\[\] chs)方法都可以将一个字符数组 转换成字符串，并且其他的方法运行正常。  
三、实验总结  
valueOf()方法有很多重载的形式，float、double、char等其它基本类型的数据都可以通过该方法转为String字符串类型。  
实验6-5 字符串的替换、切割等其他操作  
一、实验描述  
1、 考核知识点  
名称：String类的常见操作  
2、 练习目标  
 掌握如何使用String类的替换、切割等方法对字符串进行操作  
3、 需求分析  
String类中提供了许多对字符串进行替换、切割操作的方法，其中每个方法都有其各自的作用，为了让初学者能快速熟悉替换、切割方法的用法，本实验将针对不同需求使用不同的替换、切割方法，并根据输出结果进行参照学习。  
4、 设计思路（实现原理）

1.  编写Example03类。
2.  在main()方法中，使用String类中的替换和切割等方法，对字符串的操作。定义String s = “helloworld”; 将字符串s中的字符l替换成p，将字符串s中的字符ll替换成ak47，定义String ages = “20-30”; 将ages拆分成两个字符串”20”和”30”，定义String name = " admin hello ";输出去掉首尾空格后的字符串name，定义String s1 = “hello”; String s2 = “aello”;按照默认字典的顺序比较字符串s1和s2。
3.  将操作结果输出，根据打印结果，熟悉上述替换和切割方法的作用。  
    二、实验实现

package Example05;
    
    public class Example05 {
        
        public static void main(String[] args) {
        
            String s = "helloworld";
            System.out.println("s = "+s);
            System.out.println("将字符串s中的字符l替换成p:"+s.replace('l','p'));
            System.out.println("将字符串s中的字符ll替换成ak47:"+s.replaceAll("ll","ak47"));
            String ages = "20-30";
            System.out.println("ages1 = "+ages.substring(0,2)+"  ages2 = "+ages.substring(3,5));
            String name = "  admin hello      ";
            System.out.println("去掉首尾空格后的字符串name:"+name.trim());
            String s1 = "hello"; String s2 = "aello";
            System.out.println(s1.compareTo(s2));
        }
    }

运行结果如图6-8所示。

图6-8 运行结果

三、实验总结  
1、trim()方法只能去除两端的空格，不能去除中间的空格。若想去除字符串中间的空格，则可以调用String类的replace()方法。  
2、compareTo()的返回值是整型，它是先比较对应字符的大小(ASCII码顺序)。如果第一个字符和参数的第一个字符不等，则结束比较并返回他们之间的差值；如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推。直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。  
实验6-6 StringBuffer类的添加和删除操作  
一、实验描述  
1、 考核知识点  
名称：StringBuffer类  
2、 练习目标  
 掌握String和StringBuffer的区别。  
 掌握如何使用StringBuffer对象的添加和删除方法操作字符序列。  
3、 需求分析  
StringBuffer类有很多操作字符的方法，其中append()和insert()是常用的添加字符方法，delete()是常用的删除字符方法。为了让初学者对StringBuffer类中的添加、删除方法有更深入的了解，本实验将演示StringBuffer对象的添加、删除操作。  
4、 设计思路（实现原理）

1.  编写Example06类。
2.  在main()方法中，使用StringBuffer类中的方法，依次实现字符序列的添加和删除操作。定义StringBuffer sb = new StringBuffer();使用StringBuffer的添加方法append添加100，”hello”，true，12.5，在sb的第9个位置插入’world’字符串，删除sb中第2个位置的字符，删除sb中第6个到第11个字符。
3.  将添加和删除操作的结果输出，根据打印结果，熟悉各个方法的作用。  
    二、实验实现

package Example06;
    
    public class Example06 {
        
        public static void main(String[] args) {
        
            StringBuffer sb = new StringBuffer();
            sb.append(100);
            System.out.println("添加100:"+sb);
            sb.append("hello");
            System.out.println("添加 hello:"+sb);
            sb.append(true);
            System.out.println("添加 true:"+sb);
            sb.append(12.5);
            System.out.println("添加 12.5:"+sb);
            sb.insert(9,"world");
            System.out.println("在sb的第9个位置插入'world'字符串:"+sb);
            sb.deleteCharAt(1);
            System.out.println("删除sb中第2个位置的字符:"+sb);
            sb.delete(6,10);
            System.out.println("删除sb中第6个到第11个字符:"+sb);
        }
    }

运行结果如图6-9所示。

图6-9 运行结果  
三、实验总结  
1、访问StringBuffer对象中的字符时，不能超出字符的索引范围，否则会出现异常，这与数组中的角标越界异常非常相似。  
2、思考一下：String类和StringBuffer类同样是操作字符串的相关类，那么他们有什么不同之处呢？  
a) String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuffer表示字符容器，其内容和长度都可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。  
b) String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法，具体示例如下：  
String s1 = new String(“abc”);  
String s2 = new String(“abc”);  
System.out.println(s1.equals(s2)); // 打印结果为true  
StringBuffer sb1 = new StringBuffer(“abc”);  
StringBuffer sb2 = new StringBuffer(“abc”);  
System.out.println(sb1.equals(sb2)); // 打印结果为false  
c) String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能，具体示例如下：  
String s1 = “a”;  
String s2 = “b”;  
String s3 = s1+s2; // 合法  
System.out.println(s3); // 打印输出 ab  
StringBuffer sb1 = new StringBuffer(“a”);  
StringBuffer sb2 = new StringBuffer(“b”);  
StringBuffer sb3 = sb1+sb2; // 编译出错  
实验6-7 StringBuffer类的替换、截取和反转操作  
一、实验描述  
1、 考核知识点  
名称：StringBuffer类  
2、 练习目标  
 掌握如何使用StringBuffer对象的替换、截取和反转方法操作字符序列。  
3、 需求分析  
StringBuffer类有很多操作字符的方法，其中replace(int start, int end, String str)是用来替换字符的方法；substring(int start) 和substring(int start, int end)是用来截取字符的方法；reverse()是用来反转字符顺序的方法。为了让初学者快速的熟悉上述方法的作用，本实验将根据这些方法，演示字符序列的替换、截取和反转操作。  
4、 设计思路（实现原理）

1.  编写Example07类。
2.  在main()方法中，通过StringBuffer类的替换、截取和反转等方法依次实现对字符序列的操作。定义StringBuffer sb = new StringBuffer();追加字符串"hello"，“world”，“java”，使用replace()方法替换"world"为"林青霞"，使用substring()方法截取"hello"之后的字符串，使用reverse()方法反转字符串。
3.  将替换、截取和反转操作的结果输出，根据打印结果，加深不同方法的理解。  
    二、实验实现

package Example07;
    
    public class Example07 {
        
        public static void main(String[] args) {
        
            StringBuffer sb = new StringBuffer();
            sb.append("hello");
            sb.append("world");
            sb.append("java");
            System.out.println("追加字符串\"hello\"，\"world\"，\"java\":"+sb);
            sb.replace(5,10,"林青霞");
            System.out.println("使用replace()方法替换\"world\"为\"林青霞\":"+sb);
            System.out.println("使用substring()方法截取\"hello\"之后的字符串:"+sb.substring(5));
            sb.reverse();
            System.out.println("使用reverse()方法反转字符串"+sb);
        }
    }

运行结果如图6-10所示。

图6-10 运行结果  
三、实验总结  
StringBuffer类的截取方法substring(int start)、substring(int start, int end)的返回值是String类型。而其它添加、删除、替换、反转方法的返回值都是Stringbuffer类型的。  
实验6-8 System类的常用方法  
一、实验描述  
1、 考核知识点  
名称：System类  
2、 练习目标  
 掌握System类中获取时间和复制数组以及关闭Java虚拟机的方法。  
3、 需求分析  
System类定义了一些与系统相关的属性和方法，其中包括终止当前正在运行Java虚拟机、以毫秒单位获取当前时间、复制数组等功能。为了让初学者更加深入的了解System类的作用，本实验将演示使用System类的方法获取系统属性和当前时间的操作。  
4、 设计思路（实现原理）

1.  编写Example08类。
2.  在main()方法中，通过调用System类的常用方法，依次实现获取系统信息的操作。获取：系统当前时间，定义int\[\] arr = \{ 1, 2, 3, 4, 5 \}; int\[\] arr2 = \{ 5, 6, 7, 8, 9 \};使用System.arraycopy方法将arr的中后两个元素拷贝给arr2的相同位置，使用System.exit方法退出虚拟机，观察System.exit方法后面的输出“Helloworld”语句是否会执行。
3.  将获取到的系统信息输出，根据打印结果，熟悉System类中常用方法的作用。  
    二、实验实现

package Example08;
    import java.lang.System;
    import java.util.Arrays;
    
    public class Example08{
        
        public static void main(String[] args) {
        
            int[] arr = {
         1, 2, 3, 4, 5 };
            int[] arr2 = {
         5, 6, 7, 8, 9 };
            System.arraycopy(arr,3,arr2,3,2);
            System.out.println("使用System.arraycopy方法将arr的中后两个元素拷贝给arr2的相同位置:");
            for(int i = 0; i < 5; i++){
        
                System.out.println(arr2[i]+" ");
            }
            System.out.println();
            System.exit(0);
            System.out.println("Helloworld");
        }
    }

运行结果如图6-11所示。

图6-11 运行结果  
从图6-11中可以看出，控制台没有打印“Helloworld”，说明System的exit()方法起到了终止Java虚拟机运行的功能。  
三、 实验总结  
System类中所提供的属性和方法都是静态的，因此，想要引用这些属性和方法，需要使用System类直接调用。  
实验6-9 Runtime类的常用方法  
一、实验描述  
1、 考核知识点  
名称：Runtime类  
2、 练习目标  
 掌握Runtime对象的获取方法。  
 熟练使用Runtime对象的exec()方法执行dos命令。  
3、 需求分析  
Runtime类中提供了一个exec()方法，该方法用于执行一个dos命令，从而实现和在命令行窗口中输入dos命令同样的效果。为了让初学者能够熟悉Runtime中常用方法的用法，本实验将通过调用Runtime对象的exec()方法演示开启记事本的操作。  
4、 设计思路（实现原理）

1.  编写Example09类。
2.  在main()方法中，通过Runtime类的getRuntime()方法获取Runtime对象r。
3.  调用r对象的exec()方法，使其执行notepad.exe命令并打开记事本。  
    二、实验实现

package Example09;
    import java.io.IOException;
    import java.lang.*;
    
    public class Example09 {
        
        public static void main(String[] args)  {
        
            Runtime r = Runtime.getRuntime();
            System.out.println(r);
            try{
        
                r.exec("notepad.exe");
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

运行结果如图6-12所示。

图6-12 运行结果  
三、实验总结  
Runtime类用于表示虚拟机运行时的状态，它用于封装JVM虚拟机进程。每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此该类采用单例模式进行编写，对象不可以直接实例化，需要通过Runtime.getRuntime()方法获取。  
实验6-10 Math类的常用方法  
一、实验描述  
1、 考核知识点  
名称：Math类  
2、 练习目标  
 掌握Math类中一些常用的数学运算方法，例如求绝对值、三角函数等。  
3、 需求分析  
在程序开发中，会遇到一些对数字进行运算处理的情况。这时，可以通过Java API提供的Math类，实现对数字的运算处理。为了让初学者能熟悉Math类的常用方法，在实验中将列举常用的数学运算，并依次输出运算结果。  
4、 设计思路（实现原理）

1.  编写Example10类。
2.  在main()方法中分别使用Math类的常用方法操作数字运算。输出：π的值，自然对数的底数，3的绝对值，27的立方根，16的平方根，4的平方，12.345使用ceil方法后的结果，-12.345使用floor方法后的结果，3个01之间的随机数，3个1100之间的随机数。
3.  分别将表达式的运算结果输出。  
    二、实验实现

package Example10;
    import java.lang.Math;
    
    public class Example10 {
        
        public static void main(String[] args) {
        
            System.out.println("π = "+Math.PI);
            System.out.println("自然对数的底数:"+Math.E);
            System.out.println("3的绝对值:"+Math.abs(3));
            System.out.println("27的立方根:"+Math.pow(27,1.0/3.0));
            System.out.println("16的平方根:"+Math.sqrt(16));
            System.out.println("4的平方:"+Math.pow(4,2));
            System.out.println("12.345使用ceil方法后的结果:"+Math.ceil(12.345));
            System.out.println("-12.345使用floor方法后的结果:"+Math.ceil(-12.345));
            System.out.println("3个0~1之间的随机数:");
            for(int i = 0; i < 3; i++){
        
                System.out.println(Math.random() + " ");
            }
            System.out.println();
    
            System.out.println("3个1~100之间的随机数:");
            for(int i = 0; i < 3; i++){
        
                System.out.println(100*Math.random()%100+1 + " ");
            }
            System.out.println();
        }
    }

运行结果如图6-13所示。

图6-13 运行结果  
三、实验总结  
Math的round()方法用于对某个小数进行四舍五入，此方法会将小数点后面的数字全部忽略，返回一个int值。而ceil()方法和floor()方法返回的都是double类型的数，这个数在数值上等于一个整数。  
实验6-11 Random类的常用方法  
一、实验描述  
1、 考核知识点  
名称：Random类  
2、 练习目标  
 掌握如何使用Random类中的方法创建随机数。  
3、 需求分析  
在Java API中提供了一个Random类，它包含多种随机产生数字的方法。为了让初学者能够掌握Random类每个随机方法的不同，在实验中使用Random类中的不同方法随机生成数字，并根据两输出结果来对比学习。  
4、 设计思路（实现原理）

1.  编写Example11类。
2.  在main()方法中，通过Random的无参构造方法，创建Random对象r。
3.  编写两个for循环，在第一个循环体内，调用r对象的nextInt()方法生成随机数，并打印该随机数；在第二个循环体内，调用r对象的nextInt(10)方法，生成10以内的随机数，同样也打印该随机数。  
    二、实验实现

package Example11;
    import java.util.Random;
    
    public class Example11 {
        
        public static void main(String[] args) {
        
            Random r = new Random();
            System.out.println("调用r对象的nextInt()方法生成随机数:");
            for(int i = 0; i < 3; i++){
        
                System.out.println(r.nextInt());
            }
            System.out.println("调用r对象的nextInt(10)方法生成随机数:");
            for(int i = 0; i < 3; i++){
        
                System.out.println(r.nextInt(10));
            }
        }
    }

运行结果如图6-14所示。

图6-14 运行结果  
三、实验总结  
1、当使用Random类的有参构造方法创建多个Random对象时，如果传入的种子相同，则他们产生随机数的序列是相同的。  
2、Random类的nextInt(100)只能获取0~100之间的int类型的随机数，包括0，但不包括100。  
实验6-12 包装类的基本用法  
一、实验描述  
1、 考核知识点  
名称：包装类  
2、 练习目标  
 掌握包装类的作用和概念。  
 掌握包装类中的常用方法。  
3、 需求分析  
Java API针对八种基本类型提供了八种包装类来实现各种高级功能，比如说，某基本类型的范围判断，整数的进制转换等。为了让初学者能够熟悉包装类的基本用法，在实验中列举出包装类常用方法并输出结果。  
4、 设计思路（实现原理）

1.  编写Example12类。
2.  在main()方法中分别使用Integer类的属性和方法获取Integer类型的取值范围和进制间的转换结果。输出：int范围的最大值，int范围的最小值，把60转变成二进制，八进制，十六进制。
3.  分别将包装类的取值范围和转换结果输出。  
    二、实验实现

package Example12;
    import java.lang.Integer;
    
    public class Example12 {
        
        public static void main(String[] args) {
        
            Integer int_max = Integer.MAX_VALUE;
            System.out.println("int范围的最大值:"+int_max);
            Integer int_min = Integer.MIN_VALUE;
            System.out.println("int范围的最小值:"+int_min);
            System.out.println("60的二进制 = "+Integer.toBinaryString(60));
            System.out.println("60的八进制 = "+Integer.toOctalString(60));
            System.out.println("60的十六进制 = "+Integer.toHexString(60));
        }
    }

运行结果如图6-15所示。

图6-15 运行结果  
三、实验总结  
Java语言是一个面向对象的语言，但java中的基本数据类型却不是面向对象的，它通过包装类可以将基本数据类型的值包装为引用数据类型的对象。

实验6-13 包装类的装箱和拆箱  
一、实验描述  
1、 考核知识点  
名称：包装类  
2、 练习目标  
 掌握包装类的装箱和拆箱概念  
3、 需求分析  
包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型，反之，拆箱是指将引用数据类型的对象转为基本数据类型。为了让初学者增加对包装类的装箱和拆箱功能的理解，本实验将演示基本数据类型和包装类的装箱和拆箱的效果。  
4、 设计思路（实现原理）

1.  编写Example13类。
2.  在main()方法中，利用Integer的构造方法和intValue()方法，实现int类型数据100的装箱和拆箱操作。
3.  分别将装箱和拆箱的结果输出，根据打印结果熟悉装箱和拆箱之间的区别。  
    二、实验实现

package Example13;
    
    public class Example13 {
        
        public static void main(String[] args) {
        
            Integer i = new Integer(10);
            int j = i.intValue();
            System.out.println("i = "+i);
            System.out.println("j = "+j);
        }
    }

运行结果如图6-16所示。

图6-16 运行结果  
三、实验总结  
1、包装类的装箱和拆箱实质上是基本数据类型和引用数据类型相互转换的过程。  
实验6-14 包装类的自动装箱和拆箱  
一、实验描述  
1、 考核知识点  
名称：包装类  
2、 练习目标  
 掌握包装类中自动装箱和拆箱技术。  
3、 需求分析  
在JDK5.0的版本中提供了自动拆箱和装箱技术，也就是可以自动进行基本数据类型和包装类对象之间的转换。为了让初学者增加对包装类的自动装箱和拆箱功能的理解，接下来通过一个实验实现了包装类的自动装箱和拆箱功能。  
4、 设计思路（实现原理）

1.  编写Example14类。
2.  在main()方法中，使用Integer对象进行基本的数学运算操作，并打印出运算后的结果。  
    二、实验实现

package Example14;
    
    public class Example14 {
        
        public static void main(String[] args) {
        
            Integer i1 = 10;
            Integer i2 = 11;
            int i = i1+i2;
            System.out.println(i);
        }
    }

运行结果如图6-17所示。

图6-17 运行结果  
三、实验总结  
1、 包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。  
2、 除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。具体示例如下：  
Integer i = Integer.valueOf(“123”); // 合法  
Integer i = Integer.valueOf(“12a”); // 不合法  
3、 除了Character外，包装类都有parseXXX(String s)的静态方法，将字符串转换为对应的基本类型的数据。参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。具体示例如下：  
int i = Integer.parseInt(“123”); // 合法  
Integer in = Integer.parseInt(“itcast”);// 不合法  
4、 在使用包装类对象时，要注意该对象是否为null。  
实验6-15 Date类的构造方法  
一、实验描述  
1、 考核知识点  
名称：Date类  
2、 练习目标  
 掌握Date类的作用以及概念。  
 掌握如何通过Date类的构造方法创建Date对象。  
3、 需求分析  
在Java API中提供了一个Date类用于表示日期和时间。Date类中大部分构造方法都被声明为已过时，只有两个构造方法是建议使用的。为了让初学者了解这两个构造方法的用法，本实验将通过Date类的构造方法创建2个Date对象，并打印他们对应的值。  
4、 设计思路（实现原理）

1.  编写Example15类。
2.  在main()方法中，分别利用Date的两个构造方法创建两个Date对象，并打印Date对象的值。  
    二、实验实现

package Example15;
    
    import java.util.Date;
    
    public class Example15 {
        
        public static void main(String[] args) {
        
            //方式一
            Date d1 = new Date();
            System.out.println("当前日期："+d1);
            //方式二
            Date d2 = new Date(0);
            System.out.println("0时的日期："+d2);
        }
    }

运行结果如图6-18所示。

图6-18 运行结果  
三、实验总结  
由于Date类在设计之初，没有考虑国际化的问题，因此从 JDK 1.1 开始，Date类中相应的功能被Calendar类中的方法取代了。那么，对于Date类，只需要了解如何通过创建对象封装时间值即可  
实验6-16 Calendar类的常用方法  
一、实验描述  
1、 考核知识点  
名称：Calendar类  
2、 练习目标  
 掌握Calendar类的作用以及概念。  
 掌握如何使用Calendar类的常用方法。  
3、 需求分析  
从JDK1.1开始，Calendar类逐渐取代了Date类，Calendar类包含了大量操作日期和时间的方法。为了让初学者熟练掌握Calendar类中方法的用法，本实验将通过这些方法求出1998年2月份的天数。  
4、 设计思路（实现原理）

1.  编写Example16类。
2.  在main()方法中，通过静态方法getInstance()创建一个Calendar对象。
3.  将Calendar对象的日期设置为1998年3月1日。
4.  将Calendar对象表示的日期向前推1日，即1998年2月的最后一天。
5.  打印2月的最后一天的数字，即1998年2月份的天数。

二、实验实现

package Example16;
    
    import java.util.Calendar;
    
    public class Example16 {
        
        public static void main(String[] args) {
        
            Calendar c = Calendar.getInstance();
            System.out.println("通过静态方法getInstance()创建一个Calendar对象:"+c.getTime());
            c.set(1998,3,1);
            System.out.println("将Calendar对象的日期设置为1998年3月1日:"+c.getTime());
            c.add(Calendar.DATE,-1);
            System.out.println("将Calendar对象表示的日期向前推1日:"+c.getTime());
            System.out.println("打印2月的最后一天的数字，即1998年2月份的天数:"+c.get(Calendar.DATE));
        }
    }

运行结果如图6-19所示。

图6-19 运行结果  
三、实验总结  
由于Calendar对象记录月份的角标是从0开始的。因此，使用Calendar对象的set方法设置日期时，月份的数字需要减1。  
实验6-17 Date和String之间的转换（DateFormat）  
一、实验描述  
1、 考核知识点  
名称：DateFormat类  
2、 练习目标  
 掌握如何使用DateFormat类中的方法实现日期和特定格式字符串之间的转换。  
3、 需求分析  
DateFormat类中提供了日期和特定格式字符串之间转换的方法。为了让初学者掌握转换方法的使用，在实验中针对两种不同的转换方式，依次演示Date对象转换成字符串以及字符串转换成Date对象的效果。  
4、 设计思路（实现原理）

1.  编写Example17类。
2.  在main()方法中，分别编写特定格式字符串与Data对象之间相互转换的过程。定义String date1 = “2014-5-31”;通过DateFormat的静态方法getDateInstance()方法获取Dateformat实例对象，将字符串格式的日期date1转成Date类型的对象d1，输出d1，通过DateFormat的静态方法getDateTimeInstance()方法获取Dateformat实例对象，定义Date d2 = new Date();将Date类型变量d2转换成年月日时分秒的字符串形式s，输出s。
3.  将转换后的结果输出。  
    二、实验实现

package Example17;
    
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.util.Date;
    
    public class Example17 {
        
        public static void main(String[] args) throws ParseException {
        
            String date1 = "2020年10月27日";
            DateFormat df1 = DateFormat.getDateInstance();
            DateFormat df2 = DateFormat.getDateTimeInstance();
    
            Date d1 = df1.parse(date1);
            System.out.println("将字符串格式的日期date1转成Date类型的对象d1: "+d1);
    
            Date d2 = new Date();
            String s = df2.format(d2);
            System.out.println("将Date类型变量d2转换成年月日时分秒的字符串形式s: "+s);
        }
    }

运行结果如图6-20所示。

图6-20 运行结果  
三、实验总结  
DateFormat类专门用于将日期格式化为字符串或者将用特定格式显示的日期字符串转换成一个Date对象。DateFormat是抽象类，不能被直接实例化，但它提供了静态方法，通过这些方法可以获取DateFormat类的实例对象，并调用其它相应的方法进行操作，DateFormat类中提供的常用方法如表6-1所示。  
表6-1 DateFormat的常用方法  
方法声明 功能描述  
static DateFormat getDateInstance() 用于创建默认语言环境和格式化风格的日期格式器  
static DateFormat getDateInstance(int style) 用于创建默认语言环境和指定格式化风格的日期格式器  
static DateFormat getDateTimeInstance() 用于创建默认语言环境和格式化风格的日期/时间格式器  
static DateFormat getDateTimeInstance(  
int dateStyle,int timeStyle) 用于创建默认语言环境和指定格式化风格的日期/时间格式器  
String format(Date date) 将一个 Date 格式化为日期/时间字符串。  
Date parse(String source) 将给定字符串解析成一个日期  
在表6-1中，DateFormat的parse(String source)方法，能够将一个字符串解析成Date对象，但是它要求字符串必须符合日期/时间的格式要求，否则会抛出ParseException异常。  
实验6-18 Date和String之间的转换（SimpleDateFormat）  
一、实验描述  
1、 考核知识点  
名称：SimpleDateFormat类  
2、 练习目标  
 掌握如何使用SimpleDateFormat类定义一个日期-时间格式的模板。  
 掌握如何使用SimpleDateFormat类中的方法实现Date对象和String对象之间的转换。  
3、 需求分析  
SimpleDateFormat类是DateFormat类的子类，该类灵活的实现Date对象和String对象之间的转换。为了让初学者掌握SimpleDateFormat类中转换方法的使用，在实验中针对两种不同的转换方式，依次演示Date对象转换成字符串以及字符串转换成Date对象的效果。  
4、 设计思路（实现原理）

1.  编写Example18类。
2.  在main()方法中，分别编写自定义日期模板字符串和Date对象之间的相互转换过程。创建日期对象Date d = new Date();按照自定义的字符串形式"yyyy年MM月dd日 HH:mm:ss"格式化当前日期并输出，定义String s = “2016-12-12 23:12:34”;按照自定义的字符串的格式"yyyy-MM-dd HH:mm:ss"将s解析成Date形式并输出。
3.  分别将转换后的结果输出。  
    二、实验实现

package Example18;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class Example18 {
        
        public static void main(String[] args) throws ParseException {
        
            Date d = new Date();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String s = sdf1.format(d);
            System.out.println("按照自定义的字符串形式\"yyyy年MM月dd日 HH:mm:ss\"格式化当前日期并输出: "+s);
    
            String date1 = "2016-12-12 23:12:34";
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d1 = sdf2.parse(date1);
            System.out.println("按照自定义的字符串的格式\"yyyy-MM-dd HH:mm:ss\"将s解析成Date形式并输出: "+d1);
        }
    }

运行结果如图6-21所示。

图6-21 运行结果  
三、实验总结  
使用DateFormat对象将字符串解析为日期时，需要输入固定格式的字符串；使用DateFormat对象将日期转换成字符串时，输出的都是固定格式的日期，这些显然不够灵活。而使用SimpleDateFormat对象实现字符串和日期之间的相互转换时，只需要在创建SimpleDateFormat对象时，传入该字符串的日期格式模板，然后调用parse()或format()方法即可实现日期和字符串之间的灵活转换。