精华内容
下载资源
问答
  • Set集合

    千次阅读 2018-08-21 23:07:54
    Set集合: 特点:无序,不重复。 存储时采用了hash算法机制,计算存储位置。 HashCode方法: Object是引用类型的父类,提供了hashCode()方法以及equals()方法,因此我们在定义类型时,一般都重写hashCode和equals...

    第八篇

    Set集合

    特点:无序,不重复。

    存储时采用了hash算法机制,计算存储位置。

    HashCode方法

    Object是引用类型的父类,提供了hashCode()方法以及equals()方法,因此我们在定义类型时,一般都重写hashCode和equals方法。

    重写的重要性:

    equals方法我们用来判断集合中的元素是否重复,hashCode方法我们在使用Set集合时,必须要重写,因为,我们采用的hash算法计算Set集合元素的存储位置。

    int hashCode():

    Object提供的方法是通过地址计算hash值,不可控。

    我们需要在自定义类中重写此方法。

    重写原则:尽可能的让所有成员变量都参与运算尽可能的减少hash值的碰撞。            

    public int hashCode(){
    
    int result = 7;--定义一个局部变量,进行初始化
    
    int prime = 53 --定义一个局部变量,赋值为素数
    
    result = prime*result+field1;
    
    result = prime*result+field2;
    
    return result;
    
    }

    Set集合的遍历

    因为Set集合是无序的,无下标可言,因此不能使用经典for循环。我们可以使用迭代器原理。

     (1) 调用集合的iterator()获取迭代器

     (2) 使用foreach循环

    Set集合的元素

    不能轻易修改参与hash值算法的成员变量,否则容易引起内存溢出。

    原因:成员变量修改后,会出现新的hash值,但是存储位置还在原hash值的位置上。因此操作时,找不到具体的存储位置。                 

    子类:

    HashSet:无序,不重复,底层使用hash算法计算存储位置。增加删除时效率高 。   

    LinkedHashSet:是HashSet的子类,底层使用hash算法计算存储位置,同时使用链表来维护顺序,顺序与添加顺序一致。在查看检索时,效率比较高。  

    TreeSet:是SortedSet子接口的实现类,使用二叉树的数据结构维护元素的顺序。

     

    Map接口:集合框架中的另一个父接口

    Map集合:用于储存一一对应的元素数据,第一个对象可以作为索引,第二个对象作为值,我们称之为key-value,键值对。

    储存数据的特点

     (1)以key-value形式进行存储。

     (2)key与value都必须是引用类型

     (3)key可以为null。

     (4)key与value是单向一对一映射。

     (5)key不能重复

    存储机制

    Map是基于数组和链表的数据结构进行存储数据。

    作为key的对象采用了hash算法计算存储的数组 (散列数组,散列桶)的位置.如果计算出来的位置,数组中此位置没有元素,就可以添加到散列桶内,如果有元素,key的equals方法返回值为false,就会存储在散列桶元素对应的单向链表中。

    如果key的equals方法返回true,就进行替换(覆盖)。

    PS:使用Map集合,做为key的数据类型应该重写equals和HashCode方法  

    常用方法:

    V  put(K k,V v):作用:用于存储一对key-value.  返回被替换的value值,如果不是替换就返回null

    V  get(K k):作用:通过key对象,获取对应的value对象,如果集合中没有此key,返回null

    Map集合的遍历

    Set<K>  keySet();

         用于获取Map中所有的key对象,返回一个Set集合

    Set<Entry<K,V>>  entrySet();

         将key-value封装成内部类对象,返回Entry对象的Set集合                       

    Collection<V> values();

         将map集合中的所有value封装到一个Collection集合中。

    装载因子和HashMap的优化

    装载因子:DEFAULT_LOAD_FACTOR = 0.75f

    默认容量:DEFAULT_INITIAL_CAPACITY 

             16,就是数组的容量

       元素个数: size   

    当我们创建一个HashMap对象时,底层数组的初始容量为16。当存储的数据的个数 size/DEFAULT_INITIAL_CAPACITY等于DEFAULT_LOAD_FACTOR时,数组开始扩容。此时最佳。

    如果小于0.75扩容,比较占内存。

    如果大于0.75扩容,操作的元素比较多。

    public V put(K key, V value) {
    
      return putVal(hash(key), key, value, false, true);
    
    }
    
    --->
    
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    
    /**/         
    
         Node<K,V>[] tab; Node<K,V> p; int n, i;
    
            if ((tab = table) == null || (n = tab.length) == 0)
    
                /* 没有存储元素,*/
    
                n = (tab = resize()).length;
    
            if ((p = tab[i = (n - 1) & hash]) == null)
    
                tab[i] = newNode(hash, key, value, null);
    
            else {
    
                Node<K,V> e; K k;
    
                if (p.hash == hash &&
    
                    ((k = p.key) == key || (key != null && key.equals(k))))
    
                    e = p;
    
                else if (p instanceof TreeNode)
    
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    
                else {
    
                    for (int binCount = 0; ; ++binCount) {
    
                        if ((e = p.next) == null) {
    
                            /* hash碰撞 */
    
                            p.next = newNode(hash, key, value, null);
    
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    
                                treeifyBin(tab, hash);
    
                            break;
    
                        }
    
                        if (e.hash == hash &&
    
                            ((k = e.key) == key || (key != null && key.equals(k))))
    
                            break;
    
                        p = e;
    
                    }
    
                }
    
                if (e != null) { // existing mapping for key
    
                    V oldValue = e.value;
    
                    if (!onlyIfAbsent || oldValue == null)
    
                        e.value = value;
    
                    afterNodeAccess(e);
    
                    return oldValue;
    
                }
    
            }
    
            ++modCount;
    
            if (++size > threshold)
    
                resize();
    
            afterNodeInsertion(evict);
    
            return null;
    
        }

             

          内部类Node,封装了一个key-value数据,同时还存储了下一个节点的引用 。 

      static class Node<K,V> implements Map.Entry<K,V> {
    
            final int hash;
    
            final K key;
    
            V value;
    
            Node<K,V> next;
    
    
    
            Node(int hash, K key, V value, Node<K,V> next) {
    
                this.hash = hash;
    
                this.key = key;
    
                this.value = value;
    
                this.next = next;
    
            }                  

     

    Map接口的子类:

    HashMap与HashTable的区别

       (1)HashTable是一个古老的类。不建议使用

       (2)HashTable是一个线程安全的类,HashMap线程不安全

       (3)HashTable的key不能是null,HashMap可以是null

    LinkedHashMap:是HashMap子类,使用链表来维护key-value的顺序,在迭代时顺序与添加顺序一致。

    TreeMap

    是SortedMap子接口的实现类,使用了二叉树的数据结构维护 填入集合的顺序。

        (1)自然排序:

          往TreeMap里添加的key对象,可以实现Comparable接口。重写 compareTo方法

        (2)定制排序:做为key对象的数据类型,可以不实现Comparabel接口。

    需要创建一个比较器Comparator对象,实现compare方法

    Properties:

    是HashTable的子类型,用于封装属性文件的key-value信息,因为在文件里写的都是字符串,因此Properties的key与value都是字符串类型

     

    File类型

       java.io.File类型,可以对硬盘上的文件以及目录,进行操作。

          如查看文件/目录的属性信息,创建,删除文件/目录。此类型不能查看和修改文件里的内容。

    常用构造器:

       File(String pathname):

                指定一个路径,创建一个File对象

    路径:

                (1)文件的路径,要写到文件的扩展名为止

                (2)目录的路径,要写到当前目录的名称为止         

        

    常用方法:

     boolean exists():判断指定的路径是否存在

      boolean isFile();判断指定路径是不是文件

    boolean isDirectory();判断指定路径是不是目录

    String getName());获取文件/目录名称

    long lastModified();获取文件/目录的最后修改时间

    boolean isAbsolute();判断指定路径是不是绝对路径

    String getAbsolutePath();获取绝对路径

    String getParent();获取父目录的路径

    long length();获取文件大小文件/目录创建方法:

    boolean createNewFile();创建文件

    boolean mkdir();创建目录

    boolean mkdirs();创建多级目录

    文件/目录的删除方法

    boolean delete()

           可以删除文件,删除目录时,需要目录下没有文件或子目录

    File[] listFiles()

        获取目录里的file对象

    javaBean规范:程序开发者默认遵循的一种规范

        (1)提供两个构造器

        (2)给成员变量提供get/set方法

           String name

           getName()

           setName(String name);

           Bean:豆子的意思,get/set方法名上的后续单词称之为bean.

                         在命名方法时,作为bean的单词首字母要大写,成员变量要尽可能的与bean名一致,首字母小写。

        (3)重写hashCode方法和equals方法

        (4)重写toString()       

     

    递归:

    递归思想:分成递与归。一层层递进,最后再一层层归。

    两种递归

          (1) 方法调用自己   

          (2)  方法A调用方法B,方法B调用A

      举例:

         n*(n-1)*......*1                   

     

     z = f(n) 计算n的阶乘

       = n*f(n-1)

       = n*(n-1)*f(n-2)

       = n*(n-1)*......*1

       

       f(n)是一个函数:

               里的逻辑:

                n*f(n-1)

    展开全文
  • 使用Set集合对List集合进行去重

    万次阅读 2018-03-22 23:00:21
    使用Set集合对List集合进行去重前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重...
    使用Set集合对List集合进行去重

    前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重,这里的去重的意思是只要对象对象中的accountNo账号是相同的,就认为明细对象是相同的,去重之后要求是List集合或者Set集合。

    在进行上面的需求对象去重之前,先来看很简单的List集合去重:
    package com.qdfae.jdk.collections;

    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.HashSet;
    import java.util.Set;
    import java.util.TreeSet;

    import org.junit.Test;

    import com.qdfae.jdk.domain.TradeDetail;
    import com.qdfae.jdk.domain.User;

    /**
    * 使用Set集合对List集合进行去重
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:15:52
    */
    public class SetTest {
    /**
    * List集合的泛型为Integer类型
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:32:53
    */
    @Test
    public void testListToSet1() {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(1);
    Set<Integer> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }
    /**
    * List集合的泛型为String类型
    *
    * @author hongwei.lian
    * @date 2018年3月9日 下午11:34:15
    */
    @Test
    public void testListToSet2() {
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("a");
    Set<String> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }

    /**
    * List集合的泛型为自定义类型User
    * 需求是userCode一样的便是同一个对象
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:32:12
    */
    @Test
    public void testListToSet3() {
    List<User> list = new ArrayList<>();
    list.add(new User(1,"用户一","600001"));
    list.add(new User(2,"用户二","600002"));
    list.add(new User(3,"用户一","600001"));
    list.add(new User(4,"用户一","600001"));
    Set<User> set = new HashSet<>(list);
    System.out.println("list的个数为:" + list.size() + "个");
    list.forEach(System.out::println);
    System.out.println("set的个数为:" + set.size() + "个");
    set.forEach(System.out::println);
    }
    }
    上面测试使用到的User类源码:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;

    /**
    * User实体类
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:33:22
    */
    public class User implements Serializable {
    private static final long serialVersionUID = -7629758766870065977L;

    /**
    * 用户ID
    */
    private Integer id;
    /**
    * 用户姓名
    */
    private String userName;
    /**
    * 用户代码
    */
    private String userCode;
    public User() {}
    public User(Integer id, String userName, String userCode) {
    this.id = id;
    this.userName = userName;
    this.userCode = userCode;
    }

    public Integer getId() {
    return id;
    }

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

    public String getUserName() {
    return userName;
    }

    public void setUserName(String userName) {
    this.userName = userName;
    }

    public String getUserCode() {
    return userCode;
    }

    public void setUserCode(String userCode) {
    this.userCode = userCode;
    }

    @Override
    public String toString() {
    return "User [id=" + id + ", userName=" + userName + ", userCode=" + userCode + "]";
    }
    }
    依次运行上面三个方法的结果是:
    testListToSet1()方法结果:

    testListToSet2()方法结果:

    testListToSet3()方法结果:

    上面的testListToSet1()方法和testListToSet2()方法可以去重,那为什么testListToSet3()方法就不能去重呢?仔细想想就会知道,两个对象的地址值不一样,怎么会认为是相同的去重呢,再往深处想,就会想到Object类的hashCode()方法和equals()方法,这两个方法决定了两个对象是否相等。Integer类和String类之所以可以进行去重,是因为这两个类都重写了父类Object类中的hashCode()方法和equals()方法,具体的代码可以去查看JDK源码,这里不再赘述。到这里我们就知道User对象不能去重的原因所在,那么我们根据需求在User类中重写hashCode()方法和equals()方法,重写后的User类源码如下:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;

    /**
    * User实体类
    *
    * @author hongwei.lian
    * @date 2018年3月10日 上午12:33:22
    */
    public class User implements Serializable {
    private static final long serialVersionUID = -7629758766870065977L;

    /**
    * 用户ID
    */
    private Integer id;
    /**
    * 用户姓名
    */
    private String userName;
    /**
    * 用户代码
    */
    private String userCode;
    public User() {}
    public User(Integer id, String userName, String userCode) {
    this.id = id;
    this.userName = userName;
    this.userCode = userCode;
    }

    public Integer getId() {
    return id;
    }

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

    public String getUserName() {
    return userName;
    }

    public void setUserName(String userName) {
    this.userName = userName;
    }

    public String getUserCode() {
    return userCode;
    }

    public void setUserCode(String userCode) {
    this.userCode = userCode;
    }
    /**
    * 针对userCode重写hashCode()方法
    */
    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((userCode == null) ? 0 : userCode.hashCode());
    return result;
    }

    /**
    * 针对userCode重写equals()方法
    */
    @Override
    public boolean equals(Object obj) {
    if (this == obj)
    return true;
    if (obj == null)
    return false;
    if (getClass() != obj.getClass())
    return false;
    User other = (User) obj;
    if (userCode == null) {
    if (other.userCode != null)
    return false;
    } else if (!userCode.equals(other.userCode))
    return false;
    return true;
    }

    @Override
    public String toString() {
    return "User [id=" + id + ", userName=" + userName + ", userCode=" + userCode + "]";
    }
    }
    我们再次运行testListToSet3()方法结果:

    这一次符合我们的需求,接下里再来看开头提出的需求。
    准备:
    TradeDetail类源码:
    package com.qdfae.jdk.domain;

    import java.io.Serializable;
    import java.math.BigDecimal;

    /**
    * 交易明细
    *
    * @author hongwei.lian
    * @date 2018年3月10日 下午2:44:35
    */
    public class TradeDetail implements Serializable {
    private static final long serialVersionUID = 3386554986241170136L;

    /**
    * 交易明细主键
    */
    private Integer id;
    /**
    * 账号
    */
    private String accountNo ;
    /**
    * 账户名称
    */
    private String accountName;
    /**
    * 交易金额(+表示入金,-表示出金)
    */
    private BigDecimal balance;

    public TradeDetail() {}
    public TradeDetail(Integer id, String accountNo, String accountName, BigDecimal balance) {
    this.id = id;
    this.accountNo = accountNo;
    this.accountName = accountName;
    this.balance = balance;
    }

    public Integer getId() {
    return id;
    }

    public void setId(Integer id) {
    this.id = id;
    }
    public String getAccountNo() {
    return accountNo;
    }

    public void setAccountNo(String accountNo) {
    this.accountNo = accountNo;
    }

    public String getAccountName() {
    return accountName;
    }

    public void setAccountName(String accountName) {
    this.accountName = accountName;
    }

    public BigDecimal getBalance() {
    return balance;
    }

    public void setBalance(BigDecimal balance) {
    this.balance = balance;
    }
    /**
    * 针对accountNo重写hashCode()方法
    */
    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((accountNo == null) ? 0 : accountNo.hashCode());
    return result;
    }

    /**
    * 针对accountNo重写equals()方法
    */
    @Override
    public boolean equals(Object obj) {
    if (this == obj)
    return true;
    if (obj == null)
    return false;
    if (getClass() != obj.getClass())
    return false;
    TradeDetail other = (TradeDetail) obj;
    if (accountNo == null) {
    if (other.accountNo != null)
    return false;
    } else if (!accountNo.equals(other.accountNo))
    return false;
    return true;
    }

    @Override
    public String toString() {
    return "TradeDetail [id=" + id + ", accountNo=" + accountNo + ", accountName=" + accountName + ", balance="
    + balance + "]";
    }

    }
    我们首先来按照上面的想法根据需求重写TradeDetail类的hashCode()方法和equals()方法,上面已经给出重写后的TradeDetail类。
    我有三种实现方案如下:
    package com.qdfae.jdk.collections;

    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeSet;
    import java.util.stream.Collectors;

    import org.junit.Before;
    import org.junit.Test;

    import com.qdfae.jdk.domain.TradeDetail;

    /**
    * List集合去重
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午8:54:57
    */
    public class DuplicateListTest {
    /**
    * 存储没有去重的明细对象的List集合
    */
    private List<TradeDetail> tradeDetailList;
    /**
    * 存储去重后的明细对象的List集合
    */
    private List<TradeDetail> duplicateTradeDetailList;
    /**
    * 存储去重后的明细对象的Set集合
    */
    private Set<TradeDetail> tradeDetailSet;
    /**
    * 初始化tradeDetailList
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:04:45
    */
    @Before
    public void InitTradeDetailList() {
    tradeDetailList = new ArrayList<>();
    tradeDetailList.add(new TradeDetail(1, "600010", "账户一", new BigDecimal(100.00)));
    tradeDetailList.add(new TradeDetail(2, "600011", "账户二", new BigDecimal(100.00)));
    tradeDetailList.add(new TradeDetail(3, "600010", "账户一", new BigDecimal(-100.00)));
    tradeDetailList.add(new TradeDetail(4, "600010", "账户一", new BigDecimal(-100.00)));
    }

    /**
    * 使用Set接口的实现类HashSet进行List集合去重
    *
    * HashSet实现类
    * 构造方法:
    * public TreeSet(Comparator<? super E> comparator)
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:37:51
    */
    @Test
    public void testDuplicateListWithHashSet() {
    //-- 前提是TradeDetail根据规则重写hashCode()方法和equals()方法
    tradeDetailSet = new HashSet<>(tradeDetailList);
    tradeDetailSet.forEach(System.out::println);
    }
    /**
    * 使用Map集合进行List集合去重
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:05:49
    */
    @Test
    public void testDuplicateListWithIterator() {
    duplicateTradeDetailList = new ArrayList<>();
    Map<String, TradeDetail> tradeDetailMap = tradeDetailList.stream()
    .collect(Collectors.toMap(
    tradeDetail -> tradeDetail.getAccountNo(),
    tradeDetail -> tradeDetail,
    (oldValue, newValue) -> newValue));
    tradeDetailMap.forEach(
    (accountNo, tradeDetail) -> duplicateTradeDetailList.add(tradeDetail)
    );
    duplicateTradeDetailList.forEach(System.out::println);
    //-- 参考文章
    //http://blog.jobbole.com/104067/
    //https://www.cnblogs.com/java-zhao/p/5492122.html
    }
    /**
    * 使用Set接口的实现类TreeSet进行List集合去重
    *
    * TreeSet实现类
    * 构造方法:
    * public TreeSet(Comparator<? super E> comparator)
    *
    * @author hongwei.lian
    * @date 2018年3月11日 下午9:37:48
    */
    @Test
    public void testDuplicateListWithTreeSet() {
    tradeDetailSet = new TreeSet<>(
    (tradeDetail1, tradeDetail2)
    ->
    tradeDetail1.getAccountNo().compareTo(tradeDetail2.getAccountNo())
    );
    tradeDetailSet.addAll(tradeDetailList);
    tradeDetailSet.forEach(System.out::println);
    }

    }
    运行上面三个方法的结果都是:

    方案一:根据需求重写自定义类的hashCode()方法和equals()方法
    这种方案的不足之处是根据需求重写后的hashCode()方法和equals()方法不一定满足其他需求,这样这个TradeDetail类的复用性就会相当差。
    方案二:遍历List集合,取出每一个明细对象,将明细对象的accountNo属性字段作为Map集合key,明细对象作为Map集合的value,然后再遍历Map集合,得到一个去重后的List集合或者Set集合。
    这种方案的不足之处是消耗性能,首先是List集合去重转换为Map集合,Map集合再次转换为List集合或者Set集合,遍历也会消耗性能。
    方案三:使用TreeSet集合的独有的构造方法进行去重,如下:
    public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
    }
    这种方案目前为止是我使用的比较多的方案,不足之处暂时没有发现,TreeSet集合实际上是利用TreeMap的带有一个比较器参数的构造方法实现,看JDK源码很清晰,最重要的是这个参数Comparator接口,这个接口的源码:
    Comparator接口部分源码:
    @FunctionalInterface
    public interface Comparator<T> {

    int compare(T o1, T o2);

    }
    这个compare()方法需要自己根据需求去实现,仔细看上面去重的原理实际上还是使用String类的compareTo()方法,String类的compareTo()方法源码:
    public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
    char c1 = v1[k];
    char c2 = v2[k];
    if (c1 != c2) {
    return c1 - c2;
    }
    k++;
    }
    return len1 - len2;
    }
    基本就想到了这些,如果有好的实现方法,自己还会补充。
    展开全文
  • set集合的两种重要实现类

    千次阅读 2016-06-03 22:01:46
    set集合的两种重要实现类 set集合通常不能记住元素的添加顺序,不允许包含重复的元素。如果添加相同的元素,会导致添加失败。 import java.util.TreeSet; import java.util.Set; import java.util.HashSet...

    set集合的两种重要实现类


    set集合通常不能记住元素的添加顺序,不允许包含重复的元素。如果添加相同的元素,会导致添加失败。


    import java.util.TreeSet;
    import java.util.Set;
    import java.util.HashSet;
    import java.util.Iterator;
    public class Test2 {
    
    	public static void main(String[] args) {
    		System.out.println("Set集合的第一个重要实现类HashSet");
    		Set<String> set=new HashSet<String>();
    		set.add("hello");
    		set.add("world");
    		set.add("nihao");
    		set.add("dajiahao");
    		set.add("dajiahao");
    		System.out.println(set);
    		
    		System.out.println("遍历set方法一:增强for循环");
    		for(String temp:set){
    			System.out.println(temp);
    		}
    		System.out.println("遍历set方法二:使用iterator迭代器");
    		for(Iterator iter=set.iterator();iter.hasNext();){
    			String temp=(String)iter.next();
    			System.out.println(temp);
    		}
    		System.out.println("Set集合的第二个重要实现类TreeSet");
    		Set<String> set1=new TreeSet<String>();
    		set1.add("abc");
    		set1.add("abd");
    		set1.add("wer");
    		set1.add("yui");
    		set1.add("nji");
    		System.out.println(set1);
    	}
    }
    


    展开全文
  • Java遍历Set集合方法

    千次阅读 2017-02-27 10:33:23
    Java遍历Set集合方法
    1. Java中Set集合是一个不包含重复元素的Collection


    2. 对 set 的遍历  
    3.   
    4. 1.迭代遍历: 
      一般是迭代遍历: 
    5. Set<String> set = new HashSet<String>();  
    6. Iterator<String> it = set.iterator();  
    7. while (it.hasNext()) {  
    8.   String str = it.next();  
    9.   System.out.println(str);  
    10. }  
    11.   
    12. 2.for循环遍历:  
    13. for (String str : set) {  
    14.       System.out.println(str);  
    15. }  
    16.   
    17.   
    18. 优点还体现在泛型 假如 set中存放的是Object  
    19.   
    20. Set<Object> set = new HashSet<Object>();  
    21. for循环遍历:  
    22. for (Object obj: set) {  
    23.       if(obj instanceof Integer){  
    24.                 int aa= (Integer)obj;  
    25.              }else if(obj instanceof String){  
    26.                String aa = (String)obj  
    27.              }  
    28.               ........  
    29. }   
     
     
    唯一的缺点就是 在遍历 集合过程中,不能对集合本身进行操作
    for (String str : set) {
    set.remove(str);//错误!
    }
     
     

    下面分析一下Set集合的另外一个重要实现类TreeSet,

    TreeSet使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。 

    通俗一点讲,就是可以按照排序后的列表显示,也可以按照指定的规则排序

    java]  view plain  copy
    1. Set<String> set = new TreeSet<String>();  
    2.           
    3.         set.add("f");  
    4.         set.add("a");  
    5.         set.add("b");  
    6.         set.add("c");  
    7.         set.add("d");  
    8.         set.add("e");  
    9.           
    10.         System.out.println(set); 

    输出:[a, b, c, d, e, f]

    按照排序后输出



    参考网址:http://blog.csdn.net/shenshen123jun/article/details/9074097
    展开全文
  • Java集合中List,Set以及Map等集合体系详解(史上最全)

    万次阅读 多人点赞 2018-06-12 14:09:24
    List Set Map都是接口,前两个继承至Collection接口,Map为独立接口 Set下有HashSet,LinkedHashSet,TreeSet List下有ArrayList,Vector,LinkedList Map下有Hashtable,LinkedHashMap,HashMap,TreeMap 还有...
  • set集合使用详解

    千次阅读 多人点赞 2020-12-18 19:11:30
    set集合使用详解 “曾经年少爱追梦,一心只想往前飞。”那会高二,刚刚接触c语言,一发不可收拾,还记得当时为了一个想法和朋友一起想到半夜。现在我还是那个少年,那个又菜又爱玩的少年。 咳咳,set集合容器,...
  • java中的Set集合

    千次阅读 2019-08-14 19:24:19
    上两片博客已经基本的介绍了一下java中的集合分类,list集合和泛型等知识,这篇再介绍一下单列集合中的另外一种集合,Set集合。 看到这篇但是没有看过前两篇的小伙伴可以点一下这里,看一下我之前写的博客。 java中...
  • 1、list集合 ①contains(Object o) 如果列表包含指定的元素,则返回 true。 ②remove(Object o) 移除集合中第一次出现的指定元素,移除成功返回true,否则返回false。 分析源代码,可以发现传入的object对象是通过...
  • java中Set集合

    千次阅读 2017-11-21 18:05:56
    java中Set集合 /** * Set:元素不可以重复,是无序的 * Set接口中的方法和Collection一致 * Set有两个最重要的子类HashSet,TreeSet * HashSet:内部数据哈希表,是不同步的,它不保证 set 的迭代顺序;特别是它不...
  • Set集合Map集合以及Map的三种迭代

    千次阅读 2014-12-19 17:15:04
    一:Set集合: (一):Set集合: 1、Set集合用于存储不重复的对象集合,在Set集合中存储的对象中不存在两个对象equals比较为true。 2、HashSet和TreeSet是set集合的两个常见的实现类,分别用hash表和排序二叉数的...
  • Set、Map、List三种集合的差别

    万次阅读 多人点赞 2019-05-30 16:15:27
    1.集合类型主要有3种:set(集)、list(列表)和map(映射)。 2.三者关系 3.Set set接口时Collection接口的一个子接口,是无序的,set中不包含重复的元素,也就是说set中不存在两个这样的元素a1.equals(a2)结果为...
  • set集合的增删改查

    千次阅读 2018-08-04 09:07:14
    set集合操作 set集合是一个把不重复的无序的集合,里面里元素是可哈希的(不可变) 但它本身是可变的数据类型 set增 `使用add方法 set1 = {1, '2', '3', '4', '5', "666"} set1.add(6) #在无序列表里增加...
  • Python中的set集合

    千次阅读 2019-04-16 20:52:44
    集合set)是0个或多个对想引用的无序集合,这些对象所引用都是哈希运算的 集合是可变的。其中的项是无序的,因此,没有索引位置概念 集合中,任何元素都没有重复 set和dict类似,是一组key的集合,但不存储value,...
  • Set集合重复元素的判断

    千次阅读 2015-04-03 19:08:38
    重要的是Set集合不能放置重复的元素.她是怎么判断的呢?那么,我们首先要让对象具有比较性 一,存储的自定义对象实现接口 Comparable 复写public int compareTo()方法. 返回0表示二者相等. 如果返回大于0的整数...
  • ES6之Set集合的使用

    2018-11-18 10:42:32
    在许多实际问题中,我们必须处理一种集合集合中的每个元素都是唯一的(每个元素只能出现一次),这种集合称之为Set。在ES6之前,这种集合只能通过模拟实现。 console.log("------------------Set----------...
  • java中set集合的重复验证机制

    千次阅读 2018-09-30 14:47:18
    我们知道,set集合重要的一个特性,是不允许存储重复的元素。那么,这究竟是怎么验证的呢。在之前的资料查询中,有这样一个说法,set集合进行插入的时候,会调用对象的equals方法,判断元素是否相同,若equals...
  • 7.Swift 中的Set集合

    2016-01-29 15:11:24
    Swift 中的Set集合
  • 【源码】Set集合源码剖析

    千次阅读 2014-08-23 22:58:53
    注:以下源码基于jdk1.7.0_11 ...对应Map集合的两个很重要的实现HashMap(基于哈希表),TreeMap(基于红黑树),Set集合也对应了两个类HashSet和TreeSet。由于之前花很多篇幅介绍了HashMap和TreeMap,在此将不再介绍其
  • JAVA基础知识之Set集合

    万次阅读 2016-10-28 23:22:11
    Set集合的基本特征是不记录添加顺序,不允许元素重复(想想是为什么)。最常用的实现类是HashSet. 本文将要介绍以下内容 HashSet类 HashSe的特征HashSet的equals和hashCode LinkedHashSet的特征TreeSet的...
  • Set集合一个重要的性质,不含有重复元素,在这里用自己写的二分搜索树实现,这个二分搜索树不存重复元素,符合Set集合的性质 /** * @author BestQiang */ public class BST&lt;E extends Comparable&lt;E&...
  • 对hibernate的set集合进行排序

    千次阅读 2013-05-14 19:46:55
    在如下方法中:方法二已经哥已经证实是对的!可以可以规定排序方式:<set name="four" inverse="true" lazy=...在hibernate中,对于一对多和多对多的关联会使用Set集合来操作,但是有时候在业务中需要对set集合中的对
  • set与list集合

    千次阅读 2019-11-07 10:19:16
    java.util.List接口继承自Collection接口,是单列集合的一个重要分支,习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素,所有的元素是以一种线性方式进行存储的,在程序中可以通过索...
  • 集合框架之Set接口

    千次阅读 2015-01-27 08:35:02
    更确切地讲,set 不包含满足e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素。 在所有构造方法以及 add、equals 和 hashCode 方法的协定上,Set 接口还加入了其他规定,这些规定超出了从 Collection ...
  • java中Set集合的遍历及实现类比较分析

    万次阅读 多人点赞 2013-06-11 10:11:57
    java中Set集合是一个不包含重复元素的Collection,首先我们先看看遍历方法 package com.sort; import java.util.HashSet; import java.util.Iterator; import java.util.Set; /** * 一个不包含重复元素的 ...
  • 6 Python中的集合set

    千次阅读 2017-03-08 22:21:26
    6 Python中的集合set Python中的集合set 6-6 Python中什么是set 6-7 Python之 访问set 6-8 Python之 set的特点 6-9 Python之 遍历set 6-10 Python之 更新set6-6 Python中什么是setPython中什么是setset就是集合dict...
  • Java集合——Set详解

    千次阅读 2019-02-27 10:41:48
    前几天简单介绍了一下单列集合中的List,今天就给大家讲一下它的同胞兄弟Set的简介与使用情况。 Set存取无序,元素唯一 代码演示: public static void demo1() { HashSet&lt;String&gt; hs = new HashSet&...
  • 废话不多说,干货两步走: 第一步:后端 先说后端代码的示例: @ApiOperation(value = "测试", notes = ... @PostMapping(value = "/testSet") public Page delete(@RequestBody Set<String> item...
  • Python中的set(集合)数据类型

    千次阅读 2019-08-22 20:05:12
    Python中的set(集合)数据类型 Python中除了常见的Numbers(数字)、String(字符串)、List(列表)、Tuple(元组)、Dictionary(字典)标准数据类型外,还存在一种set集合)类型,可用于存储值。其有两个重要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 283,872
精华内容 113,548
关键字:

set集合重要吗