Java面向对象 集合（下）
知识概要：
（1）Map集合的体系结构
（2）Map集合的方法
（3）HashMap TreeMap
（4）集合框架中的常用工具类
（5）高级for循环
Map集合的体系结构
Map
|--Hashtable: 底层是哈希表数据结构，不可以存入null键null值。 该集合是线程同步的。jdk1.0.效率低。
|--HashMap： 底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代
|--TreeMap： 底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
Map集合的常用方法
1，添加。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2，删除。
clear()
remove(Object key)
3，判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
4，获取。
get(Object key)
size()
values()
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>(); //添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
//并put方法会返回被覆盖的值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wnagwu"));
map.put("02","zhangsan2");
map.put("03","zhangsan3"); System.out.println("containsKey:"+map.containsKey("022"));
//System.out.println("remove:"+map.remove("02")); System.out.println("get:"+map.get("023")); map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。 //获取map集合中所有的值。
Collection<String> coll = map.values(); System.out.println(coll);
System.out.println(map); }
}
map集合的两种取出方式：
1，Set<k> 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集合中的元素。
import java.util.*; class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>(); map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4"); //将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet() Iterator<Map.Entry<String,String>> it = entrySet.iterator(); while(it.hasNext())
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue(); System.out.println(key+":"+value); } /*
//先获取map集合的所有键的Set集合,keySet();
Set<String> keySet = map.keySet(); //有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator(); while(it.hasNext())
{
String key = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
} */ }
}
<strong>/*
每一个学生都有对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性 1，描述学生。 2，定义map容器。将学生作为键，地址作为值。存入。 3，获取map集合中的元素。 */ import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
} public int compareTo(Student s)
{
int num = new Integer(this.age).compareTo(new Integer(s.age)); if(num==0)
return this.name.compareTo(s.name);
return num;
} public int hashCode()
{
return name.hashCode()+age*34;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配"); Student s = (Student)obj; return this.name.equals(s.name) && this.age==s.age; }
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
} class MapTest
{
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>(); hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi1",21),"tianjin");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuhan"); //第一种取出方式 keySet Set<Student> keySet = hm.keySet(); Iterator<Student> it = keySet.iterator(); while(it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);
System.out.println(stu+".."+addr);
} //第二种取出方式 entrySet
Set<Map.Entry<Student,String>> entrySet = hm.entrySet(); Iterator<Map.Entry<Student,String>> iter = entrySet.iterator(); while(iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"........."+addr);
}
}
}
</strong>
集合工具类
Collections:集合框架的工具类。里面定义的都是静态方法。
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
Collections.shuffle(list); 将集合打乱顺序
Arrays:
用于操作数组的工具类。
里面都是静态方法。
asList:将数组变成list集合
把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
集合变数组。
Collection接口中的toArray方法。
<strong>/*
集合变数组。
Collection接口中的toArray方法。 */
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>(); al.add("abc1");
al.add("abc2");
al.add("abc3"); /*
1,指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。剩余的数组位置为null
所以创建一个刚刚好的数组最优。 2,为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。 */ String[] arr = al.toArray(new String[al.size()]); System.out.println(Arrays.toString(arr)); }
}
</strong>
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
只能获取集合元素。但是不能对集合进行操作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
import java.util.*; class ForEachDemo
{
public static void main(String[] args)
{ ArrayList<String> al = new ArrayList<String>(); al.add("abc1");
al.add("abc2");
al.add("abc3"); for(String s : al)
{
//s = "kk";
System.out.println(s);
} System.out.println(al);
/*
Iterator<String> it = al.iterator(); while(it.hasNext())
{
System.out.println(it.next());
}
*/ int[] arr = {3,5,1}; for(int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
}
for(int i : arr)
{
System.out.println("i:"+i);
} HashMap<Integer,String> hm = new HashMap<Integer,String>(); hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c"); Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
} // Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
// for(Map.Entry<Integer,String> me : entrySet) for(Map.Entry<Integer,String> me : hm.entrySet())
{
System.out.println(me.getKey()+"------"+me.getValue());
} }
}
首先要明白一点：加入Set里面的元素必须定义equals()方法以确保对象的唯一性。
第一个问题：TreeSet是怎么实现有序的，它是按什么规则排序的？
TreeSet的底层实现是采用红-黑树的数据结构，采用这种结构可以从Set中获取有序的序列，但是前提条件是：元素必须实现Comparable接口，该接口中只用一个方法，就是compareTo()方法。当往Set中插入一个新的元素的时候，首先会遍历Set中已经存在的元素（当然不是采用顺序遍历，具体采用什么方法，建议自己去看看源码），并调用compareTo()方法，根据返回的结果，决定插入位置。进而也就保证了元素的顺序。
第二个问题：它们怎么保证元素的不重复，是根据什么判断两个元素相同而不再添加的呢？
上面已经说过，加入Set里面的元素必须定义自己的equals()方法，但是对于良好的设计风格，最好在覆盖equals()方法的同时，也覆盖hashCode()方法，当然，对于TreeSet而言不用覆盖hashCode()方法也可。请记住：覆盖hashCode()方法的目的，只有一个原因就是提高效率。
在往Set中插入新的对象时，首先会用该对象的hashCode()与已经存在对象的hashCode()做比较，如果相等，那就不能插入，如果不等，才会调用equals()方法，如果equals结果为true，说明已经存在，就不能再插入，如果为false，可以插入。
注：如果没有覆盖hashCode()方法，那就是只比较equals().对两个对象equals运算，是判断两个对象是否相等的关键