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);

        }

    }

}