集合类整理

集合类关系图如下：

一，SET:

① EnumSet

package set;

import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 12:05
 */
public class EnumSetTest {

    /**
     * EnumSet提供了对枚举的set集合操作，提供了更高效简单的枚举操作
     * 其实使用hashset也能实现对枚举的操作，应该是EnumSet更专注做枚举一些吧
     * EnumSet是一个抽象类，继承于AbstractSet，AbstractSet实现Set接口
     */
    public static void main(String[] args) {
        System.out.println("EnumSet.noneOf");
        Set<Student> set=EnumSet.noneOf(Student.class);
        set.add(Student.HARRY);
        set.add(Student.ROBBIE);
        set.add(Student.ROBIN);
        for(Student p:set){
            System.out.println(p);
        }
        set.clear();
        System.out.println();

        System.out.println("EnumSet.allOf");
        set=EnumSet.allOf(Student.class);
        for(Student p:set){
            System.out.println(p);
        }
        set.clear();
        System.out.println();

        System.out.println("EnumSet.Of one");
        set=EnumSet.of(Student.ROBIN);
        for(Student p:set){
            System.out.println(p);
        }
        System.out.println();

        System.out.println("EnumSet.Of two");
        set=EnumSet.of(Student.ROBIN,Student.HARRY);
        for(Student p:set){
            System.out.println(p);
        }
        System.out.println();

        System.out.println("hashset：");
        Set<Student> set2 = new HashSet<Student>();
        set2.add(Student.HARRY);
        set2.add(Student.ROBBIE);
        set2.add(Student.ROBIN);
        for (Student student : set2){
            System.out.println(student);
        }
    }
}

enum   Student
{
    ROBIN("robin"),
    HARRY("harry",40),
    ROBBIE("robbie");
    String name;
    int age;
    private Student(String name)
    {
        this(name,0);
    }
    private Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String toString()
    {
        return name;
    }
}

打印结果：

EnumSet.noneOf
robin
harry
robbie

EnumSet.allOf
robin
harry
robbie

EnumSet.Of one
robin

EnumSet.Of two
robin
harry

hashset：
robbie
robin
harry

② LinkedHashSet

package set;

import java.util.LinkedHashSet;
import java.util.Set;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 14:35
 */
public class LinkedHashSetTest {

    /**
     * LinkedHashSet是有序的set，不允许重复，但是跟放入的先后顺序有关。
     * 如果已经包含这个元素，那么add会失败
     */
    public static void main(String[] args) {
        Set<Integer> set = new LinkedHashSet<Integer>();
        set.add(1);
        set.add(5);
        set.add(2);
        set.add(1);

        for(Integer i : set){
            System.out.println(i);
        }
    }
}

打印结果：

1
5
2

③ TreeSet

package set;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 12:27
 */
public class TreeSetTest {

    /**
     * TreeSet是类，实现NavigableSet，NavigableSet继承SortedSet接口，SortedSet实现Set接口
     * 默认升序排序，如果要改变排序规则，可以实现Comparator的compare方法
     *  其内部使用了Map
     */
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        set.add(2);
        set.add(1);
        set.add(3);

        for(Integer i : set){
            System.out.println(i);
        }
    }
}

打印结果：

3
2
1

二，List

① LinkedList

package list;

import java.util.LinkedList;
import java.util.List;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 15:22
 */
public class LinkedListTest {

    /**
     * LinkedList和ArrayList的区别
     * LinkedList是基于链表实现的，ArrayList是基于动态数组（初始化数据长度，后期再增加长度）实现的。
     * 所以对于查询，ArrayList根据角标来查询时要比LinkedList要快。
     * 对于修改，LinkedList要比ArrayList要快，因为ArrayList是数组，数组内容在一块存储空间，需要移动其他已经存储的元素，LinkedList只需要修改前后的引用就可以了，不涉及对象的移动
     */
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);

        for(Integer i : list){
            System.out.println(i);
        }
    }
}

打印结果：

1
2

② vector

package list;

import java.util.List;
import java.util.Vector;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 15:41
 */
public class VectorTest {

    /**
     * Vector类实现了List接口，他和ArrayList的区别是，他是线程安全的。
     * 内部实现是数组
     *
     */
    public static void main(String[] args) {
        List<Integer> list = new Vector<Integer>();
        list.add(1);
        list.add(2);

        for(Integer i : list){
            System.out.println(i);
        }
    }
}

打印结果：

1
2

三，queue

① ProrityQueue

package queue;

import java.util.Comparator;
import java.util.PriorityQueue;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 17:28
 */
public class ProrityQueueTest {

    public static void main(String[] args) {
        PriorityQueue<Boss> priorityQueue = new PriorityQueue<Boss>(2,new Comparator<Boss>() {
            public int compare(Boss o1, Boss o2) {
                return o2.getAge() - o1.getAge();
            }
        });

        priorityQueue.add(new Boss("zhouhui",28));
        priorityQueue.add(new Boss("zhangjingjing",26));

        for(Boss boss : priorityQueue){
            System.out.println(boss.toString());
        }

    }
}

class Boss{
    private String name;
    private Integer age;

    public Boss(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Boss{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

打印结果：

Boss{name=‘zhouhui‘, age=28}
Boss{name=‘zhangjingjing‘, age=26}

四 map

① EnumMap

package map;

import java.util.EnumMap;
import java.util.Map;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 15:46
 */
public class EnumMapTest {

    /**
     * EnumMap的key必须是枚举类型
     */
    public static void main(String[] args) {
        Map<Student,String> map = new EnumMap<Student, String>(Student.class);
        map.put(Student.HARRY,Student.HARRY.toString());
        map.put(Student.ROBBIE,Student.ROBBIE.toString());
        map.put(Student.ROBIN,Student.ROBIN.toString());

        for(Map.Entry<Student,String> entry : map.entrySet()){
            System.out.println(entry.getKey().name + ":" + entry.getValue());
        }
    }
}

enum   Student
{
    ROBIN("robin"),
    HARRY("harry",40),
    ROBBIE("robbie");
    String name;
    int age;
    private Student(String name)
    {
        this(name,0);
    }
    private Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String toString()
    {
        return name;
    }
}

打印结果：

robin:robin
harry:harry
robbie:robbie

② hashtable

package map;

import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 16:14
 */
public class HashTableTest {

    /**
     * hashtable和hashmap的区别：
     * 1，hashtable是线程安全的，hashmap不是
     * 2，hashmap能接受key和value都是null的情况，hashtable不行
     * 3，hashmap可以通过Collections.synchronizedMap(map)变成线程安全的
     */
    public static void main(String[] args) {
        Hashtable<Integer,Integer> hashtable = new Hashtable<Integer,Integer>();
        for (int i = 0; i < 10; i++) {
            hashtable.put(i,i);
        }
        //hashtable不允许null，会报空指针
        //hashtable.put(null,null);

        for(Map.Entry<Integer,Integer> entry : hashtable.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        Map<Integer,Integer> map = new HashMap<Integer, Integer>();
        map.put(1,12);

        map = Collections.synchronizedMap(map);

    }
}

打印结果：

9:9
8:8
7:7
6:6
5:5
4:4
3:3
2:2
1:1
0:0

③ IdentityHashMap

package map;

import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 15:57
 */
public class IdentityHashMapTest {

    /**
     * IdentityHashMap判断key是否重复是用对象==，而不是想HashMap这样使用对象的toString
     * 比如"1"或者String.valueOf("1")，和new String("1")是不一样的，IdentityHashMap能放进去，而HashMap不可以。
     */
    public static void main(String[] args) {
        Map<String,String> map = new IdentityHashMap<String,String>();

        map.put("1","2");
        map.put(new String("1"),"2");

        for(Map.Entry<String,String> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

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

        map = new HashMap<String, String>();
        map.put(String.valueOf("1"),"2");
        map.put(new String("1"),"2");

        for(Map.Entry<String,String> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

    }
}

打印结果：

1:2
1:2
---------------------
1:2

④ LinkedHashMap

package map;

import java.util.Map;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 16:09
 */
public class LinkedHashMapTest {

    /**
     * 有序的map集合。
     */
    public static void main(String[] args) {
        Map<Integer,Integer> map = new java.util.LinkedHashMap<Integer, Integer>();

        map.put(1,3);
        map.put(2,3);
        map.put(3,3);

        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

打印结果：

1:3
2:3
3:3

⑤ properties

package map;

import java.util.Map;
import java.util.Properties;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 16:26
 */
public class PropertiesTest {

    /**
     * properties继承于hashtable，其key和value都是string的，即使可以提供put(Object,Object)的方法，那么最后都会toString变成String，String。
     *
     * properties类更多的是load文件，getProperty(String key)获取属性值
     */
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(new Boss("zhou",1),new Boss("zhang",12));

        for(Map.Entry<Object,Object> entry : properties.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

class Boss{
    private String name;
    private Integer age;

    public Boss(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Boss{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

打印结果

Boss{name=‘zhou‘, age=1}:Boss{name=‘zhang‘, age=12}

⑥ TreeMap

package map;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 16:53
 */
public class TreeMapTest {

    /**
     * TreeMap是根据key有序的map
     */
    public static void main(String[] args) {
        Map<Integer,Integer> map = new TreeMap<Integer, Integer>(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        map.put(1,2);
        map.put(2,3);
        map.put(3,1);

        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

    }
}

打印结果：

3:1
2:3
1:2

⑦ WeakHashMap

package map;

import java.util.Map;
import java.util.WeakHashMap;

/*
 * DESCRIPTION : 
 * USER : zhouhui
 * DATE : 2017/8/18 17:03
 */
public class WeakHashMapTest {

    /**
     * weakhashmap和hashmap的区别是：
     * weakhashmap的key如果是一个空引用，那么会被释放掉。
     */
    public static void main(String[] args) {
        String a = new String("1");

        Map<String,String> map = new WeakHashMap<String, String>();
        map.put(a,"2");

        for(Map.Entry<String,String> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        System.out.println("--------------------------------------");
        a = null;
        System.gc();

        for(Map.Entry<String,String> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

}

打印结果

1:2
--------------------------------------
时间： 2024-10-29 10:45:57

集合类整理的相关文章

java集合类整理

LinkedList 优点:插入删除迅速 缺点:不适合随机访问 List<String> staff = new LinkedList<String>(); staff.add("Amy"); staff.add("Amy"); staff.add("bob"); staff.add("car"); staff.remove("Amy");// 即使有重复的只只会删掉第一个找到的 冲

java 中关于继集合类的整理

之前看过一些关于Java集合类的内容,但是过段时间不用有些就忘记了,现在整理下以后看也方便,只是给自己当笔记看的~~~~ (转载了一些注明:http://www.cnblogs.com/leeplogs/p/5891861.html) 一般地,我们常用的集合类有这几种: List结构的集合类:ArrayList类,LinkedList类,Vector类,Stack类 Map结构的集合类:HashMap类,Hashtable类 Set结构的集合类:HashSet类,TreeSet类 Queue结构

java 中关于集合类的整理02

四. 具体的集合 2. ArrayList 数组列表 注: ArrayList类 与 Vector类 有什么区别呢? 答:Vector类的所有方法都是同步的,所以说Vector类是线程安全的,所以两个线程可以安全的访问一个Vector对象. 但是,如果只有一个线程访问Vector的话,代码要在同步上花费大量的时间.所以在不需要同步的时候使用ArrayList,而同步的时候使用Vector.

Java集合类详解

集合类说明及区别Collection├List│├LinkedList│├ArrayList│└Vector│ └Stack└SetMap├Hashtable├HashMap└WeakHashMap Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些 Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,J

java集合类说明及区别

Collection├List│├LinkedList│├ArrayList│└Vector│ └Stack└SetMap├Hashtable├HashMap└WeakHashMap Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些 Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提

FindBugs规则整理

FindBugs规则整理 FindBugs是基于Bug Patterns概念,查找javabytecode(.class文件)中的潜在bug,主要检查bytecode中的bug patterns,如NullPoint空指针检查.没有合理关闭资源.字符串相同判断错(==,而不是equals)等 一.Security 关于代码安全性防护 1.Dm: Hardcoded constant database password (DMI_CONSTANT_DB_PASSWORD) 代码中创建DB的密码时采

原 IOS之NSValue整理

原 IOS之NSValue整理 发表于2年前(2013-02-28 23:02)   阅读(1974) | 评论(0) 5人收藏此文章, 我要收藏 赞3 IOS NSValue 值对象(value object)概念 在面向对象的编程语言中,值对象本质上是数据元素的的对象包装器,所谓数据元素,常见的包含string,number,date类型以及其它自定义的结构体类型.Objective-C语言本身提供了string,number,date相对应的包装类,分别是NSString,NSNumber

常见数据结构与算法整理总结（上）

数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作.算法是为求解一个问题需要遵循的.被清楚指定的简单指令的集合.下面是自己整理的常用数据结构与算法相关内容,如有错误,欢迎指出. 为了便于描述,文中涉及到的代码部分都是用Java语言编写的,其实Java本身对常见的几种数据结构,线性表.栈.队列等都提供了较好的实现,就是我们经常用到的Java集合框架,有需要的可以阅读这篇文章.Java - 集合框架完全解析 一.线性表 1.数组实现 2.链表 二.栈与队列 三.树

【Android进阶】Android面试题目整理与讲解

这一篇文章专门整理一下研究过的Android面试题,内容会随着学习不断的增加,如果答案有错误,希望大家可以指正 1.简述Activity的生命周期 当Activity开始启动的时候,首先调用onCreate(),onStart(),onResume()方法,此时Activity对用户来说,是可见的状态 当Activity从可见状态变为被Dialog遮挡的状态的时候,会调用onPause()方法,此时的Activity对用户可见,但是不能相 应用户的点击事件 当Activity从可见状态变为被其他