下载文档原格式
java中常用的键值类型1.引言1.1 概述概述：在Java编程语言中，键值类型是一种非常常见且重要的数据结构。
它们用于存储和访问键值对（key-value）数据，其中键（key）是用于唯一标识数据的标识符，值（value）则是与该键相关联的数据。
这种数据结构在实际应用中非常有用，特别是在需要快速访问、查找和更新数据的场景下。
在Java中，常用的键值类型包括HashMap、LinkedHashMap、TreeMap、Hashtable和Properties。
每种类型都有其特定的特点和适用场景，下面将对每种类型进行详细介绍。
（接下来的内容可以分别对HashMap、LinkedHashMap、TreeMap、Hashtable和Properties进行介绍，包括其定义、特点和使用场景等）1.2 文章结构本文将介绍Java 中常用的键值类型，主要包括HashMap、LinkedHashMap、TreeMap、Hashtable 和Properties。
在本文中，将会详细介绍每种键值类型的特点、用法以及适用场景。
正文部分将分成五个小节，分别介绍每种键值类型。
2.1 HashMapHashMap 是Java 中最常用的键值对容器之一。
它基于哈希表的实现，可以提供快速的插入、删除和查找操作。
在HashMap 中，键和值可以为任意对象，但是键是唯一的，而值可以重复。
2.2 LinkedHashMapLinkedHashMap 是HashMap 的一个子类，它除了具有HashMap 的特性外，还维护一个插入顺序的链表。
因此，在遍历LinkedHashMap 时，可以按照插入的顺序获取元素。
这种特性在某些场景下非常有用。
2.3 TreeMapTreeMap 是一个基于红黑树的实现，它可以保持键的有序性。
与HashMap 不同，TreeMap 中的键是按照自然顺序或者自定义的比较器进行排序的。
因此，可以在TreeMap 中按照键的顺序获取元素。
实验报告附页String s7 = new String("123.678");int n1=Integer.parseInt(s6);//将s6转化成int型数据。
double n2=Double.parseDouble(s7); //将s7转化成double型数据。
double m=n1+n2;System.out.println(m);String s8=String.valueOf(m); //String调用valuOf(int n)方法将m转化为字符串对象position=s8.indexOf(".");String temp=s8.substring(position+1);System.out.println("数字"+m+"有"+temp.length()+"位小数") ;@SuppressWarnings("unused")String s9=new String("ABCDEF");char a[]=s8.toCharArray(); //将s8存放到数组a中。
for(int i=a.length-1;i>=0;i--){System.out.print(" "+a[i]);}}}运行结果：将上面程序按如下要求修改，并运行：（1）程序中的s6改写成String s6=new String(“1a12b”);运行时提示怎样的错误？Exception in thread "main" ng.NumberFormatException: For input string: "1a12b"at ng.NumberFormatException.forInputString(Unknown Source)at ng.Integer.parseInt(Unknown Source)at ng.Integer.parseInt(Unknown Source)at xiti2.xiugai.main(xiugai.java:39)（2）请用数组a的前3个单元创建一个字符串并输出该串。
java常用的8种数据类型及取值范围Java是一种面向对象的编程语言，它支持8种基本数据类型，包括整型、浮点型、字符型、布尔型等。
这些数据类型在Java中非常常用，因此我们需要了解它们的取值范围和使用方法。
1. 整型整型是Java中最常用的数据类型之一，它包括四种类型：byte、short、int和long。
其中，byte类型占用1个字节，取值范围为-128到127；short类型占用2个字节，取值范围为-32768到32767；int类型占用4个字节，取值范围为-2147483648到2147483647；long类型占用8个字节，取值范围为-9223372036854775808到9223372036854775807。
2. 浮点型浮点型也是Java中常用的数据类型之一，它包括两种类型：float 和double。
其中，float类型占用4个字节，取值范围为1.4E-45到3.4028235E38；double类型占用8个字节，取值范围为4.9E-324到1.7976931348623157E308。
3. 字符型字符型是Java中表示字符的数据类型，它占用2个字节，取值范围为0到65535。
在Java中，字符型数据使用单引号括起来，例如：'A'、'B'、'C'等。
4. 布尔型布尔型是Java中表示真假值的数据类型，它只有两个取值：true 和false。
在Java中，布尔型数据使用关键字boolean表示。
除了以上四种基本数据类型，Java还支持四种特殊的数据类型：void、String、数组和枚举。
5. void类型void类型表示没有返回值的方法，它通常用于定义方法时指定返回类型为void。
6. String类型String类型表示字符串，它是Java中非常常用的数据类型之一。
在Java中，字符串使用双引号括起来，例如："Hello World"。
java中的几种基本类型Java是一种面向对象的编程语言，它提供了多种基本类型来存储不同的数据。
在本文中，我们将介绍Java中的几种基本类型，并且对它们的特点进行详细解释。
1. 整型（int）：整型是Java中最常用的基本类型之一，用于存储整数。
它的取值范围为-2147483648到2147483647，占用4个字节的内存空间。
整型可以用来表示年龄、身高、数量等等。
在Java中，整型的默认值为0。
2. 浮点型（float和double）：浮点型用于存储带有小数点的数字。
在Java中，有两种浮点类型：float和double。
float类型占用4个字节的内存空间，而double类型占用8个字节的内存空间。
浮点型可以用来表示距离、重量、价格等。
在Java中，浮点型的默认值为0.0。
3. 字符型（char）：字符型用于存储单个字符。
在Java中，字符型采用Unicode编码，占用2个字节的内存空间。
字符型可以用来表示字母、数字、符号等。
在Java中，字符型的默认值为'\u0000'。
4. 布尔型（boolean）：布尔型用于存储真或假的值。
在Java中，布尔型只有两个值：true和false。
布尔型可以用于表示条件的真假、开关的状态等。
在Java中，布尔型的默认值为false。
5. 字节型（byte）：字节型用于存储8位的二进制数据。
在Java中，字节型的取值范围为-128到127，占用1个字节的内存空间。
字节型可以用来表示文件、图像等二进制数据。
在Java中，字节型的默认值为0。
6. 短整型（short）：短整型用于存储较小范围的整数。
在Java中，短整型的取值范围为-32768到32767，占用2个字节的内存空间。
短整型可以用来表示月份、星期等。
在Java中，短整型的默认值为0。
这些基本类型在Java中都有对应的包装类，可以用来进行一些特定的操作，比如类型转换、数学运算等。
基本类型和包装类之间可以通过自动装箱和拆箱来进行转换。
JAVA数组操作的常用工具类在Java中，数组是一种包含固定数量元素的数据结构。
数组操作是在数组中执行各种任务的过程，并且在编程中经常遇到。
为了简化数组操作的过程，Java提供了许多常用的工具类来处理数组。
下面是Java数组操作的常用工具类。
1. Arrays类：Arrays类提供了许多静态方法来处理数组，其中一些常用的方法包括：- sort(：对数组进行排序。
- binarySearch(：在排序后的数组中查找指定元素的索引。
- toString(：将数组转换为字符串。
- equals(：比较两个数组是否相等。
- fill(：将数组的所有元素设置为指定值。
2. System类：System类提供了一些用于操作数组的静态方法，其中一些常用的方法包括：- arraycopy(：将一个数组的部分元素复制到另一个数组。
- identityHashCode(：获取数组的哈希码。
3. Collections类：Collections类是Java集合框架的一部分，但也可以用于处理数组。
其中一些常用的方法包括：- sort(：对数组进行排序。
- binarySearch(：在排序后的数组中查找指定元素的索引。
4. Arrays类与Collection接口转换：Arrays类和Collection接口之间提供了一些静态方法，可以将数组转换为Collection，并将Collection转换为数组。
其中一些常用的方法包括：- asList(：将数组转换为List。
- toArray(：将Collection转换为数组。
- toList(：将Collection转换为List。
5. Arrays类与Stream接口转换：Java 8引入了Stream接口，可以对数组进行处理。
Arrays类提供了一些方法来将数组转换为Stream，并从Stream转换为数组。
其中一些常用的方法包括：- stream(：将数组转换为Stream。
Java中常用的集合类有哪些？它们的使用场景是什么？Java作为目前最为流行的编程语言之一，其优越的面向对象编程思想和强大的类库使其成为了广大编程爱好者和专业开发者的首选语言之一。
在Java开发中，常用的集合类具有广泛的应用场景，可以大大简化我们代码的编写和维护。
在本篇文章中，我们将介绍Java中常用的集合类有哪些，它们的使用场景是什么，以及如何选择合适的集合类来应对各种场景。
一、Java中常用的集合类Java中常用的集合类包括List、Set、Map等，具体如下：1.ListList是Java中最基础和最常用的集合类之一，它是一个有序的集合，可以存储重复的元素。
List提供了一系列的方法用来操作列表中的元素，如添加、删除、获取、修改等。
常见的List有ArrayList 和LinkedList。
2.SetSet是Java中的另一个基础集合类，它是一个无序的集合，不允许存储重复的元素。
Set提供了一系列的方法用来操作集合中的元素，如添加、删除、获取等。
常见的Set有HashSet、TreeSet。
3.MapMap是Java中常用的映射关系集合，它存储键值对，支持通过键来访问值。
Map提供了一系列的方法用来操作映射关系，如添加、删除、获取、修改等。
常见的Map有HashMap、TreeMap、ConcurrentHashMap等。
二、Java中常用集合类的使用场景不同的集合类有不同的使用场景，我们需要根据具体的业务需求来选择合适的集合类。
下面我们来介绍几种常见的使用场景及其对应的集合类。
1.需要随机访问元素的情况：ArrayListArrayList是Java中常用的集合类之一，它支持随机访问，通过索引访问元素的时间复杂度为O(1)，是处理元素数量较大的情况下的较好选择。
2.需要频繁插入或删除元素的情况：LinkedListLinkedList是另一个常用的集合类，它支持快速的插入和删除操作，通过节点互相关联实现。
java的八个基本类型
Java 是一种面向对象的编程语言，它支持八个基本数据类型，分别是 byte、short、int、long、float、double、char 和 boolean。
下面我们将详细介绍这些类型。
1. byte（字节型）
byte 类型用于存储整型数值（-128 到 127），占用一个字节的空间。
byte 类型通常用于处理文件、网络数据和图像等二进制数据。
3. int（整型）
int 类型用于存储整型数值（-2147483648 到 2147483647），占用四个字节的空间。
int 类型是 Java 中最常用的整型类型，可以用于保存整数、枚举和数组下标等数据。
5. float（单精度浮点型）
float 类型用于存储浮点数值，占用四个字节的空间，在数值范围和精度上比
double 类型差。
float 类型通常用于科学计算和图形处理等领域。
7. char（字符型）
char 类型用于存储 Unicode 字符，占用两个字节的空间。
char 类型可以表示所有
的字符和符号，包括汉字和 Emoji 等表情符号。
8. boolean（布尔型）
boolean 类型只有两个取值，true 和 false。
boolean 类型通常用于控制流程和逻
辑处理等场景。
在 Java 中，基本数据类型属于值类型，它们的值存储在变量的内存空间中。
如果你
想修改变量的值，需要重新赋值。
这与引用类型不同，引用类型保存的是指向对象的指
针。
java中的常⽤集合类整理⽬录Collection接⼝集合的遍历:iterator 接⼝集合的遍历:增强for循环List接⼝ArrayListSet接⼝Map接⼝HashMapLinkedHashMapTreeMapPropertiesCollections⼯具类总结集合、数组都是对多个数据进⾏存储操作(主要是内存层⾯存储)的结构，简称Java容器。
数组的特点1.数组初始化以后，长度确定不可变2.数组定义好，其元素的类型确定不可变(可能有多态性)3.数组中提供的⽅法有限，对于添加、删除、插⼊数据等操作不⽅便。
4.获取数组中实际元素的个数是没有办法的。
5.数组存储数据的特点是有序、可重复的。
Java集合可分为Collection和Map两种体系,集合存储的优点是解决数组存储数据⽅⾯的弊端。
Collection接⼝：单列数据，⽤来存储⼀个⼀个的对象List接⼝:元素有序，可重复的集合 --> '动态'数组Set接⼝ :元素⽆序、不可重复的集合Map接⼝：双列数据，保存有映射关系(键值对)的集合Collection接⼝向collection接⼝的实现类的对象中添加数据obj时，要求obj所在类要重写equals⽅法。
Abstract Methodsadd(Object e):将元素e添加到集合中size():获取添加的元素个数addAll(Collection coll):将形参coll集合的元素添加到当前集合中clear():清空集合元素,集合仍然存在，只是集合⾥没有元素isEmpty():判断当前集合是否为空contains(Object obj):判断当前集合中是否包含obj，是否包含是通过调⽤obj的equals判断containsAll(Collection coll):判断形参coll中的所有元素是否都存在当前集合中。
remove(Object obj):移除某个元素，同样通过equals寻找移除的元素removeAll(Collection coll):从当前集合中移除coll集合中所有的元素，需要调⽤equals函数retainAll(Collection coll):求两个集合的交集,结果为修改当前集合后的集合。
Java中常⽤数据类型的输⼊输出详解⽬录1、Char型1.1 输⼊格式：1.2 举例说明2、int型1.1 简单的int格式输⼊：1.2 举例说明2.1带空格的int格式输⼊：2.2 举例说明3.1 复杂int格式的输⼊3.2 举例说明3、double型1.1 double保留两位格式输出1.2 举例说明4、多次输⼊1.1 输⼊格式1.2 举例说明5、数组1.1 数组输⼊格式：2.1 数组转换成字符串6、字符串1.1 字符串转换成整型，浮点型（以整型为例）1.2 整型，浮点型转换成字符串2.1 字符串转换成字符数组2.2 字符数组转换成字符串3 举例说明7、写在最后C语⾔学习完转到Java后，第⼀个感觉就是Java的写法很复杂，同时，在常⽤的数据类型的输⼊输出上也没有C语⾔那么⽅便。
在C语⾔上⾯，⽤ scanf 函数可以很⽅便的输⼊⼤多数格式，在Java上却不⾏，Java当中没有类似于scanf的语句。
本⽂搭配本⼈的输⼊输出习惯及做题的记录，对这些不同类型的如整型的，是整型的但隔开参数的...做⼀个总结。
下⾯的说明中主类均为Main类，我们使⽤Scanner来进⾏输⼊。
每⼀种输⼊或输出可能有多种⽅法，本⼈只写了较为简单的写法。
1、Char型这⾥说的char型指的是只输⼊⼀个字符的情况。
1.1 输⼊格式：import java.io.IOException;//导⼊包public class Main {public static void main(String[] args) throws IOException {char ch = (char)System.in.read();//<1>System.out.println((int)ch);}}说明：需要搭配IOException异常来使⽤。
<1>中，System.in就是从标准输⼊流（最常见的是键盘）输⼊，rand()⽅法是从这个流⾥⾯读取输⼊的内容。
java中8种基本数据类型Java是一种面向对象的编程语言，它支持8种基本数据类型。
这些数据类型是在Java中最基础的数据类型，用于存储各种不同类型的数据。
本文将详细介绍这8种基本数据类型。
一、整型（int）整型是Java中最常用的数据类型之一，它可以存储整数值。
整型变量可以被声明为以下几种：- byte：该变量可以存储-128到127之间的整数。
- short：该变量可以存储-32768到32767之间的整数。
- int：该变量可以存储-2147483648到2147483647之间的整数。
- long：该变量可以存储非常大或非常小的整数，范围为-9223372036854775808到9223372036854775807。
二、浮点型（float和double）浮点型用于表示小数，包括单精度浮点型和双精度浮点型两种。
float：该变量可以存储6到7位小数，并且范围约为1.4e-45到3.4e+38。
double：该变量可以存储15位小数，并且范围约为4.9e-324到1.8e+308。
三、字符型（char）字符型用于表示单个字符，例如字母、数字和标点符号等。
它只能存储一个字符，使用单引号来声明。
四、布尔型（boolean）布尔型用于表示真或假的值。
它只有两个值：true和false。
五、字节型（byte）字节型是Java中最小的数据类型，它可以存储-128到127之间的整数。
它通常用于处理二进制数据，例如图像和声音等。
六、短整型（short）短整型可以存储-32768到32767之间的整数。
它通常用于节省内存空间，例如在数组中存储大量数据时。
七、长整型（long）长整型可以存储非常大或非常小的整数，范围为-9223372036854775808到9223372036854775807。
它通常用于处理时间戳或其他需要精确计算的数据。
八、无符号整型（unsigned int）无符号整型只能存储正数，范围为0到4294967295。
public static void main(String[] args) {String str1;str1 = "你好";// 使用字符串常量构造一个字符串String str2 = new String("你好");// String类中重写了父类Object类的equals方法// String类中的equals方法比较的是字符串的内容// 使用String类中的equals方法时，建议将字符串常量写在前面String str3 = null;System.out.println("你好".equals(str3));//正确写法//System.out.println(str3.equals("你好"));//错误写法// 使用equals方法System.out.println(str1.equals(str2));//trueSystem.out.println(str1 == str2);//false// 使用char数组构造一个字符串char [] ch1 = {'a', 'b', 'c'};String str4 = new String(ch1); System.out.println("str4: " + str4);char [] ch2 = {'a', 'b', 'c', 'd', 'e', 'f'}; String str5 = new String(ch2, 2, 2); System.out.println("str5: " + str5);// 使用byte数组构造一个字符串//byte [] by1 = {-50, 3, 100};byte [] by1 = "测试".getBytes();String str6 = new String(by1); System.out.println("str6: " + str6);// String类中的equals方法和等号String str7 = "西安网星";String str8 = "西安网星";System.out.println(str7.equals(str8));//trueSystem.out.println(str7 == str8);//true// length()：获取字符串的长度System.out.println(str7.length());//4// isEmpty()：判断字符串手不是为空System.out.println(str7.isEmpty());//false// charAt(int index)：获取指定位置上的字符System.out.println(str7.charAt(2));//网// equalsIgnoreCase：忽略大小写比较String str9 = "abccdabc";String str10 = "ABccdabc";System.out.println(str9.equals(str10));//falseSystem.out.println(str9.equalsIgnoreCase(str10));//tru e// startsWith：判断某个字符串以什么开始// endsWith：判断某个字符串以什么结尾System.out.println(str9.startsWith("a"));//trueSystem.out.println(str9.startsWith("a", 2));//falseSystem.out.println(str9.endsWith("c"));//true//String str9 = "abccdabc";// indexOf：从开始位置查找出指定字符串在已有字符串中的位置// lastIndexOf：从结尾位置查找出指定字符串在已有字符串中的位置System.out.println(str9.indexOf("bc"));//1System.out.println(str9.indexOf("ac"));//-1System.out.println(str9.indexOf("bc", 2));//6System.out.println(stIndexOf("ab"));//5System.out.println(stIndexOf("ab", 4));//0// substring：截取字符串，包括指定开始位置本身System.out.println(str9.substring(4));//dabc// substring：截取字符串，包括指定开始位置本身，结束位置不包括System.out.println(str9.substring(4, 7));//dabSystem.out.println(str9.substring(4,str9.length()));//dabcString str11 = "test.jpg";System.out.println(str11.substring(4,str11.length()));//.jpg// concat：连接字符串System.out.println(str9.concat(str11));//abccdabctest.j pgSystem.out.println(str9 + str11);//abccdabctest.jpg// contains：包含某个字符串System.out.println(str11.contains("."));//true// replace：字符串替换System.out.println(str11.replace("test", "my"));//my.jpg// split：分割字符串String str12 = "test.jpg";//String[] strs = str12.split("\\.");String[] strs = str12.split("t");System.out.println(strs.length);for(int i = 0; i < strs.length; i++){System.out.println("strs[" + i + "]=" + strs[i]);//str[0]=aa}// toLowerCase()：转换成小写// toUpperCase()：转换成大写System.out.println(str12.toLowerCase());//test.jpgSystem.out.println(str12.toUpperCase());//TEST.JPG // trim()：去前后空格String str13 = " abc ";System.out.println(str13.length());//5String str14 = str13.trim();System.out.println(str14);System.out.println(str14.length());//3// regionMatches：测试两个字符串区域是否相等。
String str15 = "abcdefghijk";String str16 = "abcdefghijk";boolean flag = str15.regionMatches(0, str16, 0, str16.length());System.out.println("flag: " + flag);//trueflag = str15.regionMatches(1, str16, 1, str16.length() - 1);System.out.println("flag: " + flag);//trueflag = str15.regionMatches(3, str16, 3, 6);//str16="defg"System.out.println("flag: " + flag);//true// 将“数字”组成的字符串转换为基本数据类型int a = Integer.parseInt("1111");System.out.println(a);float f = Float.parseFloat("23.45F");System.out.println(f);double d = Double.parseDouble("11.22");System.out.println(d);// 将基本数据类型转换为字符串String s1 = String.valueOf(a);String s2 = String.valueOf(f);String s3 = String.valueOf(d);/*// equals()// ==A a1 = new A();A a2 = new A();System.out.println(a1.equals(a2));//falseSystem.out.println(a1 == a2);//false*/}}public static void main(String[] args) {// 字符串与字节数组相互转化String s1 = "欢迎来abc到网星!";// 将字符串转换成字节数组byte [] bytes = s1.getBytes();// 将字节数组转换成字符串String s2 = new String(bytes);System.out.println(s2);System.out.println("---------------------");try {// 将字符串转换成字节数组bytes = s1.getBytes("GBK");// ISO-8859-1 UTF-8 GBK// 将字节数组转换成字符串s2 = new String(bytes,"GBK");System.out.println(s2);System.out.println("---------------------");bytes = s1.getBytes("UTF-8");// ISO-8859-1 UTF-8 GBKs2 = new String(bytes,"UTF-8");System.out.println(s2);System.out.println("---------------------");bytes = s1.getBytes("ISO-8859-1");// ISO-8859-1 UTF-8 GBKs2 = new String(bytes,"ISO-8859-1");System.out.println(s2);//乱码} catch (UnsupportedEncodingException e) {e.printStackTrace();}}}public static void main(String[] args) {String s1 = "你好";String s2 = s1.concat("张三");System.out.println(s2);// 动态修改字符串的内容StringBuilder sb1 = new StringBuilder("你好"); sb1.append("张三");System.out.println(sb1);// 获取指定位置上的字符char ch = sb1.charAt(3);//三System.out.println(ch);// 在指定位置插入字符串sb1.insert(2, "干啥");System.out.println(sb1);//你好干啥张三// 字符串反转sb1.reverse();System.out.println(sb1);//三张啥干好你// 在指定位置删除字符串sb1.delete(2, 4);System.out.println(sb1);//三张好你sb1.reverse();// 在指定位置替换字符串sb1.replace(2, 4, "李四");System.out.println(sb1);//你好李四}}public static void main(String[] args) {Date d1 = new Date();System.out.println(d1);//d1.toString()Date d2 = new Date(1000);System.out.println(d2);//d2.toString()Date d3 = new Date(00L);System.out.println(d3);//d3.toString()System.out.println(System.currentTimeMillis());//00 Date d4 = new Date(35L);System.out.println(d4);//d4.toString()// 日期格式化SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss.SSS E");// 将日期类型转换为字符串String dateStr = sdf.format(d4);System.out.println("dateStr: " + dateStr);// 把(日期)字符串转换为日期类型try {Date d5 = sdf.parse(dateStr);System.out.println("d5: " + d5);} catch (ParseException e) {e.printStackTrace();}System.out.println("------------------------------------------");// 日期格式化SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss", );// 将日期类型转换为字符串String dateStr1 = sdf1.format(d4);System.out.println("dateStr1: " + dateStr1);public static void main(String[] args) {//c产生绝对值System.out.println(m);double d1 = Math.random();System.out.println(d1);// 产生1到8之间的随机数int n = (int)(Math.random() * 8) + 1;System.out.println(n);// 产生1到100之间的随机数n = (int)(Math.random() * 100) + 1;System.out.println(n);int a = Math.round(3.5643F);System.out.println("a: " + a);a = Math.round(3.4643F);System.out.println("a: " + a);double d2 = Math.sqrt(8);//求平方根System.out.println("d2: " + d2);System.out.println("--------------------------");// 数字格式化：普通数字、百分比、货币形式NumberFormat nFormat = NumberFormat.getInstance();nFormat.setMaximumFractionDigits(7);//设置小数部分的最大位数nFormat.setMinimumIntegerDigits(3);//设置整数部分的最小位数String s = nFormat.format(d2);System.out.println("8的平方根格式化后："+s);System.out.println("--------------------------");// 设置语言地区//Locale locale = Locale.getDefault();//java.util.Locale//Locale locale = ;//zh_CN, en_US, en_GB, zh_HKLocale locale = new Locale("en", "GB");System.out.println(locale);/*nFormat = NumberFormat.getCurrencyInstance();Currency currency = Currency.getInstance(locale);nFormat.setCurrency(currency);*/nFormat = NumberFormat.getCurrencyInstance(locale);String string = nFormat.format(0.35);System.out.println(string);//$0.35//HK$0.35//￥0.35System.out.println("--------------------------");Random random = new Random();// java.util.Randomn = random.nextInt(8) + 1;System.out.println("n=" + n);/ 正则表达式public class RegexDemo {public static void main(String[] args) {、String regex = "\\dhello";boolean flag = s1.matches(regex);String result = flag ? "匹配成功" : "匹配失败";System.out.println(result);System.out.println("-----------------------");s1 = "029-";regex = "[0]\\d{2,3}-[2-8]\\d{6,7}";flag = s1.matches(regex);result = flag ? "匹配成功" : "匹配失败";System.out.println(result);}。
