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集合，只能存储字符串类型
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);
}