Java集合List_Set_Map

List集合接口规范概述

List接口继承自——Collection——Iterable

Iterable接口以循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iterable迭代器。它主要通过foreach方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历。

List接口简洁继承自Iterable接口并在Collection直接父类接口基础上定义更多的可操作方法，最典型就是定义了以索引方式操作集合元素的方法。

List集合接口常用方法

1. boolean add(Object e) //往集合末尾添加一个数，可以是任何类型，添加成功返回true
2. void add(int index,Object element) //在集合的index位置上插入一个Object类，执行效率不高
3. void clear() //把集合里的元素全部删除
4. boolean contains(Object o) //判断集合中是否包含Object类o，包含则返回true
5. Object get(int index) //用来获取集合中index位置的元素，返回值是Object类型
6. boolean isEmpty() //判断集合是否为空

 

List集合接口常用方法2

1. Iterator<E> iterator() //迭代器，用来遍历集合中的元素
2. Object remove(int index) //移除index对象的元素，移除以后返回被移除对象的一个副本，实际上就是一个引用。如果没有，返回空
3. boolean remove(Object o) //移除索引index位置的元素，移除成功返回true，如果没有这个元素，返回false
4. Object set(int index,Object element) //将index位置的元素，替换成element
5. public int indexOf(String target,int fromIndex) //从index位置查找一个目标target，该方法几乎不用
6. int size() //获取集合的大小

 

ArrayList集合实现类

ArrayList集合类是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的）。ArrayList查找访问集合元素速度比较快，删除，插入随机操作比较慢，经常在企业级开发中使用ArrayList处理数据应用。

 

Vector集合实现类

Vector也被称为向量集合，和ArrayList非常类似都是可变的动态数组集合，最大区别是Vector是线程同步的，相对ArrayList数据处理效率要低；在多线程中通常使用Vector处理可能被多个线程并发访问的数据。

Vector集合具有ArrayList的所有方法外，增加了public Enumeration<E> elements()方法，此方法返回Enumeration枚举接口，可使用此接口实现对集合的遍历

 

Set集合接口规范概述

Set接口继承自——Collection——Iterable

Iterable接口循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iterator迭代器。它主要通过foreach方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历。

Set接口只能存储不相等的对象，Set接口是数学Set的抽象描述，与ArrayList不同，它其中的元素不带有任何索引，不能使用索引方式访问集合中元素。

Set接口通常追加，遍历元素比较慢，随机删除修改数据速度稍快。

 

Set集合接口常用方法

1. boolean add(Oject e) //在末尾添加元素
2. void clear() //清空集合
3. boolean contains(Object o) //是否包含对象
4. Iterator<E> iterator() //得到一个指向集合的迭代器

 

Set集合接口常用方法2

1. boolean remove(Object o) //移除给定的元素
2. int size() //返回集合的大小
3. boolean isEmpty() //判断集合是否为空
4. Object[] toArray() //把集合中的所有元素封装成一个Object数组返回

 

HashSet集合实现类

此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用null元素。

HashSet实现不是同步的。如果多个线程同时访问一个哈希set，而其中至少一个线程修改了该set，那么它必须保持外部同步。

 

TreeSet集合实现类

基于TreeMap的NavigableSet继承并实现了SortedSet排序接口。使用元素的自然顺序对元素进行排序，或者根据创建set时提供的Comparator进行排序。

此实现不是同步的。如果多个线程同时访问一个TreeSet，而其中至少一个线程修改了该set，那么它必须外部同步。

由于排序，通常此类比HashSet效率要低。

 

TreeSet集合常用方法

1. public TreeSet(Comparator<E> comparator) //按照comparator里面的排序方式进行排序，这个就是自定义排序方法

(1) 例：

(2) TreeMap depTree = new TreeMap(new Comparator(){

(3) 

(4)             @Override

(5)             public int compare(Object k1, Object k2) {

(6)                 Integer intK1 = (Integer)k1;

(7)                 Integer intK2 = (Integer) k2;

(8)                 if (intK1.intValue()>intK2.intValue())

(9)                     return -1;

(10)                 else if(intK1.intValue()<intK2.intValue())

(11)                     return 1;

(12)                 return 0;

(13)             }

(14)         });//自定义的倒序排序方法

1. public Iterator<E> descendinglterator() //降序排序迭代器
2. public E last()
3. public E first()

 

LinkedHashSet集合实现类

基于哈希表和链接列表的Set接口的实现类，与HashSet无序集合相比，LinkedHashSet的迭代是一个可以被预知的访问操作，它以添加到集合中的顺序为迭代最终顺序。

由于LinkedHashSet需要维护元素顺序，因此其效率比HashSet要稍低些。

通常在需要保证使用Set接口并安装存储顺序迭代时使用此类。

 

Map集合接口规范概述

Map接口是存储键值对象的顶级集合接口。存储在Map集合中的键值对象必须确保每个键是不重复的;对于相同的键对象在添加到Map中时会产生覆盖源键值对象操作。

在通常情况下Map通过一个唯一的键查找其对应的值对象，键和值必需同时成对出现，一个键对应一个值对象。

在很多情况下可以使用Map对象替代实体对象，这样可以在应用程序实体类比较多的情况下减少类的定义。

键是存储的数据名称，值是存储的数据本身。

Map集合接口常用方法

1. Object put(Object key,Object value) //往集合中放值，第一个参数是键，第二个参数是值。可以使用任何类型的对象作为键和值，多数情况下键是字符串
2. Object get(Object key) //通过键查找值，并返回这个键对应的值
3. boolean containsKey(Object key) //对于某一个键，查找他是否包含这个键
4. boolean containsValue(Object value) //判断是否包含value这个对象
5. int size() //获取当前键值对的大小

 

Map集合接口常用方法2

1. Set<K> keySet() //返回当前Map中所有键的集合，封装在一个Set中
2. Collection<V> values() //返回一个Map所有值的集合，封装成一个Collection
3. boolean isEmpty() //Map是否为空
4. V remove(Object key) //移除key这个键值对象，键和值都移除，返回一个值对象的引用，也就是值对象的指针或句柄
5. void clear() //清空Map集合中的键值

 

HashMap集合实现类

HashMap是基于哈希表算法的Map接口的实现类。此实现类提供所有可选的映射操作，允许使用null值和null键。HashMap不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap不是线程安全的，如果在多线程中使用必需在程序中处理同步问题。

 

TreeMap集合实现类

基于红黑树（Red-Black tree）的NavigableMap实现。NavigableMap接口是SortedMap排序Map的子接口。

TreeMap基于树形结构的排序方式实现排序，TreeMap默认以键为依据采用自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法由于排序，通常此类比HashMap效率要低。

TreeMap不是线程安全的，在多线程中必需手动处理同步问题。

 

 

Hashtable集合实现类

Hashtable类实现一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以用作键和值。和HashMap不一样，Hashtable不予许存储空键和空值。

Hashtable与HashMap功能几乎相同的，最大区别在于HashMap是非线程同步的，而Hashtable是线程同步的，在多线程中通常使用同步的Hashtable。

由于Hashtable要考虑线程同步问题，因此Hashtable执行效率要比HashMap低。在非多线程中提倡使用HashMap存储键值对象，从而提高性能。

 

总结：

Java中常用的3种集合接口

List是有序，Set是无序，Map是键值。使用哪个根据企业实际情况来定。

package com.xzit.test;

import com.xzit.domain.Users;
import com.xzit.imp.UserManager;
import java.util.Scanner;

/**
 * 用户注册功能的测试类
 * @author Administrator
 *
 */
public class TestUserRegister {
    public static void main(String[] args) {
        UserManager use = new UserManager();

        /* 在此下面编写代码实现模拟用户注册
         * 用户注册必需满足用户端的注册名称在已注册的用户名称中是不存储在的,否则用户名不可用,
         * 注册失败,如果满足条件则用户信息添加到表中(DataBase 类的静态属性usersTable集合中)
         * */
        Scanner in = new Scanner(System.in);
        Users users2 = new Users();
        System.out.println("请输入您要注册的用户名称，回车键结束");
        users2.setName(in.next());

        System.out.println("请输入您的登录密码，回车键结束");
        users2.setPassword(in.next());

        //定义一个int值接收方法执行的返回结果
        int tag = use.userRegister(users2);
        if (tag==0)
            System.out.println("注册失败，系统中已有同名用户！");
        else if(tag==1)
            System.out.println("注册成功！");

        /* 在此下面获取所有已注册用户信息输出观察注册结果*/
        System.out.println("所有注册用户信息如下：");
        use.queryUserList();
    }
}

package com.xzit.test;

import com.xzit.domain.Users;
import com.xzit.imp.UserManager;

import java.util.Scanner;

/**
 * 用户登录功能的测试类
 * @author Administrator
 *
 */
public class TestUserLogin {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        /*
         *在此下面完成从控制台输入用户的登录名称和登录密码完成用户登录验证代码
         * */
        UserManager use = new UserManager();
        System.out.println("请输入您的用户名：");
        String name = in.next();

        System.out.println("请输入您的密码：");
        String password = in.next();

        //调用登录方法，并new一个user2接收返回值
        Users user2 = use.userLogin(name,password);

        /* 如果用户登录成功则显示用户的信息*/
        if (user2.getGranted()==1){
            System.out.println("登陆成功，您的用户信息如下：");
            System.out.println("用户Id："+user2.getId());
            System.out.println("用户名："+user2.getName());
            System.out.println("密码："+user2.getPassword());
            System.out.println("注册时间："+user2.getRegisterDateTime());
            System.out.println("是否允许登录："+user2.getGranted());
        }
        /* 如果用户登录失败则显示登录失败的提示信息*/
        else if (user2.getGranted()==0){
            System.out.println("用户名密码不存在！");
        }
    }
}

package com.xzit.dao;

import com.xzit.domain.Users;

import java.util.List;

/**
 * 此类是访问数据库的操作组件接口,主要实现对用户进行管理定义抽象方法
 * @author Administrator
 *
 */

public interface UserDao {
    /* 获取所有已注册的用户列表*/
    public List<Users> queryUserList();

    /* 用户登录的抽象方法*/
    public Users userLogin(String name,String password);

    /* 用户注册的抽象方法*/
    public int userRegister(Users user);
}

package com.xzit.imp;

import com.xzit.dao.UserDao;
import com.xzit.db.Database;
import com.xzit.domain.Users;

import java.sql.Timestamp;
import java.util.*;

/**
 * 定义一个子类继承并实现UserDao的抽象方法
 */

public class UserManager implements UserDao {
    /* 获取所有已注册的用户列表*/
    @Override
    public List<Users> queryUserList() {
        Database dat = new Database();
        //创建一个泛型是User类的集合userTable2，用来接收getUsersTable()方法返回的集合
        List<Users> usersTable2 = dat.getUsersTable();

        //遍历输出集合里的内容，打印出所有已注册的用户
        for (Users use:usersTable2){
            System.out.println("用户id："+use.getId());
            System.out.println("用户名称："+use.getName());
            System.out.println("用户密码："+use.getPassword());
            System.out.println("用户注册时间"+use.getRegisterDateTime());
            if (use.getGranted()==0)
                System.out.println("用户是否被授予登录权限：否
");
            else if (use.getGranted()==1)
                System.out.println("用户是否被授予登录权限：是
");

        }
        return null;
    }

    /* 用户登录的方法*/
    @Override
    public Users userLogin(String name, String password) {
        Database dat = new Database();
        //创建一个泛型是User类的集合userTable2，用来接收getUsersTable()方法返回的集合
        List<Users> usersTable2 = dat.getUsersTable();

        /**
         * 使用当前集合获取指向集合的迭代器，使用迭代器遍历集合中元素
         */
        Iterator<Users> iterator = usersTable2.iterator();//获取迭代器
        Users use = new Users();    //new一个User对象
        while (iterator.hasNext()){ //如果集合中有下一个元素
            use = iterator.next();  //把集合中元素赋给对象emp
            if (name.equals(use.getName())&&password.equals(use.getPassword())) {   //如果用户名密码相等
                use.setGranted(1);  //设置允许登录并返回
                return use;
            }
            else
                use.setGranted(0);  //否则设置不允许登录
        }
        return use; //返回use
    }

    /* 用户注册的方法*/
    @Override
    public int userRegister(Users user) {
        Database dat = new Database();
        //创建一个泛型是User类的集合userTable2，用来接收getUsersTable()方法返回的集合
        List<Users> usersTable2 = dat.getUsersTable();

        //遍历输出集合里的内容，检查有没有同名用户，有则注册失败
        for (Users use:usersTable2){
            if (use.getName().equals(user.getName()))
                return 0;
        }

        //如果没有同名用户，则执行以下语句赋予用户ID、注册时间、登录权限
        user.setId(UUID.randomUUID().toString());// 系统生成id
        user.setRegisterDateTime(new Timestamp(new Date().getTime()));
        user.setGranted(1);

        //将用户加入到集合当中
        usersTable2.add(user);

        return 1;
    }
}

package com.xzit.db;

import com.xzit.domain.Users;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;

/**
 * 此类模仿数据库
 * @author Administrator
 *
 */
public class Database {

    /* 此List 集合模仿存储已经注册的用户信息表*/
    private static List<Users> usersTable = new ArrayList<Users>(0);

    /* 预存已经注册的用户信息*/
    static{
        Users user0 = new Users();
        user0.setId(UUID.randomUUID().toString());// 系统生成id
        user0.setName("lixiaolong");
        user0.setPassword("123456");
        user0.setRegisterDateTime(new Timestamp(new Date().getTime()));// 系统时间
        user0.setGranted(1);

        Users user2 = new Users();
        user2.setId(UUID.randomUUID().toString());// 系统生成id
        user2.setName("liangxiaolong");
        user2.setPassword("111111");
        user2.setRegisterDateTime(new Timestamp(new Date().getTime()));// 系统时间
        user2.setGranted(1);

        Users user3 = new Users();
        user3.setId(UUID.randomUUID().toString());// 系统生成id
        user3.setName("chenglong");
        user3.setPassword("888888");
        user3.setRegisterDateTime(new Timestamp(new Date().getTime()));// 系统时间
        user3.setGranted(1);

        //把预注册的用户信息存进集合里
        usersTable.add(user0);
        usersTable.add(user2);
        usersTable.add(user3);
    }


    /* 获取所有用户的getUsersTable静态方法*/
    public static List<Users> getUsersTable() { return usersTable;
    }


}

package com.xzit.domain;

import java.sql.Timestamp;

/**
 * 用户实体类
 * @author Administrator
 *
 */

public class Users {

    private String id; // 用户id,实际数据库表中用户记录主键

    private String name; // 用户登录系统名称

    private String password; // 登录密码

    private Timestamp registerDateTime; // 用户注册时间,取系统日期时间

    private int granted; // 是否被授予登录权限(此属性值如果为0 则被禁止登录,如果为1则允许登录)

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Timestamp getRegisterDateTime() {
        return registerDateTime;
    }

    public void setRegisterDateTime(Timestamp registerDateTime) {
        this.registerDateTime = registerDateTime;
    }

    public int getGranted() {
        return granted;
    }

    public void setGranted(int granted) {
        this.granted = granted;
    }
}