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());//按照长度比    }}