JAVASE02-Unit05： 集合操作 —— 查找表

package day05;
/**
 * 使用该类测试自定义元素的集合排序
 * @author adminitartor
 *
 */
public class Point implements Comparable<Point>{
    private int x;
    private int y;
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    
    @Override
    public String toString() {
        return "("+x+","+y+")";
    }
    /**
     * 该方法的作用是用来判断当前对象this与
     * 参数给定的对象o之间比较大小的。
     * 返回值不关注具体取值，只关注取值范围，
     * 当:
     * 返回值>0:当前对象大于参数对象(this>o)
     * 返回值<0:当前对象小于参数对象
     * 返回值=0:两个对象相等
     */
    public int compareTo(Point o) {
        int len = this.x*this.x+this.y*this.y;
        int olen = o.x*o.x+o.y*o.y;
        return len-olen;
    }
    
    
}

package day05;

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

/**
 * 排序自定义类型元素
 * @author adminitartor
 *
 */
public class SortListDemo1 {
    public static void main(String[] args) {
        List<Point> list
            = new ArrayList<Point>();
        list.add(new Point(3,4));
        list.add(new Point(1,2));
        list.add(new Point(5,7));
        list.add(new Point(3,1));
        list.add(new Point(6,2));
        System.out.println(list);
        /*
         * Collections的sort方法要求集合元素
         * 必须实现Comparable接口。
         * 侵入性
         */
        Collections.sort(list);
        System.out.println(list);
    }
}

package day05;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 排序字符串
 * @author adminitartor
 *
 */
public class SortListDemo2 {
    public static void main(String[] args) {
        List<String> list
            = new ArrayList<String>();
        
        list.add("苍#null");
        list.add("范老师");
        list.add("小泽老师");
        
        System.out.println(list);
        
        Comparator<String> com 
            = new Comparator<String>(){
                public int compare(String o1, String o2) {
                    return o1.length()-o2.length();
                }
            
        };
        
        Collections.sort(list,com);
        System.out.println(list);
        
    }
}

package day05;

import java.util.LinkedList;
import java.util.Queue;

/**
 * java.util.Queue
 * 队列
 * 队列也可以存储一组元素，但是存取元素必须遵循
 * 先进先出原则。
 * @author adminitartor
 *
 */
public class QueueDemo {
    public static void main(String[] args) {
        Queue<String> queue
            = new LinkedList<String>();
        /*
         * boolean offer(E e)
         * 入队操作，向队列末尾追加新元素
         */
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");
        queue.offer("four");
        
        System.out.println(queue);
        /*
         * E poll()
         * 获取队首元素，获取后该元素即从队列
         * 中被移除。
         */
        String str = queue.poll();
        System.out.println(str);
        System.out.println(queue);
        
        /*
         * E peek()
         * 引用队首元素，获取后但不从队列中删除
         */
        str = queue.peek();
        System.out.println(str);
        System.out.println(queue);
        
        //新循环遍历
        for(String s : queue){
            System.out.println(s);
        }
        System.out.println(queue);
        
        System.out.println("自行遍历开始!");
        while(queue.size()>0){
            str = queue.poll();
            System.out.println(str);
        }
        System.out.println("遍历完毕了!");
        System.out.println(queue);
    }
}

package day05;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈
 * 栈结构存储一组元素，但是存取需要遵循先进后出原则
 * 
 * java.util.Deque
 * 双端队列，两端都可以进出队的队列，是Queue的
 * 子类。
 * Deque接口规定了两端进出队的方法。
 * 当仅调用从一端进出队的方法时，就形成了栈的结构特点
 * 
 * @author adminitartor
 *
 */
public class Stack {
    public static void main(String[] args) {
        Deque<String> stack
            = new LinkedList<String>();
        
        stack.offer("one");
        stack.offer("two");
        System.out.println(stack);//[one,two]
        
        stack.offerLast("three");
        System.out.println(stack);//[one,two,three]
        
        stack.offerFirst("four");
        System.out.println(stack);//[four,one,two,three]
        
        String str = stack.poll();
        System.out.println(str);//four
        
        str = stack.pollFirst();
        System.out.println(str);//one
        
        str = stack.pollLast();
        System.out.println(str);//three
        
        System.out.println(stack);
        
        /*
         * 双端队列提供了入栈与出栈的方法
         */
        /*
         * void push(E e)
         * 入栈操作
         * 最后入栈的元素会在栈顶
         */
        stack.push("three");
        stack.push("four");
        stack.push("five");
        System.out.println(stack);
        
        /*
         * E pop()
         * 出栈操作
         * 获取栈顶元素后该元素即从栈中被移除
         */
        str = stack.pop();
        System.out.println(str);
        System.out.println(stack);
        
        str = stack.peek();
        System.out.println(str);
        System.out.println(stack);
        
        for(String s : stack){
            System.out.println(s);
        }
        System.out.println(stack);
        
        
    }
}

package day05;

import java.util.HashMap;
import java.util.Map;

/**
 * 删除Map中的元素
 * @author adminitartor
 *
 */
public class Map_Remove {
    public static void main(String[] args) {
        Map<String, Integer> map 
            = new HashMap<String, Integer>();
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        map.put("化学", 99);
        
        System.out.println(map);
        /*
         * 删除数学这一条记录
         * V remove(K k)
         * 根据给定的key将对应的key-value对
         * 从Map中删除，返回值为该key对应的value
         */
        Integer v = map.remove("数学");
        System.out.println(map);
        System.out.println(v);
    }
}

package day05;

import java.util.HashMap;
import java.util.Map;

/**
 * 判断Map是否包含给定元素
 * @author adminitartor
 *
 */
public class Map_Contains {
    public static void main(String[] args) {
        Map<String, Integer> map 
            = new HashMap<String, Integer>();
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        map.put("化学", 99);
        
        boolean ck = map.containsKey("语文");
        System.out.println("key是否包含:"+ck);
        
        boolean cv = map.containsValue(99);
        System.out.println("value是否包含:"+cv);
    }
}

package day05;
/**
 * HashMap的Key对于HashMap的影响
 * 影响HashMap的查询性能的主要因素是在HashMap中
 * 出现链表。
 * 那么作为Key的元素的hashcode值与equals比较的结果
 * 在Map中产生链表有很大的作用。要妥善重写他们。
 * 
 * API手册中Object对于hashcode方法与equals的重写
 * 有如下要求:
 * 1:当我们重写一个类的equals方法，就应当连同重写
 *   hashcode方法
 * 2:hashcode应当与equals比较结果一致，即:
 *   当两个对象equals比较结果为true时，他们的
 *   hashcode方法返回的数字应当相等。反之亦然。
 *   因为当两个作为key的对象hashcode相同但是
 *   equals比较不相同时，会在HashMap中产生链表，
 *   影响散列表查询性能。
 * 
 * 
 * @author adminitartor
 *
 */
public class Key {
    private int x;
    private int y;
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Key other = (Key) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }
    
    
}

package day05;

import java.util.HashMap;
import java.util.Map;

/**
 * java.util.Map
 * Map 查找表
 * 以key-value对的形式存储元素
 * 常用实现类:HashMap 散列表(散列算法实现)
 * @author adminitartor
 *
 */
public class Map_Put_Get {
    public static void main(String[] args) {
        /*
         * Map需要指定两个泛型，分别指定key与
         * value的类型
         */
        Map<String,Integer> map 
            = new HashMap<String,Integer>();
        
        /*
         * Map要求key不允许重复(equals比较)
         * V put(K k,V v)
         * 将给定的key-value对存入到Map中，
         * 若key在map中已经存在了，则是替换value
         * 操作，返回至则为被替换的value
         * 若key不存在，则返回值为NULL
         */
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        /*
         * 获取put返回值时，若返回值为包装类类型
         * 注意不要用基本类型接收，避免自动拆箱
         * 引起的空指针异常:
         * int n = map.put("化学",99);
         * 因为若"化学"作为key在Map中不存在，put
         * 返回值为NULL,那么对其拆箱会引发空指针
         */
        Integer n = map.put("化学", 99);
        
        System.out.println(map);
        System.out.println(n);
        
        //重复的key是替换value操作
        n = map.put("语文", 88);
        System.out.println(map);
        System.out.println(n);
        
        
        /*
         * V get(K k)
         * 根据给定的key获取对应的value
         * 若给定的key不存在，则返回值为null
         */
        n = map.get("数学");
        System.out.println("数学:"+n);
        
        n = map.get("体育");
        System.out.println("体育:"+n);
        
    }
}

package day05;

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

/**
 * 遍历Map
 * 遍历Map有三种方式:
 * 1:遍历所有的key
 * 2:遍历每一组键值对
 * 3:遍历所有的value(相对不常用)
 * @author adminitartor
 *
 */
public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map 
            = new HashMap<String, Integer>();
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        map.put("化学", 99);
        
        /*
         * 遍历所有的key
         * Set<K> keySet()
         * 将当前Map中所有的key存入一个Set集合
         * 后返回。遍历该集合就等于遍历了Map中
         * 所有的key
         */
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println("key:"+key);
        }
        
        /*
         * 遍历每一组键值对
         * Map中每一组键值对由Map的内部类Entry
         * 的一个实例保存。
         * Set<Entry> entrySet()
         * 该方法会将当前Map中每组键值对(若干的
         * Entry实例)存入一个Set集合后返回
         */
        Set<Entry<String,Integer>> entrySet 
                            = map.entrySet();
        for(Entry<String,Integer> e:entrySet){
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+":"+value);
        }
        
        /*
         * Collection<V> values()
         * 该方法会返回当前Map中所有的value
         */
        Collection<Integer> values
            =    map.values();
        for(Integer value : values){
            System.out.println("value:"+value);
        }
    }
}