1.关于map的遍历
/**使用entrySet遍历map类KV，而不是keySet方式遍历
keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key
1.Map集合中提供了get()获取元素的方法，get()对应一个键去除其对应的值，这种方式比较局限和单一。
/**
* 2.不能全部取出来，要去除所有元素（值），则必须要拿到所有的键，然后才能渠道所有与其对应的值，针对这种新的需求
* java提供了相应的解决方案
* 解决方案：
* Map集合中提供了两中取出方式：
* <1> 返回值类型Set<K> 方法是keySet()：返回此映射中包含的键的set视图，将Map中所有的键存入到set集合，因为set具备迭代器，所有迭代方式取出所有的键再根据get
* 方法，获取每一个键对应的值
* <2> 返回值类型：Set<Map.Entry<K,V>>方法是entrySet()
* 去除的是关系，关系中包含key和value,其中map。entry<K,V>来标识这种数据类型：将map集合中的映射关系存入到set集合中，这个关系的数据类型为:Map.Entry
* 3.values()方法返回的是所有的value值。这就是map从三个角度去获取值的方法
*/
@Test
public void testKeyset() {
Map<String, String> map = new HashMap<>();
map.put("1", "fengyw1");
map.put("2", "fengyw2");
map.put("3", "fengyw3");
map.put("4", "fengyw4");
map.put("5", "fengyw5");
// 使用keyset遍历
Set<String> k = map.keySet();
Iterator<String> kt = k.iterator();
while (kt.hasNext()) {
String key = kt.next();
String value = map.get(key);//这个相当于又循环了一遍
System.out.println(key + ": " + value);
}
System.out.println("keyset is end ........");}
@Test
public void testEntryset() {
System.out.println("mapset is start ........");
Map<String, String> map = new HashMap<>();
map.put("1", "fengyw1");
map.put("2", "fengyw2");
map.put("3", "fengyw3");
map.put("4", "fengyw4");
map.put("5", "fengyw5");
// 使用keyset遍历
Set<Map.Entry<String, String>> setMap = map.entrySet();
Iterator<Map.Entry<String, String>> entryTr = setMap.iterator();
while(entryTr.hasNext()){
Map.Entry<String, String> entry = entryTr.next();
System.out.println(entry.getKey() +": "+entry.getValue());
}
System.out.println("mapset is end ........");
}
}
.entryset是一次遍历，keyset相当于拿到了key值以后，又对每个key值去遍历map
2.Comparator和Comparable的区别
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
(1)、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
(2)、可以使用多种排序标准，比如升序、降序
3利用set的不可重复性去重，避免list遍历
package entity;
import java.util.Comparator;
public class User implements Comparable<User>{
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;
}
@Override
public int compareTo(User o) {
// TODO Auto-generated method stub
return this.name.compareTo(o.name);
}
}
package mytest;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.Set;
import java.util.TreeSet;
import entity.User;
public class MySet {
public static void main(String[] args){
ArrayList<User> mList = new ArrayList<>();
ArrayList<User> subList = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
User people = new User();
people.setAge(10 + i);
people.setName("jack" + i);
mList.add(people);
}
for (int i = 0; i < 9999; i++) {
User people = new User();
people.setAge(10 + i);
people.setName("jack" + i);
subList.add(people);
}
quchong(mList,subList);
quchongSet(mList,subList);
}
private static void quchong(ArrayList<User> mList, ArrayList<User> subList) {
Long s = new Date().getTime();
for (User people : subList) {
for (int i = 0; i < mList.size(); i++) {
if (people.getName().equals(mList.get(i).getName())) {
mList.remove(i);
}
}
}
Long s2 = new Date().getTime();
System.out.println("去重耗费了"+ (s2-s));//去重耗费了556
}
private static void quchongSet(ArrayList<User> mList, ArrayList<User> subList) {
Long s = new Date().getTime();
Set<User> user1 = new TreeSet<User>();
user1.addAll(mList);
user1.removeAll(subList);
Long s2 = new Date().getTime();
System.out.println("去重耗费了"+ (s2-s));//去重耗费了2
}
}
4.合理利用好集合的有序性 (sort) 和稳定性 (order)
说明：稳定性指集合每次遍历的元素次序是一定的。有序性是指遍历的结果是按某种比较规则
依次排列的。如： ArrayList 是 order / unsort；HashMap 是 unorder / unsort；TreeSet 是
order / sort
5.java中的ListIterator和Iterator
(1)Iterator可以应用于所有的集合，Set、list和map这些集合的子类型，而ListIterator只能用于list及其子类型
(2)ListIterator有add方法，可以向List中添加对象，而Iterator不能
(3)ListIterator和Iterator都有hashNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法。可以逆向。
(4)ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能
(5)都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改
package mytest;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class IteratorListTest {
@Test
public void test(){
// TODO Auto-generated method stub
List<String> list = new LinkedList<>();
list.add("fengyw1");
list.add("fengyw2");
list.add("fengyw3");
ListIterator<String> iter = list.listIterator();
String first = iter.next();
iter.remove(); //如果这里不删除也不添加，用set，结果一样
System.out.println("first:"+first);
iter.add("fengyw4");
//遍历List元素
System.out.println("遍历List中元素，方法一：");
for(String str : list)
System.out.println(str+" ");
iter = list.listIterator();
System.out.println("遍历List中元素，方法二：");
while(iter.hasNext())
{
System.out.println(iter.next());
}
System.out.println("遍历List中元素，方法三：");
Iterator<String> iterTor = list.iterator();
while(iterTor.hasNext()){
System.out.println(iterTor.next());
}
}
}
first:fengyw1
遍历List中元素，方法一：
fengyw4
fengyw2
fengyw3
遍历List中元素，方法二：
fengyw4
fengyw2
fengyw3
遍历List中元素，方法三：
fengyw4
fengyw2
fengyw3
6.ArraList中的iterator的理解
private class Itr implements Iterator<E> {
int cursor; // cursor表示下一个元素的索引位置
int lastRet = -1; // lastRet表示上一个元素的索引位置
int expectedModCount = modCount;//modCount用于记录ArrayList集合的修改次数
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {//获取当前元素
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);//调用了本身的remove方法
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
原文：http://www.cnblogs.com/fengyuwan/p/6674943.html