j2se学习中的一些零碎知识点6之DecimalFormat数字类以及java中的集合

最新推荐文章于 2021-04-13 21:40:58 发布

powerx_yc

最新推荐文章于 2021-04-13 21:40:58 发布

阅读量174

点赞数

文章标签： java 数据结构与算法数据库

原文链接：http://blog.51cto.com/12402717/2045953

版权

1、数字类java.text.DecimalFormat：

数字格式元素：“#”表示任意数字；“,”表示千分位；“.”表示小数点；“0”表示不够补零。
构造器DecimalFormat(String pattern) 方法表示创建给定的模式标志的数字格式化对象。
如DecimalFormat df = new DecimalFormat("###,###"); DecimalFormat df = new DecimalFormat("###,###.##");（加入千分位，保留2为小数）DecimalFormat df = new DecimalFormat("###,###.00");（加入千分位，保留4为小数，不够补0）

2、java.math.BigDecimal类：该类型的数据精确度极高，适合做财务软件。（财务软件中double类型精确度太低。）

构造器BigDecimal(int val)方法将一个int类型的数据转换成BigDecimal类对象：
add(BigDecimal augend)方法用以将两个BigDecimal类对象表示的值执行加法运算：（需要注意的是，不能够使用“+”号）：

3、java.util.Random类：生成随机数

构造器Random()方法生成一个随机数对象：
nextInt(int n)方法返回一个随机的int类型值，值的范围为[0 ~ (n - 1)]：

4、java集合主要有3种重要的类型：（容器只能存储引用类型）

List：是一个有序集合，可以放重复的数据；Set：是一个无序集合，不允许放重复的数据；Map是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重复（如×××号对应姓名。）
集合继承结构图--Collection部分：（单个存储）
集合继承结构图--Map部分：

5、单向链表的数据结构：
j2se学习中的一些零碎知识点6之DecimalFormat数字类以及java中的集合

双向链表的数据结构：

6、Collection集合中的常用方法1：

    package com.geeklicreed.j2se;
    import java.util.ArrayList;
    import java.util.Collection;
    public class CollectionTest {
            public static void main(String[] args) {
                    //1、创建集合
                    Collection c = new ArrayList(); //多态
                    //2、添加元素
                    c.add(1); //jdk5.0之后，自动装箱
                    c.add(new Integer(100));

                    Object o = new Object();
                    c.add(o); //Collection集合只能单个存储元素，并且只能存储引用类型

                    Customer cus = new Customer("JACK", 20);
                    c.add(cus);

                    //3、获取元素的个数
                    System.out.println(c.size()); //4
                    System.out.println(c.isEmpty()); //false

                    //4、将集合转换成Object类型的数组
                    Object[] objs = c.toArray();
                    for(int i = 0; i < objs.length; i++){
                            System.out.println(objs[i]);
                    }

                    //5、清空
                    c.clear();
                    System.out.println(c.size()); //0
                    System.out.println(c.isEmpty()); //true
            }
    }

Collection集合中的常用方法2：迭代器的用法

package com.geeklicreed.j2se;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
         Iterator iterator()：获取集合所依赖的迭代器对象
         通过迭代器中方法完成集合的迭代（遍历）
         注意：这种方式是所有集合通用的遍历方式
 */
public class CollectionTest {
        public static void main(String[] args) {
                //创建集合对象、
                Collection c = new ArrayList();
                //添加集合对象
                c.add(100); //自动装箱
                c.add(3.14); //自动装箱
                c.add(false); //自动装箱

                //迭代，遍历
                //1、获取迭代器对象
                //不需要关心底层集合的具体类型，所有集合依赖的迭代器都实现了java.util.Iterator;接口。
                //Iterator it = c.iterator();  //迭代器是面向接口编程。
                //it是引用，保存了内存地址，指向堆中的“迭代器对象”

                //java.util.LinkedList$Listener 类是LinkedList集合所依赖的迭代器
                //java.util.AbstractList$Listener 类是ArrayList集合所依赖的迭代器

                //2、开始调用方法，完成遍历，迭代
                /*Iterator it = c.iterator();
                while(it.hasNext()){
                        Object element = it.next();
                        System.out.println(element); //100 3.14 false
                }*/
                /*
                 boolean b = it.hasNext(); 判断是否有更多的元素，如果有返回true
                 Object o = it.next(); 将迭代器向下移动一位，并且取出指向的元素
                 原则：调用it.next()方法之前必须调用it.hasNext();
                 */
                for(Iterator it = c.iterator(); it.hasNext();){
                        Object o = it.next();
                        System.out.println(o);
                }
        }
}

Collection集合中的常用方法3：contains的用法（需要注意，包装类都重写了Object类中的equals方法）

package com.geeklicreed.j2se;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {
        public static void main(String[] args) {
                //创建集合
                Collection c = new ArrayList();
                //创建Integer类型的对象
                Integer i1 = new Integer(10);
                //添加元素
                c.add(i1);
                //判断集合中是否包含i1
                System.out.println(c.contains(i1)); //true
                //创建Integer类型的对象
                Integer i2 = new Integer(10);
                //contains方法底层调用的是equals方法，如果equals返回true，就是包含
                System.out.println(c.contains(i2)); //true

                Manager m1 = new Manager("geeklicreed", 24);
                c.add(m1);
                System.out.println(c.contains(m1)); //true
                //重写equals方法之前
                Manager m2 = new Manager("geeklicreed", 24);
                System.out.println(c.contains(m2));  //false
                //重写equals方法之后，比较内容
                System.out.println(c.contains(m2));  //true
        }
}
package com.geeklicreed.j2se;

public class Manager {
        private String name;
        private int age;

        public Manager(String name, int age) {
                super();
                this.name = name;
                this.age = age;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + age;
                result = prime * result + ((name == null) ? 0 : name.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Manager other = (Manager) obj;
                if (age != other.age)
                        return false;
                if (name == null) {
                        if (other.name != null)
                                return false;
                } else if (!name.equals(other.name))
                        return false;
                return true;
        }

}

java中ArrayList中的contains源码如下：

 public boolean contains(Object o) {
                return indexOf(o) >= 0;
        }
        public int indexOf(Object o) {
                if (o == null) {
                        for (int i = 0; i < size; i++)
                                if (elementData[i]==null)
                                        return i;
                } else {
                        for (int i = 0; i < size; i++)
                                if (o.equals(elementData[i]))
                                        return i;
                }
                return -1;
        }

Collection集合中的常用方法4：remove方法

package com.geeklicreed.j2se;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * boolean remove(Object o);
 * remove和contains方法都需要集合中的元素重写equals方法。因为Object中的equals方法比较的是内存地址，
 * 在现实的业务逻辑当中不能比较内存地址，该比较内容。
 */
public class CollectionTest {
        public static void main(String[] args) {
                //创建集合对象
                Collection c = new ArrayList();
                Integer i1 = new Integer(10);

                //添加元素
                c.add(i1);

                //删除
                Integer i2 = new Integer(10);
                c.remove(i2);
                System.out.println(c.size()); //0

                Manager m1 = new Manager("geeklicreed", 24);
                c.add(m1);

                Manager m2 = new Manager("geeklicreed", 24);
                c.remove(m2);

                System.out.println(c.size()); //0
        }
}
package com.geeklicreed.j2se;

public class Manager {
        private String name;
        private int age;

        public Manager(String name, int age) {
                super();
                this.name = name;
                this.age = age;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + age;
                result = prime * result + ((name == null) ? 0 : name.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Manager other = (Manager) obj;
                if (age != other.age)
                        return false;
                if (name == null) {
                        if (other.name != null)
                                return false;
                } else if (!name.equals(other.name))
                        return false;
                return true;
        }

}

7、深入List集合：

    package com.geeklicreed.j2se;

    import java.util.ArrayList;
    import java.util.List;

    /*
     * 深入List集合
     * ArrrayList集合底层是数组。数组是有下标的，所以ArrayList集合有很多自己的特性
     * ArrayList集合底层默认初始化容量是10，扩大之后的容量是原容量的1.5倍。
     * Vector集合底层默认初始化容量也是10,扩大之后的容量是原容量的2倍
     * 
     * 如何优化ArrayList和Vector?
     * 尽量减少扩容操作，因为扩容需要数组拷贝。数组拷贝很耗内存。
     * 一般推荐在创建集合的时候指定初始化容量。
     */
    public class ListTest {
            public static void main(String[] args) {
                    //创建List集合
                    //这里可以直接修改成LinkedList，而其余的代码不需要改变，这体现了多态的强大之处
                    List l = new ArrayList();
                    //添加元素
                    l.add(123);
                    l.add(321);
                    l.add(69);

                    //在下标为1的位置上添加555
                    l.add(1,555);

                    //取得第一个元素
                    System.out.println(l.get(0));

                    System.out.println("-----------------------");

                    //遍历（List集合特有的遍历方式）
                    for(int i = 0; i < l.size(); i++){
                            Object element = l.get(i);
                            System.out.println(element);
                    }
                    /*输出结果为：
                    123
                    -----------------------
                    123
                    555
                    321
                    69*/
            }
    }

8、java中的HashMap底层就是哈希表（或者说是散列表），哈希表是数组和单向链表的结合，哈希表是一个数组，只不过这个数组中的每一个元素又是单向链表。
wKioL1nTjHKQtBzJAACHH0V9Wcg481.png

HashSet底层实际上是一个HashMap，HashMap底层采用了哈希表数据结构。
哈希表又叫做散列表，哈希表底层是一个数组，这个数组中每一个元素是一个单向链表，每个单向链表都有一个独一无二的hash值，代表数组的下标。在某个单向链表中的每一个节点上的hash值是相等的。hash值实际上是key调用hashCode方法，在通过“hash function”转换成的值。
如何向哈希表中添加元素：先调用被存储的key的hashCode方法，经过某个算法得出hash值，如果在这个哈希表中不存在这个hash值，则直接加入元素。如果该hash值已经存在，继续调用key之间的equals方法，如果equals方法返回false，则将该元素添加，如果equals方法返回true，则放弃添加该元素。
HashSet其实是HashMap中的key部分，HashSet有什么特点，HashMap中的key就应该有什么特点。
HashMap和HashSet的初始化容量都是16，默认加载因子是0.75。

关于往Set集合中存储的元素，该元素的hashCode和equals方法：

package com.geeklicreed.j2se;

import java.util.HashSet;
import java.util.Set;

/*
 * 关于往Set集合中存储的元素，该元素的hashCode和equals方法需要重写：
 * HashMap中有一个put方法，put(key, value)中的 key 是无序不可重复的
 * 结论：存储在HashSet集合或者HashMap集合key部分的元素，需要同时重写hashCode + equals方法
 */
public class SetTest {
    public static void main(String[] args) {
        //创建集合
        Set es = new HashSet();

        Employee e1 = new Employee("1000", "JACK");
        Employee e2 = new Employee("1000", "JACK");
        Employee e3 = new Employee("1000", "SCOTT");
        Employee e4 = new Employee("2001", "SUN");
        Employee e5 = new Employee("3000", "JIM");
        Employee e6 = new Employee("3001", "COOK");

        System.out.println(e1.hashCode()); //1507423
        System.out.println(e2.hashCode()); //1507423

        //添加元素
        es.add(e1);
        es.add(e2);
        es.add(e3);
        es.add(e4);
        es.add(e5);
        es.add(e6);

        //查看集合元素的个数
        System.out.println(es.size()); //5

    }
}
package com.geeklicreed.j2se;
//根据现实的业务逻辑得知：该公司员工编号是：1000 - 9999
public class Employee {
    //编号
    String no;

    //姓名
    String name;

    //Construtor
    public Employee(String no, String name) {
        this.no = no;
        this.name = name;
    }

    //重写equals方法
    //如果员工编号相同，并且名字相同，则是同一个对象
    public boolean equals(Object o){
        if(this == o){
            return true;
        }
        if(o instanceof Employee){
            Employee e = (Employee)o;
            if(e.no.equals(this.no) && e.name.equals(this.name)){
                return true;
            }
        }
        return false;
    }

    //重写hashCode方法
    public int hashCode(){
        //以员工编号分组
        return no.hashCode();
    }

}

9、SortedSet类：（需要注意，SortedSet还可以对存储的字符串和日期进行自动排序，java.lang.Integer、java.lang.String和java.util.Date类都实现了Comparable接口。）

    package com.geeklicreed.j2se;

    import java.util.Iterator;
    import java.util.SortedSet;
    import java.util.TreeSet;

    public class SortedSetTest {
        public static void main(String[] args) {
            //创建集合
            SortedSet ss = new TreeSet();

            //添加元素
            ss.add(10); //自动装箱
            ss.add(20);
            ss.add(15);
            ss.add(30);
            ss.add(25);
            ss.add(9);

            //遍历
            Iterator it = ss.iterator();
            while(it.hasNext()){
                Object element = it.next();
                System.out.println(element);
            }
            /*输出结果为：
                    9
                    10
                    15
                    20
                    25
                    30
            */
        }
    }

如果自定义类添加进SortedSet集合中，需要实现Comparable接口以实现可比较，否则会出现以下异常情况：（SUN编写TreeSet集合在添加元素的时候，会调用compareTo方法完成比较。）
Exception in thread "main" java.langClassCastException: User cannot be cast to java.lang.Comparable

让SortedSet集合做到排序还有另一种方式：java.util.Comparator，单独编写一个比较器：（优先选择这种方式，单独使用比较器使得类之间的耦合度降低。）

package com.geeklicreed.j2se;

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetTest {
    public static void main(String[] args) {
        //创建TreeSet集合的时候提供一个比较器
        SortedSet products = new TreeSet(new ProductComparator());

        Product p1 = new Product(3.4);
        Product p2 = new Product(4.0);
        Product p3 = new Product(3.0);
        Product p4 = new Product(2.0);
        Product p5 = new Product(5.0);

        //添加元素
        products.add(p1);
        products.add(p2);
        products.add(p3);
        products.add(p4);
        products.add(p5);

        //遍历
        Iterator it = products.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        /*
            输出结果为：
            Product [price=5.0]
            Product [price=4.0]
            Product [price=3.4]
            Product [price=3.0]
            Product [price=2.0]

         */
    }
}
package com.geeklicreed.j2se;

public class Product {
    double price;

    Product(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product [price=" + price + "]";
    }

}
package com.geeklicreed.j2se;

import java.util.Comparator;
//单独编写一个比较器
public class ProductComparator implements Comparator {

    //需求：按照商品价格排序
    @Override
    public int compare(Object o1, Object o2) {
        double price1 = ((Product)o1).price;
        double price2 = ((Product)o2).price;

        if(price1 == price2){
            return 0;
        }else if(price1 < price2){
            return 1;
        }else{
            return -1;
        }
    }

}

10、关于Map集合中的常用方法：

    package com.geeklicreed.j2se;

    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;

    /*
     * 关于Map集合中常用的方法
     * void clear(); 清空Map
     * boolean isEmpty(); 判断该集合是否为空
     * int size(); 获取Map中键值对的个数
     * 
     * Object put(Object key, Object value); 向集合中添加键值对
     * Object get(Object key); 通过key获取value
     * 
     * boolean containsKey(Object key); 判断Map中是否包含这样的key
     * boolean containsValue(Object value); 判断Map中是否包含这样的value
     * 
     * Object remove(Object key); 通过key将键值对删除
     * 
     * Collection values(); 获取Map集合中所有的value
     * 
     * Set keySet(); 获取Map中所有的key
     * 
     * Set entrySet(); 返回此映射中包含的映射关系的Set视图
     * 
     * 注意：存储在Map集合key部分的元素需要同时重写hashCode + equals方法
     */
    public class MapTest {
        public static void main(String[] args) {
            //1、创建Map集合
            Map persons = new HashMap(); //HashMap的默认初始化容量是16，默认加载因子是0.76

            //2、存储键值对
            persons.put("10000", "JACK");
            persons.put("10011", "JACK");
            persons.put("10002", "SUN");
            persons.put("10003", "COOK");
            persons.put("10004", "KING");
            persons.put("10000", "LUCY");

            //3、判断键值对的个数
            //Map中的key是无序不可重复的，和HashSet相同
            System.out.println(persons.size()); //5

            //4、判断集合中是否包含这样的key
            System.out.println(persons.containsKey("10000")); //true

            //5、判断集合中是否包含这样的value
            //注意：Map中如果key重复了，value采用的是“覆盖”
            System.out.println(persons.containsValue("LUCY")); //true

            //6、通过key获取value
            String k = "10002";
            Object v = persons.get(k);
            System.out.println(v); //SUN  

            //7、通过key删除键值对
            persons.remove("10002");
            System.out.println(persons.size()); //4

            //8、获取所有的value
            Collection values = persons.values();
            Iterator it = values.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
                /*
                输出结果为：
                LUCY
                JACK
                KING
                COOK*/
            }
            System.out.println("-------------------------");
            //9、获取所有的key
            //以下程序演示如何遍历Map集合
            Set keys = persons.keySet();
            Iterator it2 = keys.iterator();
            while(it2.hasNext()){
                Object id = it2.next();
                Object name = persons.get(id);

                System.out.println(id + "-->" + name);
                /*
                输出结果为：
                10000-->LUCY
                10011-->JACK
                10004-->KING
                10003-->COOK*/
            }
            System.out.println("-------------------------");
            //10、entrySet
            //将Map转换成Set集合
            Set entrySet = persons.entrySet();
            Iterator it3 = entrySet.iterator();
            while(it3.hasNext()){
                System.out.println(it3.next());
                /*
                输出结果为： 
                10000=LUCY
                10011=JACK
                10004=KING
                10003=COOK*/

            }
        }
    }

11、Hashtable接口的实现类Properties简单方法介绍：

    package com.geeklicreed.j2se;

    import java.util.Properties;

    /*
     * HashMap默认初始化容量是16，默认加载因子0.75
     * Hashtable默认初始化容量是11，默认加载因子是0.75
     * 
     * java.util.Properties; 也是由key和value组成，但是key和value都是字符串类型
     */
    public class MapTest {
        public static void main(String[] args) {
            //1、创建属性类对象
            Properties p = new Properties();

            //2、存
            p.setProperty("driver", "oracle.jdbc.driver.OracleDriver");
            p.setProperty("username", "scott");
            p.setProperty("password", "tiger");
            p.setProperty("url", "jdbc:oracle:thin:@192.168.1.100:1521:geeklicreed");

            //3、取：通过key获取value
            System.out.println(p.getProperty("driver"));
            System.out.println(p.getProperty("username"));
            System.out.println(p.getProperty("password"));
            System.out.println(p.getProperty("url"));

        }
    }

12、Collections关于集合工具类java.util.Collections;：介绍两个主要的静态方法

返回排序后的List集合（如果是自定义的类，需要实现Comparable接口）
返回线程安全的List集合。

13、关于JDK5.0新特性：泛型（编译期概念）

为什么引入泛型？在JDK5.0之前，集合中没有使用泛型，集合中的元素不统一，在遍历集合的时候，只能够拿出来Object类型，需要做大量的强制类型转换。而泛型可以统一集合中的数据类型，可以减少强制类型转换。（缺点：类型太统一，只能存储一种类型。）

List集合使用泛型语法：

package com.geeklicreed.j2se;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericTest {
    public static void main(String[] args) {
        //创建一个List集合，只能存储字符串类型
        List<String> strs = new ArrayList<String>();

        //添加元素
        //Error
        //strs.add(1);
        strs.add("JACK");
        strs.add("SUN");
        strs.add("KING");
        strs.add("SMITH");

        //遍历
        Iterator<String> it = strs.iterator();

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

Map集合使用泛型语法：

package com.geeklicreed.j2se;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
 * Map使用泛型
 */
public class GenericTest {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<String, Integer>();
        //存
        maps.put("西瓜", 10);
        maps.put("苹果", 9);
        maps.put("香蕉", 20);

        //遍历
        Set<String> keys = maps.keySet();
        Iterator<String> it = keys.iterator();
        while(it.hasNext()){
            String k = it.next();
            Integer v = maps.get(k);
            System.out.println(k + " --> " + v);
            /*输出结果为：
                苹果 --> 9
                香蕉 --> 20
                西瓜 --> 10
             */
        }
    }
}

Set集合使用泛型语法：

package com.geeklicreed.j2se;

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class GenericTest {
    public static void main(String[] args) {
        SortedSet<Manager> ss = new TreeSet<Manager>();

        // 添加
        Manager m1 = new Manager(1000.0);
        Manager m2 = new Manager(1500.0);
        Manager m3 = new Manager(1300.0);

        ss.add(m1);
        ss.add(m2);
        ss.add(m3);

        Iterator<Manager> it = ss.iterator();
        while(it.hasNext()){
            Manager m = it.next();
            m.work();
            /*
                输出结果为：
                工作，一个月1000.0元
                工作，一个月1300.0元
                工作，一个月1500.0元
             */
        }
    }
}

class Manager implements Comparable<Manager> {

    double sal;

    public Manager(double sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "Manager [sal=" + sal + "]";
    }

    public void work(){
        System.out.println("工作，一个月" + sal + "元");
    }

    //实现接口中的方法
    @Override
    public int compareTo(Manager m) {
        double sal1 = this.sal;
        double sal2 = m.sal;

        if(sal1 > sal2){
            return 1;
        }else if(sal1 < sal2){
            return -1;
        }
        return 0;
    }

}

自定义泛型：

package com.geeklicreed.j2se;

public class GenericTest {
    public static void main(String[] args) {
        MyClass<String> mc = new MyClass<String>();

        //泛型就是编译期检查类型
        //Erroe
        //mc.m1(100);

        mc.m1("JACK");
    }
}

//自定义泛型
class MyClass<T>{
    public void m1(T t){
        System.out.println(t);
    }
}

JDK5.0新特性：关于增强for循环。语法：for(类型变量: 数组名/集合名){}。（集合要想使用增强for循环这种语法，集合需要使用泛型。如果不使用泛型，需要用Object类型来定义集合中的元素。）

增强for的缺点：没有下标。

//集合
Set<String> strs = new HashSet<String>();

strs.add("张三");
strs.add("李四");
strs.add("王五");
strs.add("赵六");

//遍历
for(String name: strs){
        System.out.println(name);
}

//集合不使用泛型
List l = new ArrayList();

l.add(1);
l.add(2);
l.add(3);
l.add(4);

//如果集合不使用泛型，该集合在使用增强for循环的时候应该用Object类型来定义

for(Object element: l){
    System.out.println(element);
}

转载于:https://blog.51cto.com/12402717/2045953

powerx_yc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
j2se学习中的一些零碎知识点6之DecimalFormat数字类以及java中的集合

1、数字类java.text.DecimalFormat：数字格式元素：“#”表示任意数字；“,”表示千分位；“.”表示小数点；“0”表示不够补零。构造器DecimalFormat(String pattern) 方法表示创建给定的模式标志的数字格式化对象。如DecimalFormat df = new DecimalFormat("###,###"); DecimalFormat ...
复制链接

扫一扫