Java 集合

1.散列表Map

- 容量       散列表中散列数组大小
- 散列运算    key->散列值的算法
如："mm".hashCode()%10->8
- 散列桶     散列值相同的元素的”线性几何“
- 加载因子   就是散列数组加载率，一般小于75%性能比较理想
- 散列查找   根据key计算散列值，根据散列值（下标），找到散列桶
顺序比较key，如果一样，就返回value
散列表中key不同，value可以重复

2.HashMap

- HashMap以键值对的形式存储对象，关键字key是唯一的，不重复的
key可以是任何对象，value可以是任何对象
key:value 成对放在集合中
重复的key算一个，重复添加时替换操作
根据key的散列值计算散列表，元素按照散列值排序
HashMap默认的容量是16，默认加载因子0.75
HashMap根据key检索查找value值

Hash可以在构造时指定参数：初始容量和加载因子



案例：HashMap

public class HashMapDemo {
public static void main(String[] args) {
HashMap users = new HashMap();
//注册用户
users.put("Tom", new User("Tom", "123", 5));
users.put("Jerry", new User("Jerry", "123", 6));
users.put("Andy", new User("Andy", "abc", 6)); //将被覆盖
users.put("Andy", new User("Andy", "123", 8));
System.out.println(users);
//登录查找
Scanner s = new Scanner(System.in);
while(true) {
System.out.println("用户名：");
String name = s.nextLine();
System.out.println("密码：");
String pwd = s.nextLine();
if (!users.containsKey(name)) {
System.out.println("没有注册！");
continue;
}
User user = (User) users.get(name);
if (user.pwd.equals(pwd)) {
System.out.println("欢迎"+user.name+"   age:"+user.age);
break;
}
}
}
}
class User {
String name;
String pwd;
int age;
public User(String name, String pwd, int age) {
super();
this.name = name;
this.pwd = pwd;
this.age = age;
}
public String toString() {
return name+":"+age;
}
}

HashMap VS HashTable

HashMap   新，非线程安全，不检查锁，快
HashTable 旧，线程安全，检查锁，慢一点

3.集合框架

- 集合框架包括集合不映射(Collection and Map), 以及它们的子类(容器类)

- List元素有先后次序的集合, 元素有index位置, 元素可以重复,继承自Collection接口
实现类:ArrayList,Vector,LinkedList
- Set元素无续,不能重复添加,是数学意义上的集合,继承自Collection接口
 实现类:HashSet(是一个只有Key的HashMap
- Collection集概念,没有说明元素是否重复和有序,使用集合的跟接口,很少直接使用
其他集合都是实现类: ArrayList, HashSet
- Map描述了(key: value)成对放置的集合,key不重复,Value可以重复(key重复算一个)
 实现类:HashMap(散列表算法实现)
TreeMap(二叉排序树实现,利用Key排序)
 Map适合检查查找

java集合架构支持3种类型的集合：规则集（Set），线性表（List），和图（Map）

- Collection接口
Set接口：HashSet具体类
LinkedHashSet具体类
TreeSet具体类
List接口：ArrayList具体类
LinkedList具体类
向量类Vector具体类
Stack具体类
- Map接口
HashMap类
LinkedHashMap类
TreeMap类　　　　

案例：HashSet

public class SetDemo {
public static void main(String[] args) {
Set<Node> foods = new HashSet<Node>();
//1.放入5个豆豆
foods.add(new Node(3, 4));
foods.add(new Node(6, 8));
foods.add(new Node(2, 12));
foods.add(new Node(5, 10));
foods.add(new Node(9, 9));
System.out.println(foods.size());
System.out.println(foods);
//2.吃了一个豆豆
foods.remove(new Node(9, 9));
//3.在面板中画出豆豆
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 20; j++) {
if (foods.contains(new Node(i, j))){
System.out.print("o");
} else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
class Node {
int i;
int j;
public Node(int i, int j) {
super();
this.i = i;
this.j = j;
}
//注意：必须写equals()方法
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (obj instanceof Node) {
Node node = (Node) obj;
return i == node.i && j == node.j;
}
return false;
}
//注意：必须写hashCode()方法
public int hashCode() {
return (i << 16) | j;
}
public String toString() {
return "["+i+","+j+"]";
}
}

案例：链表数据结构

public class LinkedDemo {
public static void main(String[] args) {
Node head = new Node("黑桃10");
head.next = new Node("黑桃J");
head.next.next = new Node("黑桃Q");
head.next.next.next = new Node("黑桃K");
System.out.println(head);
}
}
class Node {
Object value;
Node next;
public Node (Object obj) {
value = obj;
}
public String toString() {
return next == null ? value.toString() : value+","+next ;//递归的写法
}
}

4.Java泛型

泛型是Java5以后提出的语法现象
作用是在编译期检查的类型约束(运行期不检查泛型)
泛型可以用来约束类中元素的类型

案例：泛型

public class ShopDemo {
public static void main(String[] args) {
Shop<Food> foodShop = new Shop<Food>(new Food("土豆")); //食品店
Shop<Pet> petShop = new Shop<Pet>(new Pet("旺财")); //宠物店
System.out.println(foodShop.buy());
System.out.println(petShop.buy());
// 如果不适用泛型，默认泛型是<Object>
Shop shop = new Shop(new Object());
}
}
class Shop<P> { //P代表商品类型
P product; //销售商品
public Shop(P p) {
product = p;
}
P buy() { // 进货方法
return product;
}
}
class Food {
String name;
public Food(String name) {
super();
this.name = name;
}
public String toString() {
return name;
}
}
class Pet {
String name;
public Pet(String name) {
super();
this.name = name;
}
public String toString() {
return name;
}
}

5.集合的迭代

集合的迭代,是一种遍历算法

- 迭代操作举例:播放列表的“逐个播放”,将扑克牌“逐一发放”
- Java使用Iterator接口描述了迭代模式操作
Iterator中的方法,与门为while循环设计
- Iterator的实例可以从集合对象获得,是这个集合的一个元素序列视图,
默认包含一个操作游标(在第一个元素之前)
hasNext()方法,可以检查游标是否有下一个元素
next) 方法,移动游标到下一个元素,并丏返回这个元素引用
使用while循环配合这个两个方法, 可以迭代处理集合的所有元素
- 迭代时可以使用迭代器remove()方法删除刚刚迭代的元素在迭代过程中
 迭代时不能使用集合方法(add, remove, set) 更改集合元素!

案例：Iterator

public class IteratorDemo {
public static void main(String[] args) {
Collection<String> eggs = new HashSet<String>();
eggs.add("鸡蛋");
eggs.add("鸭蛋");
eggs.add("鸟蛋");
Iterator<String> ite = eggs.iterator();
while (ite.hasNext()) {
String egg = ite.next();
System.out.println(egg);
}
}
}

6.集合的工具类 Collections

同数组的工具类 Arrays 相同,集合的工具类为 Collections,
其中提供了许多的方法,诸如排序、 二分查找、打乱、填充等操作。

案例：Collections

public class CollectionsDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<String>();
names.add("Tom");
names.add("Jerry");
names.add("Black");
names.add("Andy");
names.add("Lee");
// 排序
Collections.sort(names);
System.out.println(names);
// 二分法查找
int index = Collections.binarySearch(names, "Jerry");
System.out.println(index);
// 乱序
Collections.shuffle(names);
System.out.println(names);
}
}

7.Comparable和Comparator

- Comparable
表示可以比较的(用于类实现)
实现这个接口表示:这个类的实例可以比较大小,可以迚行自然排序
compareTo() 返回正数表示大, 返回负数表示小, 返回 0 表示相等
Comparable 的实现必须与equals()的结果一致,就是相等的对象时候, 比较结果一定是0!
- Comparator
比较工具
用于临时定义比较规则,不是默认比较规则

案例：Comparator

public class Demo {
public static void main(String[] args) {
//String重写的compareTo方法
int a = "Tom".compareTo("Jerry");
System.out.println(a);
a = "Tom".compareTo("Tom");
System.out.println(a);
a = "Jerry".compareTo("Tom");
System.out.println(a);
List<String> names = new ArrayList<String>();
names.add("Tom");
names.add("Jerry");
names.add("Black");
names.add("Andy");
names.add("Lee");
ByLength byLength = new ByLength();
Collections.sort(names, byLength);
System.out.println(names);
}
}
//自定义比较规则
class ByLength implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return -(o1.length() - o2.length());//按照长度比
}
}