j2se学习中的一些零碎知识点6之DecimalFormat数字类以及java中的集合
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、单向链表的数据结构：
- 双向链表的数据结构：
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集合，只能存储字符串类型 Liststrs = new ArrayList (); //添加元素 //Error //strs.add(1); strs.add("JACK"); strs.add("SUN"); strs.add("KING"); strs.add("SMITH"); //遍历 Iterator 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) { Mapkeys = maps.keySet(); Iterator 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) { SortedSetss = new TreeSet (); // 添加 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 it = ss.iterator(); while(it.hasNext()){ Manager m = it.next(); m.work(); /* 输出结果为： 工作，一个月1000.0元 工作，一个月1300.0元 工作，一个月1500.0元 */ } } } class Manager implements Comparable { 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) { MyClassmc = new MyClass (); //泛型就是编译期检查类型 //Erroe //mc.m1(100); mc.m1("JACK"); } } //自定义泛型 class MyClass { public void m1(T t){ System.out.println(t); } } - JDK5.0新特性：关于增强for循环。语法：for(类型 变量: 数组名/集合名){}。（集合要想使用增强for循环这种语法，集合需要使用泛型。如果不使用泛型，需要用Object类型来定义集合中的元素。）
-
增强for的缺点：没有下标。
//集合 Setstrs = new HashSet (); 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