——- android培训、java培训、期待与您交流！ ———-
Map集合：
1、概念
|–Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。
|–HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.
|–TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。
Map集合存储和Collection的不同：
Collection一次存一个元素；Map一次存一对元素。
Collection是单列集合；Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
特点：要保证map集合中键的唯一性。
2、相关方法
1，添加。
put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。
void putAll(Map);
2，删除。
void clear()：清空
value remove(key) ：删除指定键。
3，判断。
boolean isEmpty()：
boolean containsKey(key)：是否包含key
boolean containsValue(value) ：是否包含value
4，取出。
int size()：返回长度
value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。
Collection values()：获取map集合中的所有的值。
5，获取map中的所有元素：
原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。
3、方法展示：
package XianChen;
import java.util.*;
import javax.swing.text.html.HTMLDocument.Iterator;
/**
* @author Administrator
*
*/
public class LiZi {
public static void main(String[] args) {
Tree();
}
public static void Tree(){
Map<Integer,Person> hp = new HashMap<Integer,Person>();
hp.put(001,new Person("a",11));
hp.put(003,new Person("a",12));
hp.put(002,new Person("a",14));
// 同键 则覆盖旧值
// [1=[a=10], 2=[a=14], 3=[a=12]]
hp.put(001,new Person("a",10));
// 可以存储空值，实际是将空值 作为对应对象存进
hp.put(null,null);
// 键唯一 ，覆盖上一个
// {null=[a=16], 1=[a=10], 2=[a=14], 3=[a=12], 5=null}
hp.put(null,new Person("a",16));
hp.put(005,null);
// 按键的顺序返回所有值的集合
hp.values();
System.out.println(hp.values());
}
}
// 自定义比较器 实现 Comparator 覆盖 Compare()
class Compar implements Comparator<Person>{
//比较方法：
public int compare(Person o1, Person o2) {
int num=o1.getName().compareTo(o2.getName());
if(num==0){
return o1.getAge()-o2.getAge();
}
return num;
}
}
//自定义类 实现 Comparable() 覆盖 CompareTo()
class Person implements Comparable<Person>{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
// 比较方法：
public int compareTo(Person o) {
int num=this.age-o.age;
if(num==0)
return this.name.compareTo(o.name);
else
return num;
}
public String toString() {
return "[" + name + "=" + age + "]";
}
}
map集合的两种取出方式：
1， Set keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。 Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2， Set< Map.Entry < k,v >> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry，Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。
package JiHe;
import java.util.*;
import javax.swing.text.html.HTMLDocument.Iterator;
public class MapLianxi {
public static void main(String[] args) {
String str= "adadadfdgfgthrhrfdg";
char[] ch =str.toCharArray();
Map<Character,Integer> map=new TreeMap<Character,Integer>();
for(int x=0;x<ch.length;x++){
int count=0;
if(map.get(ch[x])!=null)
count=map.get(ch[x]);
count++;
map.put(ch[x], count);
}
StringBuilder sb= new StringBuilder();
// 迭代方式一： Entry
Iterator<Map.Entry<Character, Integer>> it= map.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Character, Integer> me= it.next();
Character key=me.getKey();
Integer value=me.getValue();
sb.append(key+"("+value+")");
}
System.out.println(sb.toString());
sb.delete(0, sb.length());
// 迭代方式二 keySet
Iterator<Character> iter=map.keySet().iterator();
while(iter.hasNext()){
char cher=iter.next();
int val=map.get(cher);
sb.append(cher+"("+val+")");
}
System.out.println(sb.toString());
}
}
4、集合选择技巧：
看到Array就是数组结构，有角标，查询速度很快。
看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
看到tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。
保证唯一，就用Set。不保证唯一，就用List。
Collections
它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。
静态方法：
Collections.sort(list);//list集合进行元素的自然顺序排序。
//按指定的比较器方法排序。
Collections.sort(list,new ComparatorByLen());
class ComparatorByLen implements Comparator<String>{
public int compare(String s1,String s2){
int temp = s1.length()-s2.length();
return temp==0?s1.compareTo(s2):temp;
}
}
Collections.max(list); //返回list中字典顺序最大的元素。
int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。
Collections.reverseOrder();//逆向反转排序。
Collections.shuffle(list);//随机对list中的元素进行位置的置换。
将非同步集合转成同步集合的方法：Collections中的 XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);
原理：定义一个类，将集合所有的方法加同一把锁后返回。
Collection 和 Collections的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等
``` Arrays：
===========
<div class="se-preview-section-delimiter"></div>
### 1、静态方法。
asList方法：将数组转换成list集合。
String[] arr = {"abc","kk","qq"};
List<String> list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；
可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。
如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
集合变数组：用的是Collection接口中的方法：toArray();
如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。
如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。
将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。
<div class="se-preview-section-delimiter"></div>
增强for 循环
========
增强for循环：foreach语句，foreach简化了迭代器。
格式：
<div class="se-preview-section-delimiter"></div>
// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for( 元素类型 变量名 : Collection集合 & 数组 ) {
…
}
**高级for循环和传统for循环的区别：**
高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。
作用：对存储对象的容器进行迭代： 数组 collection map
**1、增强for循环迭代数组：**
String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
for(String s : arr) {
System.out.println(s);
}
**2、单列集合 Collection：**
List list = new ArrayList();
list.add("aaa");
// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
for(Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
**3、双列集合 Map：**
<div class="se-preview-section-delimiter"></div>
Map map = new HashMap();
map.put(“a”, “aaa”);
// 传统方式
Set entrys = map.entrySet(); // 1.获得所有的键值对Entry对象
iter = entrys.iterator(); // 2.迭代出所有的entry
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
String key = (String) entry.getKey(); // 分别获得key和value
String value = (String) entry.getValue();
System.out.println(key + “=” + value);
}
// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
<div class="se-preview-section-delimiter"></div>
for(Object obj : map.entrySet()) {
Map.Entry entry = (Entry) obj; // obj 依次表示Entry
System.out.println(entry.getKey() + “=” + entry.getValue());
}
**集合迭代注意问题：**
在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
**增强for循环注意问题：**
<div class="se-preview-section-delimiter"></div>
在使用增强for循环时，不能对元素进行赋值；
int[] arr = {1,2,3};
for(int num : arr) {
num = 0; //不能改变数组的值
}
System.out.println(arr[1]); //2
**相关代码**
<div class="se-preview-section-delimiter"></div>
package XianChen;
import java.util.*;
import java.util.Map.Entry;
/**
* @author Administrator
*
*/
public class LiZi {
public static void main(String[] args) {
Tree();
}
public static void Tree(){
Map<Integer,Person> hp = new HashMap<Integer,Person>();
hp.put(001,new Person("a",11));
hp.put(003,new Person("a",12));
hp.put(002,new Person("a",14));
// 同键 则覆盖旧值
// [1=[a=10], 2=[a=14], 3=[a=12]]
hp.put(001,new Person(“a”,10));
// 可以存储空值，实际是将空值 作为对应对象存进
hp.put(null,null);
// 键唯一 ，覆盖上一个
// {null=[a=16], 1=[a=10], 2=[a=14], 3=[a=12], 5=null}
hp.put(null,new Person(“a”,16));
hp.put(005,null);
// 按键的顺序返回所有值的集合
hp.values();
System.out.println(hp.values());
// 方式一： keySet
Set keyset = hp.keySet();
Iterator it = keyset.iterator();
while(it.hasNext()){
Integer key =it.next();
System.out.println(key+” “+hp.get(key));
}
// 方式二： entrySet
Iterator