java集合稳定性_java集合（二）

1.关于map的遍历

/**使用entrySet遍历map类KV，而不是keySet方式遍历

keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key

1.Map集合中提供了get()获取元素的方法，get()对应一个键去除其对应的值，这种方式比较局限和单一。

/**

* 2.不能全部取出来，要去除所有元素(值)，则必须要拿到所有的键，然后才能渠道所有与其对应的值，针对这种新的需求

*  java提供了相应的解决方案

*  解决方案：

*  Map集合中提供了两中取出方式：

*  <1> 返回值类型Set方法是keySet()：返回此映射中包含的键的set视图，将Map中所有的键存入到set集合，因为set具备迭代器，所有迭代方式取出所有的键再根据get

*    方法，获取每一个键对应的值

*  <2> 返回值类型：Set>方法是entrySet()

*   去除的是关系，关系中包含key和value,其中map。entry来标识这种数据类型：将map集合中的映射关系存入到set集合中，这个关系的数据类型为:Map.Entry

* 3.values()方法返回的是所有的value值。这就是map从三个角度去获取值的方法

*/

@Test

public void testKeyset() {

Map 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 k = map.keySet();

Iterator 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 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> setMap = map.entrySet();

Iterator> entryTr = setMap.iterator();

while(entryTr.hasNext()){

Map.Entry 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{

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 mList = new ArrayList<>();

ArrayList 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 mList, ArrayList 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 mList, ArrayList subList) {

Long s = new Date().getTime();

Set user1 = new TreeSet();

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 list = new LinkedList<>();

list.add("fengyw1");

list.add("fengyw2");

list.add("fengyw3");

ListIterator 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 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 {

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();

}

}