java的collection的学习

比较器，需要继承 Comparable<T> 这个接口，并实现 compareTo() 方法。

挽救的比较器，Comparator ，如果类没有实现 Comparable<T> 接口，而又不能修改这个类，那么就使用 Comparator 。

 

Iterator 接口 和 Iterable 接口的区别

//（1）Iterator 接口  
// 理解为：迭代器。
// 输出集合时，使用该接口。

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

//（2）Iterable 接口  
// 理解为：可迭代的。
// 该接口不能给集合输出，只能先将集合转换成 Iterator 接口输出

//定义：
public interface Iterable<T> {

    //这个方法，表示转换为 Iterator 接口
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

 

 

Collection 接口

（1）是单集合的最大父接口。

// 定义：
public interface Collection<E> extends Iterable<E>

Vector 类（废弃）

性质：（）

//定义：
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

 

LinkedList 类

性质：（1）继承了Deque接口，而Deque接口又继承了Queue接口，所以，LinkedList可以作为队列和双端队列使用。

// 定义：
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

 

HashSet 类

性质： （1）HashSet的底层实现是HashMap，将add(E e)中的e作为key存储在HashMap中。（2）HashSet 判断重复元素的依据是根据Object类的 hashCode() 和 equals()两个方法。

// HashSet
class Book {
    private String title;
    private double price;
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result + ((title == null) ? 0 : title.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price))
            return false;
        if (title == null) {
            if (other.title != null)
                return false;
        } else if (!title.equals(other.title))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "书名：" + this.title + "，价格：" + this.price + "\n";
    }
}
public class HashSetDemo {
    public static void main(String[] args) {
        Set<Book> all = new HashSet<Book>();			// 实例化Set接口
        all.add(new Book("Java开发实战经典", 79.8));		// 保存数据
        all.add(new Book("Java开发实战经典", 79.8)); 		// 全部信息重复
        all.add(new Book("JSP开发实战经典", 79.8)); 		// 价格信息重复
        all.add(new Book("Android开发实战经典", 89.8)); 	// 都不重复
        System.out.println(all);
    }
}

//运行结果：
[书名：Android开发实战经典，价格：89.8
, 书名：JSP开发实战经典，价格：79.8
, 书名：Java开发实战经典，价格：79.8
]

TreeSet 类

性质： （1）保证数据时存储是有序；（2）注意：要进行对象排序，对象所在的类需要 Comparable<T> 的 compareTo(T o) 方法。（3）将元素存储在红-黑数的数据结构中。

// TreeSet，要进行对象排序，对象所在的类需要Comparable的compareTo()方法。
class Book implements Comparable<Book> {				// 需要实现Comparable接口
    private String title;
    private double price;
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    @Override
    public String toString() {
        return "书名：" + this.title + "，价格：" + this.price + "\n";
    }
    @Override
    public int compareTo(Book o) {					// 排序方法，比较所有属性
        if (this.price > o.price) {
            return 1;
        } else if (this.price < o.price) {
            return -1;
        } else {
            return this.title.compareTo(o.title); 			// 调用String类的比较大小
        }
    }
}
public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Book> all = new TreeSet<Book>();			// 实例化Set接口
        all.add(new Book("Java开发实战经典", 79.8));		// 保存数据
        all.add(new Book("Java开发实战经典", 79.8)); 		// 全部信息重复
        all.add(new Book("JSP开发实战经典", 79.8)); 		// 价格信息重复
        all.add(new Book("Android开发实战经典", 89.8)); 	// 都不重复
        System.out.println(all);
    }
}

//运行结果：
[书名：JSP开发实战经典，价格：79.8
, 书名：Java开发实战经典，价格：79.8
, 书名：Android开发实战经典，价格：89.8
]

Comparable和Comparator区别

见：Java中Comparable和Comparator区别小结

 

LinkedHashSet 类

性质：是按照被添加的顺序保存对象的。

// 定义：
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable

 

集合的输出

一般使用 Iterator<E> 接口，或者使用 foreach 语法。

// Iterator 接口输出集合。
public class CollectionOutput {
    public static void main(String[] args) {
        List<String> all = new ArrayList<String>() ;	// 实例化List集合
        all.add("Hello"); 						// 保存重复元素
        all.add("mldn");						// 保存数据
        all.add("World");						// 保存数据
        all.add("Yootk");						// 保存数据
        Iterator<String> iter = all.iterator() ;		// 实例化Iterator接口
        while (iter.hasNext()) {					// 判断是否有数据
            String str = iter.next() ;				// 取出当前数据
            System.out.println(str);				// 输出数据
        }
    }
}

//运行结果：
Hello
mldn
World
Yootk

foreach 语法输出，只要扩展了 Iterable 接口的类都可以使用foreach输出。

public class ForeachDemo {
    public static void main(String[] args) {
        List<String> all = new ArrayList<String>() ;	// 实例化List接口对象
        all.add("11111") ;				// 向集合保存数据
        all.add("22222") ;				// 向集合保存数据
        all.add("33333") ; 				// 向集合保存数据
        // 集合中包含的数据都是String型，所以需要使用String接收集合中的每一个数据
        for (String str : all) {					// for循环输出
            System.out.println(str);
        }
    }
}

//结果：
11111
22222
33333

 

Stack 类（废弃）

这个类已经废弃，因为继承Vector类，这个类已经废弃，而且Vector类提供了insert和remove方法（即在任何地方都可以插入或者删除），这两个方法不应该在栈中出现。

//定义：
public class Stack<E> extends Vector<E>

 

栈的实现

既然，Stack类以及被废弃，那么如果实现栈呢？使用LinkedList来实现栈，如下：

// 自己实现的一个栈
public class Stack<T> {
  private LinkedList<T> storage = new LinkedList<T>();
  public void push(T v) { storage.addFirst(v); }
  public T peek() { return storage.getFirst(); }
  public T pop() { return storage.removeFirst(); }
  public boolean empty() { return storage.isEmpty(); }
  public String toString() { return storage.toString(); }
} 

 

Queue 接口

// 接口定义：
//普通队列：接口
public interface Queue<E> extends Collection<E>

//双端队列：接口
public interface Deque<E> extends Queue<E>

// 一般用 LinkedList 实现，如：
Queue<String> queue = new LinkedList<String>();

//数组队列
public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable

//优先级队列：其remove方法获取队列中优先级最小的元素
//内存存储使用的是堆，是一个可以自我调整的二叉树
public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable

 

  Map接口

Map 的输出：利用Iterator实现Map接口的输出；

// map输出：
public class MapOutPut {
    public static void main(String[] args) {
        Map<String, Integer> map = new Hashtable<String, Integer>();	// 定义Map集合
        map.put("壹", 1);										// 保存数据
        map.put("贰", 2);										// 保存数据
        map.put("叄", 3);										// 保存数据
        map.put("叄", 33); 									// key数据重复
        // 将Map集合变为Set集合，目的是使用iterator()方法，注意泛型的统一
        Set<Map.Entry<String,Integer>> set = map.entrySet() ;
        Iterator<Map.Entry<String,Integer>> iter = set.iterator() ;	// 取得Iterator实例
        while (iter.hasNext()) {								// 迭代输出
            Map.Entry<String, Integer> me = iter.next() ;			// 取出Map.Entry
            System.out.println(me.getKey() + " = " + me.getValue());	// 输出数据
        }
    }
}

// 结果输出：
贰 = 2
壹 = 1
叄 = 33

HashMap 类

 

Hashtable 类（废弃）

同步处理，性能较低，线程安全，key不允许为null。这个类已经废弃了，推荐使用 ConcurrentHashMap。

 

TreeMap 类

可以排序的Map子类。需要实现 Comparable<T> 的 compareTo(T o) 方法

 

concurrentHashMap 类

与 concurrentHashMap 的区别，见 java的j.u.c包的学习