比较器&&队列&&栈

一.  Comparable

Collections的sort方法排序List集合时，要求List集合元素必须实现可比较接口。

当实现了Comparable接口后，就需要重写compareTo方法，该方法的作用是判断当前对象this与给定参数的大小

如果返回值大于0，当前对象比参数给定的对象大

如果小于0，则当前对象比给定参数小

等于0，两个对象相等

 

二.  Comparator(比较器)

       Collections.sort(list,new MyComparator());

class MyComparatorimplements Comparator<String>{

@Override

       public int compare(String o1, String o2) {

               * 按字符串长度

               * 重载的sort方法要求传入一个额外的比较器

               * 然后按照比较器的比较规则进行元素比较，从大到小输出，该方法不再要求必须实现Comparable方法，因为

               * 不适用自身规则比较

              returno1.length() -o2.length();

       }

}

* 将来有排序集合元素需求是，建议使用重载的而带有比较器的比较方法，因为不带比较器的方法要求集合元素必须时间Comparable接口，

 * 这种在使用某个功能而该功能要求你为其修改代码的现象称为侵入性，修改的代码越多，侵入性越高，耦合度越高，不利于程序扩展

 * 比较器解决两个问题，第一个是解决侵入性，不要求集合元素实现接口，还解决了另一种情况，即当元素已经实现

 * Comparable接口并定义了比较规则，但该规则不满足我们的排序需求，这是可以额外使用比较器提供的规则。

 

三.  队列和栈

队列和栈都是两端进出的

Queue  LinkedList

       Queue<String>q = newLinkedList<String>();

              /**

               * boolean offer 入队操作

               */

              q.offer("1");

              q.offer("2");

              q.offer("3");

              q.offer("4");

              System.out.println(q);

              /**

               * poll从队首取元素,返回一个取到的元素

               */

              q.poll();

              System.out.println(q);

              /**

               * peek() 返回查看的队首元素

               */

              Stringp = q.peek();

        System.out.println(p);

 

栈

 * 用于存放一组元素，元素存取必须遵循先进后出的原则.

 * 使用栈通常为了解决有后退功能的需求中

 * 栈可以使用双端队列实现，双端队列Deque，两端栈都可以进出队的队列，当仅从一端进出队时，就实现了栈的效果

public class StackDemo {

       public static void main(String[] args) {

              Deque<String>stack =newLinkedList<String>();

              stack.push("1");

              stack.push("2");

              stack.push("3");

              stack.push("4");

              System.out.println(stack);

               * pop() 获取栈顶元素，并作出栈操作，若仅想引用，还是使用peek

              stack.pop();

              System.out.println(stack);

              stack.pop();

              System.out.println(stack);

       }

}

四.  Map接口(多行两列)

KEY       VALUE              键值对

语文       数学

*java.util.Map 查找表，以key-value对的形式存储数据在Map中key是不允许重复的(equals比较)一个key对应一个value

* 通常Map实现类，HashMap，使用散列算法实现

*/

public class MapDemo1 {

       public static void main(String[] args) {

              Map<String,Integer> map =new HashMap<String,Integer>();

* V put(K k, V v) 将给定的key-value存入Map

* 因为Map不允许有重复的key，所以若给定的key已经存在，则把value替换掉，返回被替换的value，不是重复的key，返回值

* 为null

              map.put("语文", 99);

              map.put("数学", 98);

              map.put("英语", 96);

              map.put("物理", 97);

              map.put("化学", 99);

              Integers = map.put("语文", 100);

              System.out.println(s);

              System.out.println(map);

              map.remove("语文");

              System.out.println(map);

              System.out.println(map.get("化学"));

              System.out.println(map.get("美术"));

              System.out.println(map.containsKey("艺术"));

              }

}

* 遍历Map三种方式： 1.遍历所有key 2.遍历所有键值对 3.遍历所有value(相对不常用)

 */

public class MapDemo2 {

       public static void main(String[] args) {

              Map<String,Integer> map =new HashMap<String,Integer>();

              map.put("语文", 99);

              map.put("数学", 98);

              map.put("英语", 96);

              map.put("物理", 97);

              map.put("化学", 99);

* Set<K> keySet()将当前Map中的所有key存入一个Set集合后将其返回，那么遍历这个sat集合等于遍历所有的key

              Set<String>keySet =map.keySet();

              for (Stringkey :keySet) {

                     System.out.println(key);

              }

* 遍历每一组键值对，在Map中每一组键值对有Map一个内部类

* Entry保存，Entry提供了两个方法，getKey，getValue来分别获取表示这组键值对的key和value Set

* <Entry> entrySet();该方法会将当前Map中每组键值对，若干的Entry实例存入到Set集合，并返回

              Set<Entry<String,Integer>> EntrySet = map.entrySet();

              for (Entry<String,Integer>e :EntrySet) {

                     System.out.println(e.getKey() +":" +e.getValue());

              }

       }

}

               * Colletction values()

               * 将当前Map中所有的value存入到一个集合中并将其返回

              Collection<Integer> values =map.values();

              for(Integers :values){

                     System.out.println(s);

              }

 * 查看Map是否包含指定内容

public class MapDemo3 {

       public static void main(String[] args) {

              Map<String,Integer> map =new HashMap<String,Integer>();

              map.put("语文", 99);

              map.put("数学", 98);

              map.put("英语", 96);

              map.put("物理", 97);

              map.put("化学", 99);

               * 是否包含指定的key boolean containsKey(Objectk )判断Map是否包含给定的key

              booleancontains =map.containsKey("体育");

              System.out.println(contains);  

               * boolean containsValue(Object v)判断是否包含该value

              contains = map.containsValue(99);

              System.out.println(contains);

       }

}

通过k的hascode，运用散列算法，算出一定的值存放在固定位置

Map最好不要出现链表。同hashcode就会出现一个格子出现两个人的情况

HashCode在Object类中有定义，一般需要重写

* 使用该类才测试作为Map中的key元素的equals与hashcode方法的重写准则

 * API手册上明确说明，当我们重写equals的时候就应当连同hashcode一起重写

 * 应当遵循:

 * 一致性：当两个对象equals比较为true时，那么hashcode方法返回的数字必须相同，反过来虽然不是强制的

 * 但是尽量保证两个对象hashcode若相同，equals比较也为true，否则在HashMap中会产生链表，影响HashMap的查询性能

 * 稳定性：hashcode返回的数字在当前对象参与equals比较的属性值没有发生改变的前提下，多次调用返回的数字应当不变

 

散列算法只要其中一个参数变了，运行的整个结果就会改变，值超过12个的时候，数组扩容一倍，但是散列算法依据的是数组的大小，hashCode的值不会变，但是通过散列算法之后算出来的值将会改变，所以位置会改变

容量：capacity

Size：大小

Load factor 加载因子  size/ capacity

new的同时可以给数组的长度 new HashMap(xxxxxxxxxx)

 

 

 

* 有序的HashMap存储顺序与迭代顺序一致

public class MapDemo4 {

       public static void main(String[] args) {

              Map<String,Integer> map =new LinkedHashMap<String,Integer>();

              map.put("语文", 99);

              map.put("数学", 98);

              map.put("英语", 96);

              map.put("物理", 97);

              map.put("化学", 99);

              Set<String>keySet =map.keySet();

              for (Strings :keySet) {

                     System.out.println(s);

              }

       }

}