java基础之容器的记忆方法和使用（代码详解）

1136法：

一个图；一个类；三个知识点；六个接口。

一个图：

一个类：

Collections类：
Collections(要记住的类)，提供了一些静态方法实现了基于List容器的一些常用方法suffle（随机排序）、binarySearch（二分查询）等。

package javaBasic.collection;
import java.util.*;
/**
 * @author yn
 */
public class TestLinkedList3 {
    public static void main(String[] args){
        List l1 = new LinkedList();
        List l2 = new LinkedList();
        for (int i=0;i<=9;i++){
            l1.add("a"+i);
        }
        System.out.println(l1);
        Collections.shuffle(l1);//随机排列；
        System.out.println(l1);
        Collections.reverse(l1);//逆序；
        System.out.println(l1);
        Collections.sort(l1);
        System.out.println(l1);
        System.out.println(Collections.binarySearch(l1,"a5" ));//二分查找
    }
}

3个知识点：

1. For(基础)；

2. Generic：泛型

• 在定义集合时同时定义集合中对象的类型，使用<>；
• 好处：增强程序的可读性和稳定性；

3.Auto-boxing/unboxing：在合适的时候自动打包解包

• 打包： 自动将基础类型转换为对象；
• 解包：自动将对象转换为基础类型。

6个接口：

Set, List, Map, Collection, Iterator, Comparable

1.set:

package javaBasic.collection;

import java.util.*;

/**
 * @author yn
 * @description  两个HashSet之间可以做运算，（由于Set集合元素不重复的特性）求交集，求并集。
 */
public class TestHashSet3 {
    public static void main(String[] args){
        Set s1 = new HashSet();
        Set s2 = new HashSet();
        s1.add("a");s1.add("b");s1.add("c");
        s2.add("d");s2.add("a");s2.add("b");
        //Set和List容器都具有construction（Collection c）
        //构造方法用以初始化容器类
        Set sn = new HashSet(s1);
        sn.retainAll(s2);
        Set su = new HashSet(s1);
        su.addAll(s2);
        System.out.println(sn);
        System.out.println(su);
    }
}

输出：
[a, b]
[a, b, c, d]

2. List:

• LinkedList的底层实现是链表（改快读慢），ArrayList的底层实现是数组（读快改慢）。
• hash两者之间。
• Linked底层链表add的时候：只需要切换指针的指向，便可以添加一个元素；
• Array底层数组add的时候，需要将后边的元素依次向后移动才能在某个位置添加一个元素。

package javaBasic.collection;

import java.util.*;
/**
 * @author yn
 * @description List方法举例 LinkedList的底层实现是链表（改快读慢），ArrayList的底层实现是数组（读快改慢）。
 * hash两者之间。
 * Linked底层链表add的时候：只需要切换指针的指向，便可以添加一个元素；
 * Array底层数组add的时候，需要将后边的元素依次向后移动才能在某个位置添加一个元素。
 */
public class TestLinkedList2 {
    public static void main(String[] args){
        List l1 = new LinkedList();
        for (int i=0;i<=5;i++){
            l1.add("a"+i);
        }
        System.out.println(l1);
        l1.add(3,"a100");
        System.out.println(l1);
        l1.add(6,"a200");//在某个位置上直接添加
        System.out.println(l1);
        System.out.println(l1.get(2)+" ");
        System.out.println(l1.indexOf("a3"));
        l1.remove(1);
        System.out.println(l1);
    }
}

3.Map:

package javaBasic.collection;
import java.util.*;

/**
 * @author yn
 * @description Map方法举例
 */
public class TestMapExample {
    public static void main(String[] args){
        Map<String,Integer> m1 = new HashMap();
        Map m2 = new TreeMap();
        //m1.put("one",new Integer(1));  //旧的写法；
        m1.put("one", 1);                        //新的写法；
        //m1.put("two",new Integer(2));
        m1.put("two", 2);
        //m1.put("three",new Integer(3));
        m1.put("three", 3);
        //m2.put("A",new Integer(1));
        m2.put("A",1 );
        //m2.put("B",new Integer(2));
        m2.put("B",2 );
        System.out.println(m1.size());
        System.out.println(m1.containsKey("one"));
        System.out.println(m2.containsValue(new Integer(1)));

        if (m1.containsKey("two")){
            //int i = (Integer) m1.get("two");
            int i =  m1.get("two");//加入泛型之后，不用再添加类型，写法越来越简单。
            System.out.println(i);
        }
        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);
    }
}

4.Collection ； 5.Iterator

package javaBasic.collection;

import java.util.*;
import java.util.HashSet;
import java.util.Iterator;


/**
 * @author yn
 * @description set，Iterator
 */
public class TestHashSet1 {
    public static void main(String[] args){
        Collection hs = new HashSet();
        hs.add(new Name("f1", "l1"));
        hs.add(new Name("f2","l2" ));
        hs.add(new Name("f3","l3" ));
        hs.add(new Name("f1", "l1"));//相同的元素不会被加入
        Iterator iterator = hs.iterator();
        while (iterator.hasNext()){
            //next()的返回值为Object类型，需要转换为相应的类型；
            Name name  = (Name)iterator.next();
            //也可以给Name写valueOf方法；
            System.out.println(name.getFirstname() + " " + name.getLastname());

        }
        System.out.println(hs);
    }
}

输出：
f1 l1
f2 l2
f3 l3
[f1 l1, f2 l2, f3 l3]

6.Comparable

• Comparable 这个j接口只有一个方法：compareTo(T o)，传入的参数是泛型，
• 使用的时候需要实现这个接口，并且要实现这个方法；（接口中的方法没有实现）

package javaBasic.collection;
import java.util.*;
/**
 * @author yn
 */
public class UseComparable {
    public static void main(String[] args){
        List l1 = new LinkedList();
        l1.add(new Name("Kar1", "M"));
        l1.add(new Name("Steven", "Lee"));
        l1.add(new Name("John", "o"));
        l1.add(new Name("Tom", "M"));
        System.out.println(l1);
        Collections.sort(l1);
        System.out.println(l1);
    }
}

输出：
[Kar1 M, Steven Lee, John o, Tom M]
[Steven Lee, Kar1 M, Tom M, John o]

package javaBasic.collection;

public class Name implements Comparable{
    private String firstname,lastname;

    Name(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }
    public String getFirstname(){
        return firstname;
    }
    public String getLastname(){
        return lastname;
    }
    public String toString(){
        return firstname + " " + lastname;
    }
    //增加Name类的equals和hashCode方法如下：
    public boolean equals(Object obj){
        if (obj instanceof Name){
            //如果这个obj是个Name对象，名等于名，姓等于姓，那就返回true
            //如果传的不是Name对象，就交给父类处理。
            Name name = (Name)obj;
            return (firstname.equals(name.firstname))&&(lastname.equals(name.lastname));
        }
        return super.equals(obj);
    }
    public int hashCode(){
        return firstname.hashCode();
    }

    public int compareTo(Object o){
        Name name = (Name)o;
        int lastCmp = lastname.compareTo(name.lastname);
        return (lastCmp!=0?lastCmp:firstname.compareTo(name.firstname));
    }
}