java容器

java容器

java容器包含两种，Map和Collection，其中Map存储键值对（两个对象以及映射关系），Collection存储对象。
CS-Note详情

https://cyc2018.github.io/CS-Notes/#/notes/Java 容器?id=collection
接口与类的关系图如下：

注：LinkList实现了Queue接口

Map接口

Map接口的实现类主要包含HashMap，TreeMap，LinkedHashMap，Properties等。、

1. TreeMap 使用红黑树（自平衡二叉查找树）构造键的关系，能够快速查找键Olog(n)。TreeKey.higherKey(K key) 获取比key大的最小键。、
2. LinkHashMap 可以顺序存放元素
   常用的方法如下：

• Map遍历
  https://www.cnblogs.com/blest-future/p/4628871.html
• Map 修改 value值，先获取到value，修改后put再添加
• Map.put()
  插入元素,同时支持修改元素
• Map.get()
  获取元素
• Map.keySet()
  获取key集合，返回Set
• Map.containsKey()
  判断是否存在某key
• Map.containsValue()
  判断是否存在某value
• Map.clear()
  清空map
• Map.remove()
  删除元素

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class helloWorld {
    public static void main(String[] args) {
     Map<Integer,Integer> map = new HashMap<Integer,Integer>();
     Map<Integer,Integer> mapcopy = new HashMap<Integer,Integer>();
     map.put(1,2);					//插入映射
     map.put(2, 4);
     map.put(9, 10);
    map.get(1);						//根据key，获取value
     Set<Integer> keys = map.keySet();    //针对key排序
     List<Integer> list = new ArrayList<Integer>(keys);
     list.sort(null);
     for(int i =0;i<list.size();i++) {
    	 	System.out.print(map.get(list.get(i))+"
");
     }

     System.out.println(map.get(1));
     if(map.containsKey(1)){			//判断是否存在key 1
    	 	System.out.println();
     }  

     if(map.containsValue(1)){		//判断是否存在value 1
 	 	System.out.println(1);
    }

     map.remove(1);					//清除key为1的映射关系
     map.clear();					//清除所有映射关系
     map.putAll(mapcopy);			//复制映射关系
     map.size();
     map.entrySet();
     
 } 
}

List接口

List接口的实现类包括vector，ArrayList，LinkedList。stack是vector的子类。(Stack 常用方法：Stack.empty(),Stack.pop(),Stack.push(),Stack.peek(),获取顶层元素，LinkedList实现了Queue接口，包括offer()压入元素返回boolean，add()当队列满时抛出异常poll()(弹出首个元素，并返回该元素，不存在返回null)，remove()（取出队首元素，不存在则抛出异常）,isEmpty(),size(),peek()获取队首元素,element()取队首元素不存在则抛出异常,offer() 压入元素)，推荐使用offer(),poll(),peek(),可以判断是否空或者满。

• ArrayList
  最为常用，通过数组实现，能够快速随机访问，当插入或者删除元素时，复杂度高，适合随机查找或者遍历，不适合插入或者删除。
• LinkedList
  链表结构存储数据，适合动态的插入或者删除元素，随机访问和遍历速度比较慢，接口中没有定义get，remove，insertlist方法。可以实现栈，队列。
• Vector
  和ArrayList类似，通过数组实现，不同的是他支持线程的同步（某一时刻只支持一个线程访问，避免多线程同时写入而引起的不一致性）但同步需要较高的花费，因此访问比ArrayList慢，通常情况下开发人员可以自己控制同步操作，尽量使用ArrayList。
  如果是对数组排序，直接使用Array.sort()函数，对List 元素排序可以使用 java.util.Collections.sort(java.util.List)，java.util.Collections.sort(java.util.List, java.util.Comparator)，对List中的元素实现comparator接口或者重载Collections.sort方法,

• 重载 Collections.sort函数

 Collections.sort(listA, new Comparator<Person>() {
            public int compare(Person arg0, Person arg1) {
                return arg0.Order - arg1.Order;
            }
        });

• 实现Comparable 接口

public class Person implements Comparable<Person> {
     public int compareTo(Person arg0) {
        return this.getOrder().compareTo(arg0.getOrder());      //这里定义你排序的规则。
    }
}

List 常用方法如下：

• List.add(4)
  插入元素4
• List.add(3,4)
  3位置出插入元素4
• List.remove()
  删除某元素
• List.contains()
  判断是否存在某元素
• List.set(3,4)
  3位置设置为4
• List.size()
  返回大小

Vector、LinkedList、ArrayList实现了List接口；
List接口中的常用抽象方法：
	1. size()
	2. isEmpty()
	3. contains(object o),判断是否存在
	4. toArray() 返回一个数组
	5. add(E e)
	6. remove(object o)
	7. remove(int index)
	8. indexOf(object o)/ lastIndexOf(object o)
	9. subList(int fromIndex,int toIndex)
	10. containsALL（Collections<?> c）
	11. addAll(Collections<? extend E> c)
	12. removeAll(Collection<?> c)
	13. sort(Comparator<? super E> c)
	Q？ object o ，E e；
	
https://www.cnblogs.com/xiarongjin/p/8309755.html    通配符讲解

<? super E> 元素类型下限
<? extend E> 元素类型上限

import java.security.acl.Permission;
import java.util.ArrayList;
import java.util.List;
import java.util.ListResourceBundle;

public class listp {

   public static void main(String[] args) {
   	// TODO Auto-generated method stub
   	List<Integer> list = new ArrayList<Integer>();
   	list.add(1);			//向后添加
   	list.add(4);
   	list.add(2);		
   	for(int i=0;i<list.size();i++)
   		System.out.print(list.get(i)+"	");
   	System.out.println();
   	list.remove(1);		//删除元素
   	list.add(10);
   	for(int i=0;i<list.size();i++)
   		System.out.print(list.get(i)+"	");
   	System.out.println();
   	if(list.contains(10))	//判断是否存在
   		System.out.println("存在");
   	list.add(1, 7);			//在指定位置添加，后面元素向后移动
   	list.set(0, 8);		
   	for(int i=0;i<list.size();i++)
   		System.out.print(list.get(i)+"	");
   	System.out.println();
   	System.out.println(list.indexOf(2));	
   	list.isEmpty();			//判断是否为空
   }
}

LinkedList 还实现了Queue接口

Queue接口中的抽象函数：
	1. add ( E e)  返回类型boolean，队列满则抛出异常
	2. offer（E e）返回类型boolean，失败返回false
	3. remove () 删除第一个元素，返回删除元素，队列为空则抛出异常
	4. poll（）同上，队列为空则返回null
	5. peek（）同element（），返回队首元素，element失败抛出异常，peek返回null
推荐使用 offer(),poll(),peek() 通过返回值判定队列是否为空或者满

Set接口

Set中每个元素都只保存一次，通常只关心set中的成员，而不是他们在set中的顺序，Set接口常见的实现类有HashSet，TreeSet，LinkedHashSet

• HashSet
  能够最快获取元素，查找时间复杂度O(n)，哈希表存储实现，数据的输出没有规律可循。
• TreeSet
  能够存储元素顺序，按照比较结果的升序保存对象，使用红黑树数据结构存储。
• LinkedHashSet
  具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。

常用方法：

• clear()
• add()
• remove()
• contains()
• isEmpty()
• size()
• iterator() 返回一个iterator对象

java迭代器

java迭代器Iterator 作为一个接口，定义了若干个函数，包括

• boolean hasNext()，判断是否还有下一个元素
• E next()，返回下一个元素
• default void remove() 删除上一个返回的元素

它的工作是遍历和选择容器中的对象。使用迭代器的好处是在更换容器时不依赖特定容器类类型

java中为什么通过接口引用指向实现接口类的对象？

方便代码的重构，基于java多态的思想。接口存在的意义是为了同一方法的多种实现，使用接口引用在调用函数时可以根据引用对象的不同采用不同的函数实现方式，在重构代码时，只需要将接口引用指向另一个类的对象即可。