java 集合 LinkedHashSet

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Set;

/**

 * 类HashSet和LinkedHashSet都是接口Set的实现，

 * 两者都不能保存重复的数据。

 * 主要区别是HashSet不保证集合中元素的顺序，

 * 即不能保证迭代的顺序与插入的顺序一致。

 * 而LinkedHashSet按照元素插入的顺序进行迭代，

 * 即迭代输出的顺序与插入的顺序保持一致。

 * @author 蓝

 *

 */

public class LinkHashSetTest {

    public static void main(String[] args) {

        Set<Integer> hashIntdger=new HashSet<Integer>();

        Set<String> hashString=new HashSet<String>();

        Set<Integer> linkHashInteger=new LinkedHashSet<Integer>();

        Set<String> linkHashString=new LinkedHashSet<String>();

        for(int i=0;i<20;i++)

        {

            hashIntdger.add(i);

            hashString.add(String.valueOf(i));

            linkHashInteger.add(i);

            linkHashString.add(String.valueOf(i));

        }

        boolean inOder;

        System.out.println("Integer类型hashSet存储顺序:");

        LinkHashSetTest.printSet(hashIntdger);

        inOder=LinkHashSetTest.IsSaveInOrder(hashIntdger);

        System.out.println("按顺序存储？"+inOder);

        

        System.out.println("String类型hashSet存储顺序:");

        LinkHashSetTest.printSet2(hashString);

        inOder=LinkHashSetTest.IsSaveInOrder2(hashString);

        System.out.println("按顺序存储？"+inOder);

        

        System.out.println("Integer类型LinkedhashSet存储顺序:");

        LinkHashSetTest.printSet(linkHashInteger);

        inOder=LinkHashSetTest.IsSaveInOrder(linkHashInteger);

        System.out.println("按顺序存储？"+inOder);

        

        System.out.println("String类型LinkedhashSet存储顺序:");

        LinkHashSetTest.printSet2(linkHashString);

        inOder=LinkHashSetTest.IsSaveInOrder2(linkHashString);

        System.out.println("按顺序存储？"+inOder);

    }

    //添加方法

    static void add(Set<Integer> set,Integer integer)

    {

        set.add(integer);

    }

    static void add(Set<String> set,String string)

    {

        set.add(string);

    }

    //遍历方法

    static void printSet(Set<Integer> set)

    {

//        Iterator<Integer> iterator=set.iterator();

        System.out.print("{");

        for(Iterator<Integer> it=set.iterator();it.hasNext();)

        {

            System.out.print(it.next()+" ");

        }System.out.println("}");

    }

    static void printSet2(Set<String> set)

    {

//        Iterator<Integer> iterator=set.iterator();

        System.out.print("{");

        for(Iterator<String> it=set.iterator();it.hasNext();)

        {

            System.out.print(it.next()+" ");

        }System.out.println("}");

    }

    static boolean IsSaveInOrder(Set<Integer> set)

    {

        int i=0;

        Iterator<Integer> it=set.iterator();

        while(it.hasNext())

        {

            int ob=it.next();

            if(ob!=i)

            {

                return false;

            }

            i++;

        }

        return true;

    }

    static boolean IsSaveInOrder2(Set<String> set)

    {

        int i=0;

        Iterator<String> it=set.iterator();

        while(it.hasNext())

        {

            String ob=it.next();

            if(!ob.equals(String.valueOf(i)))

            {

                return false;

            }

            i++;

        }

        return true;

    }
}

结果：

Integer类型hashSet存储顺序:

{0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 }

按顺序存储？true

String类型hashSet存储顺序:

{11 12 13 14 15 16 17 18 19 0 1 2 3 4 5 6 7 8 9 10 }

按顺序存储？false

Integer类型LinkedhashSet存储顺序:

{0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 }

按顺序存储？true

String类型LinkedhashSet存储顺序:

{0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 }

按顺序存储？true