5，集合框架

集合框架：对象容器

集合中存储的都是引用类型的元素，那么引用类型变量实际上存储的是对象的“地址”，所以实际上集合只存储了元素对象在堆中

的地址。而并不是将对象本身存入了集合中。

Collection-Collections区别？

List

ArrayList

LinckedList

Set

HashSet->HashMap

LinckedHashSet->链表

Map

HashMap->16*x

LinckedHashMap

HashTable

队列和栈

Queue

Deque

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

package caokangnsd;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;


public class CollectionAndMap {
/*

* 集合 Collection 

* |                           | 

* List                        Set 

* |         |          |      |       |         | 

* Arraylist LinkedList Vector HashSet SortedSet LinkedHashSet 

* |                                   | 

* Stack                               TreeSet
*
*
* Map | | | | Hashtable HashMap LinkedHashMap SortedMap | TreeMap 链表和散列表，哈希算法

* 1，集合中的方法 2，数组加入 3，sort 4，存储参考图片

*/

public static void main(String[] args) {

// 首先建立一个存在的集合

Collection<String> ex = new ArrayList<String>();// String对象的集合

ex.add("A");

ex.add("B");

System.out.println(Arrays.toString(ex.toArray()));

// 分别创建不同类型的集合

List<String> arraylist = new ArrayList<String>();

List<String> linkedlist = new LinkedList<String>();

Set<String> hashset = new HashSet<String>();

Set<String> linkedhashset = new LinkedHashSet<String>();

Map<String, String> hashmap = new HashMap<String, String>();
//
// clear,size,isEmpty
// add,addAll

arraylist.add("one");

hashset.add("one");

arraylist.add("two");

hashset.add("two");

arraylist.addAll(ex);

hashset.addAll(ex);

arraylist.add(2, "three");

System.out.println(arraylist);

System.out.println(hashset);

linkedhashset = new LinkedHashSet<String>(arraylist);// 插入顺序排序，直接加入集合

System.out.println(linkedhashset);

// get,set

String a = arraylist.get(2);

System.out.println(a);

arraylist.set(1, "three");

System.out.println(arraylist);

// linkedlist.set(1, "A");

// remove,removeAll

arraylist.remove("three");// 删除第一个相同的元素

arraylist.remove(2);//如果元素也是2，位置优先

System.out.println(arraylist);

hashset.remove("two");

System.out.println(hashset);

// contains,containsAll

// 对于List来说ArrayList更利于查询和增删，LinkedList更利于增删，在之后的队列和栈中表现

// 对于Set来说常用HashSet无序不重复，所以不用遍历查询的效率是非常高的

// Iterator

Iterator it = arraylist.iterator();// 1

while (it.hasNext()) {

String str = it.next().toString();

System.out.println("-" + str);

if ("one".equals(str)) {

it.remove();// 迭代器中的删除方法

}

}

System.out.println(arraylist);// 2

for (String str : arraylist) {

System.out.println(str);

}

arraylist.forEach((str) -> System.out.println(str));// 3

// 队列和栈

Queue q = new LinkedList();// 先进先出

q.offer(1);

q.offer('A');

q.offer("B");

for (int i = 0; i < q.size(); i++) {

System.out.println(q.peek());// 查看

q.poll();// 删除

}

Deque d = new LinkedList();

d.offer(1);

d.offer(2);

d.push(3);// push

d.pop();// pop

d.offerFirst(0);// offerFirst

d.pollLast();

System.out.println(d);

// subList,asList,.toArray集合和数组的转换

arraylist.clear();

arraylist.add("one");

arraylist.add("two");

arraylist.addAll(ex);

arraylist.add(2, "three");

System.out.println(arraylist);

List sub = arraylist.subList(0, 2);

// System.out.println(sub);

// sub.clear();//

// System.out.println(arraylist);//删除的问题

Object[] strs = arraylist.toArray();

System.out.println(Arrays.toString(strs));

strs = Arrays.copyOf(strs, strs.length - 1);// 不存在删除的问题

System.out.println(Arrays.toString(strs));

System.out.println(arraylist);

String[] strs1 = { "A", "B", "C" };

List<String> list = Arrays.asList(strs1);

System.out.println(Arrays.toString(strs1));

list.set(1, "C");

System.out.println(Arrays.toString(strs1));// 这里转换成集合之后不能增删只能更改，且会改变

数组

// sort可以被Collections.sort的类型都是继承了Comparable接口

List<Sort1> sort1 = new ArrayList<Sort1>();// 1

sort1.add(new Sort1(3, 2));

sort1.add(new Sort1(1, 2));

sort1.add(new Sort1(2, 2));

Collections.sort(sort1);

System.out.println(sort1.toString());// OK

Collections.sort(sort1, new Comparator<Sort1>() {// 2

@Override

public int compare(Sort1 s1, Sort1 s2) {

// TODO Auto-generated method stub

return s2.x - s1.x;

}

});

System.out.println(sort1.toString());

// Map

/*

* 散列表的存储 根据key的哈希值来存储，本身是不重复的，equals的对象哈希值必定相等，哈希值相等未必

equals

* 根据哈希值找寻key根据key找寻values这样无序的存储，但是有相同的哈希值时以List存储在一个位置

* 本身具有容量16，我们可以设置它的容量和利用率，默认的利用率在3/4

* 

*/

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

map.put("one", "haha");

map.put("two", "heihei");

map.put("three", "hehe");

System.out.println(map.get("one"));//

map.remove("one");

System.out.println(map);

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

System.out.println(keys);

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

System.out.println(values);

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

for(Entry<String,String> entry:keyvalue) {

System.out.println(entry.getKey()+","+entry.getValue());

}

//补充之BlockingQueue->ArrayBlockingQueue,LinkedBlockingQueue;

//两个最为特殊的方法put(),take()等待放入和取出

//offer(e,time,u),poll(time,u)多长的时间内将元素插入或拿出

BlockingQueue<String> bq=new ArrayBlockingQueue<>(5);//需要设置初始容量

try {

bq.offer("haha", 5, TimeUnit.MILLISECONDS);//offer

bq.poll(5,TimeUnit.MILLISECONDS);

bq.put("heihei");

bq.take();

} catch (InterruptedException e) {//这里说明是线程

// TODO Auto-generated catch block
e.printStackTrace();

}


}

}


class Sort1 implements Comparable<Sort1> {

int x;

int y;


public Sort1(int x, int y) {

this.x = x;

this.y = y;

}


@Override
public int compareTo(Sort1 s) {

// TODO Auto-generated method stub

return this.x - s.x;

}


public String toString() {

return "" + this.x;

}


}