精华内容
下载资源
问答
  • 主要介绍了Java中对List去重, Stream去重的问题解答,文中给大家介绍了Java中List集合去除重复数据的方法,需要的朋友可以参考下
  • 本文主要介绍了java list 去重的方法,其中有带类型写法和不带类型写法,并举例测试,具有一定参考借鉴价值,希望能对有需要的小伙伴有所帮助
  • list去重.txt

    2020-05-26 16:08:00
    在java的list中由于经常存在重复的元素,需要去重,这个时候要用到list去重,将一些不必要展现出来的元素展现出来
  • 问题就是对一个list中的新闻id进行去重去重之后要保证顺序不变。 直观方法 最简单的思路就是: 复制代码 代码如下: ids = [1,2,3,3,4,2,3,4,5,6,1] news_ids = [] for id in ids:  if id not in news_ids:  news...
  • List去重

    2018-10-31 21:22:05
    我们知道List允许有相同的元素,那么我们怎么通过方法来让它去重呐, 我们都会想到Set集合,Set集合是不允许有相同的元素的,所以我们可以借助Set集合,把重复的元素去掉。如果不是对象类型的去重。直接用Set集合...

    我们知道List允许有相同的元素,那么我们怎么通过方法来让它去重呐,
    我们都会想到Set集合,Set集合是不允许有相同的元素的,所以我们可以借助Set集合,把重复的元素去掉。如果不是对象类型的去重。直接用Set集合转化就行。就像下面的

     List list = new ArrayList();
            list.add("aa");
            list.add("dd");
            list.add("cc");
            list.add("aa");
            Set set = new HashSet();
            set.addAll(list);
            List n = new ArrayList<>();
            n.addAll(set);
            System.out.println(n);
    
        结果:
        [aa, dd, cc]
        通过这,你会发现可以啊
        但是对象呐,
    
     public class People {
    
        private String name;
        private String phoneNumber;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPhoneNumber() {
            return phoneNumber;
        }
    
        public void setPhoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }
    
        public People(String name, String phoneNumber) {
            super();
            this.name = name;
            this.phoneNumber = phoneNumber;
    }
    
        @Override
        public String toString() {
            return "People{" +
                    "name='" + name + ''' +
                    ", phoneNumber='" + phoneNumber + ''' +
                    '}';
        }
    
    }
    

    这种需要重写equals和hashcode,再用Set去重。

    public class People {
    
        private String name;
        private String phoneNumber;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPhoneNumber() {
            return phoneNumber;
        }
    
        public void setPhoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }
    
        public People(String name, String phoneNumber) {
            super();
            this.name = name;
            this.phoneNumber = phoneNumber;
    }
    
        @Override
        public String toString() {
            return "People{" +
                    "name='" + name + ''' +
                    ", phoneNumber='" + phoneNumber + ''' +
                    '}';
        }
    
        @Override
        public boolean equals(Object arg0) {
            // TODO Auto-generated method stub
            People p = (People) arg0;
            return name.equals(p.name) && phoneNumber.equals(p.phoneNumber);
        }
    
        @Override
        public int hashCode() {
            // TODO Auto-generated method stub
            String str = name + phoneNumber;
            return str.hashCode();
        }
    
    }
    

    这里注意一下重写equals方法和hashcode方法

    	public boolean equals(Object orgs){
    		// 强制类型转换
    		People p = (People)orgs;
    		return p.name.equals( name )&& p.phoneNumber.equals(phoneNumber);
    	}
    	public int hashcode(){
    		String str = name + phoneNumber;
    		return str.hashCode();
    	}
    
    展开全文
  • List去重及使用jdk8语法操作list去重

    千次阅读 2020-05-06 18:43:47
    1. 集合List去重 List是有序的,可以重复的。Set是无序的,不可以重复的。List去重,如果T是基本类型的,只需要将List转成Set就可以去重;如果T是对象类型,那么需要重新equals()和hashCode()方法。 1.1 基本类型 ...

    1. 集合List去重

    List是有序的,可以重复的。Set是无序的,不可以重复的。List去重,如果T是基本类型的,只需要将List转成Set就可以去重;如果T是对象类型,那么需要重新equals()和hashCode()方法。

    1.1 基本类型

    假如有一个List集合[Simon, kevin, lucy, kevin, lily],去掉其中重复的元素kevin

    List<String> list = new ArrayList<>();
    list.add("Simon");
    list.add("kevin");
    list.add("lucy");
    list.add("kevin");
    list.add("lily");
    

    1.1.1 List< String>转Set< String>去重

    通过List转Set去重,然后存到一个新的List集合list3里面

    Set<String> set = new HashSet<>(list);
    List<String> list3 = new ArrayList<>(set);
    System.out.println("list3="+list3);
    

    这样去重后的问题:新的集合lis3t和原来的list集合里面元素的顺序不一致

    要让去重后的List集合和原来的List集合一致,可以如下操作:
    先foreache list集合,然后去set.add()判断,如果add()方法返回为true便给新的list集合去添加这个元素。
    具体的实现代码如下:

    Set<String> set2 = new HashSet<>();
    List<String> list4 = new ArrayList<>();
    for(String str : list) {
    	if(set2.add(str)) {
    		list4.add(str);
    	}
    }
    System.out.println("list4="+list4);
    

    1.1.2 jdk8的新语法操作List< String>去重

    List<String> list2 = list.stream().distinct().collect(Collectors.toList());
    System.out.println("list2="+list2);
    

    这样操作后新的list集合list2的顺序和list里面的顺序一致

    1.2 对象类型

    对象类型,需要重新equals()和hashCode()方法,才能够判断出来两个对象是同一个对象,然后给去重。

    public class User {
    	
    	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 String toString() {
    		return "User [name=" + name + ", age=" + age + "]";
    	}
    
    	public User(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	@Override
    	public int hashCode() {
    		String str = name + age;
    		return str.hashCode();
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		User user = (User)obj;
    		return name.equals(user.name) && age==user.age;
    	}
    
    }
    

    需要去重的List集合List< User >:

    List<User> list = new ArrayList<User>() {{
    	add(new User("Simon", 24));
    	add(new User("kevin", 28));
    	add(new User("lucy", 23));
    	add(new User("kevin", 28));
    	add(new User("lily", 27));
    }};
    System.out.println("list="+list);
    

    1.2.1 List< User>转Set< User>去重

    Set<User> set = new HashSet<>(list);
    System.out.println(set);
    List<User> list3 = new ArrayList<>();
    list3.addAll(set);
    System.out.println("list3="+list3);
    

    这样操作是去重了,但是集合list3的顺序和集合list的不一致

    要让去重后的集合和list集合顺序一致,可以如下操作:

    Set<User> set2 = new HashSet<>();
    List<User> list4 = new ArrayList<>();
    for (User user : list) {
    	if(set2.add(user)) {
    		list4.add(user);
    	}
    }
    System.out.println("list4="+list4);
    

    1.2.2 使用jdk8新语法List< User>去重

    重写equals()和hashCode()方法

    List<User> list2 = list.stream().distinct().collect(Collectors.toList());
    System.out.println("list2="+list2);
    
    展开全文
  • c# List去重

    2021-01-26 10:48:16
    需求 : 对List集合中的元素去重。 实现: 有三种方式可以使用 - 使用Linq中distinct()方法 - 借助hashset - 使用for循环遍历,这种方法在数据量大时,运行速度比较慢 代码示例 使用distinct() //使用...
    1. 需求 : 对List集合中的元素去重。
    2. 实现: 有三种方式可以使用
      - 使用Linq中distinct()方法
      - 借助hashset
      - 使用for循环遍历,这种方法在数据量大时,运行速度比较慢

    代码示例

    • 使用distinct()

      //使用distinct()
      List<string> lst1 = new List<string>() 
      { "as", "lio", "sdrf", "asd", "lio" };
                var  reslst =lst1.Distinct().ToList();
    
    • 使用hashset

     public static List<T> RemoveT<T>(List<T> items)
            {
                HashSet<T> set = new HashSet<T>();
    
                var res = new List<T>();//返回
    
                for (int i = 0; i < items.Count; i++)
                {
                    if (!set.Contains(items[i]))
                    {
                        set.Add(items[i]);
                        res.Add(items[i]);
                    }
                }
                return res;
            }
    
    • 使用for-loop

     public  static List<string> ForLoopRemove(List<string> items)
            {
                List<string> output = new List<string>();
                for (int i = 0; i < items.Count; i++)
                {
                    bool flag = false;
                    //每个元素都与其他这个元素前面的比较,如果前面没有,则添加,否则不添加
                    for (int z = 0; z < i; z++)
                    {
                        if (items[z] == items[i])
                        {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        output.Add(items[i]);
                    }
                }
                return output;
            }
    

    测试三种方式的运行速度
    代码示例

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    
    namespace ConsoleApp2
    {
        class Program
        {
            static void Main(string[] args)
            {
                //list 去重,三种方法
                for (int test = 0; test < 3; test++)
                {
                    // 获取测试数据
                    var testData = GetTestData(test);
                    var max = testData.Item3;///执行次数
    
                    var s1 = Stopwatch.StartNew();
                    for (int i = 0; i < max; i++)
                    {
                        // 方法 1: use Distinct.
                        var unique = testData.Item2.Distinct().ToList();
                    }
                    s1.Stop();
                    var s2 = Stopwatch.StartNew();
                    for (int i = 0; i < max; i++)
                    {
                        // 方法 2: use HashSet.
                        var unique = Method.RemoveT(testData.Item2);
                    }
                    s2.Stop();
                    var s3 = Stopwatch.StartNew();
                    for (int i = 0; i < max; i++)
                    {
                        // 方法 3: use nested for-loop.
                        var unique = Method.ForLoopRemove(testData.Item2);
                    }
                    s3.Stop();
                    // 打印信息.
                    Console.WriteLine(testData.Item1);
                    //调用时间.
                    Console.WriteLine(s1.Elapsed.TotalMilliseconds + " ms");
                    Console.WriteLine(s2.Elapsed.TotalMilliseconds + " ms");
                    Console.WriteLine(s3.Elapsed.TotalMilliseconds + " ms");
                }
    
                //结论: 当数据量少时,直接使用for-loop 遍历数据即可;
                //当数据量大时,使用hashSet 或者时linq的distinct()方法
                List<string> testLst=  GetListWithDuplicates(100, 20);
                Method.RemoveRepeat(testLst);
    
                //实现按照对象的某个字段去重。
    
                List<Student> lst = new List<Student>();
                lst.Add(new Student { No = 23, name = "李磊" });
                lst.Add(new Student { No = 45, name = "david" });
                lst.Add(new Student { No = 12, name = "lily" });
    
                lst.Add(new Student { No = 23, name = "李磊" });
                lst.Add(new Student { No = 45, name = "david" });
                lst.Add(new Student { No = 72, name = "lily" });
    
                var res=  lst.Distinct(new ItemEqualityComparer());
                foreach (var item in res)
                {
                    Console.WriteLine($"distinct: {item.No}---{item.name}");
                }
    
    
                Console.ReadKey();
            }
    
          
    
            /// <summary>
            /// 生成测试数据,最后的一个参数,表示方法被调用的次数
            /// </summary>
            /// <param name="test"></param>
            /// <returns></returns>
            static Tuple<string, List<string>, int> GetTestData(int test)
            {
                // Tuple contains description string, list, the unique element count, and iterations for test.
                switch (test)
                {
                    default:
                    case 0:
                        return new Tuple<string, List<string>, int>("10 ELEMENT LIST, 0 DUPLICATES",
                            GetListWithDuplicates(10, 0),
                            100000);
                    case 1:
                        return new Tuple<string, List<string>, int>("300 ELEMENT LIST, 100 DUPLICATES",
                            GetListWithDuplicates(200, 100),
                            1000);
                    case 2:
                        return new Tuple<string, List<string>, int>("3000 ELEMENT LIST, 1000 DUPLICATES",
                            GetListWithDuplicates(2000, 1000),
                            100);
                }
            }
    
            public static List<string> GetListWithDuplicates(int len, int repeatNum)
            {
                const string duplicateString = "bird";
                List<string> result = new List<string>();
                for (int i = 0; i < len; i++)
                {
                    result.Add("cat" + i);
    
                    if (repeatNum > 0)
                    {
                        result.Add(duplicateString);
                        repeatNum--;
                    }
                }
    
                for (int i = 0; i < repeatNum; i++)
                {
                    result.Add(duplicateString);
                }
                return result;
            }
        }
    
    
        /// //
      #region  按照对象的某个字段去重
        public class Student
        {
            public string name;
            public int No;
            
        }
        /// <summary>
        /// 按照学号判断
        /// </summary>
        public class ItemEqualityComparer : IEqualityComparer<Student>
        {
            public bool Equals(Student x, Student y)
            {
                return x.No == y.No;
            }
    
            public int GetHashCode(Student obj)
            {
                return obj.No.GetHashCode();
            }
        }
        #endregion
    
    }
    
    

    调用方法的封装

    using System;
    using System.Collections.Generic;
    
    
    namespace ConsoleApp2
    {
        public static class Method
        {
    
            /// <summary>
            /// 使用两个循环,但是在数据量大时,这种方法比较慢
            /// </summary>
            /// <param name="items"></param>
            /// <returns></returns>
            public  static List<string> ForLoopRemove(List<string> items)
            {
                List<string> output = new List<string>();
                for (int i = 0; i < items.Count; i++)
                {
                    bool flag = false;
                    //每个元素都与其他这个元素前面的比较,如果前面没有,则添加,否则不添加
                    for (int z = 0; z < i; z++)
                    {
                        if (items[z] == items[i])
                        {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        output.Add(items[i]);
                    }
                }
                return output;
            }
    
            /// <summary>
            /// 使用hashset去重
            /// </summary>
            /// <param name="lst"></param>
           public  static void RemoveRepeat(List<string> lst)
            {
                Console.WriteLine("intput :" + lst.Count);
    
                HashSet<string> set = new HashSet<string>();
                foreach (string item in lst)
                {
                    set.Add(item);
                }
                Console.WriteLine(set.Count);
    
                lst.Clear();
                lst.AddRange(set);
                Console.WriteLine("outPut: "+lst.Count);
            }
    
            /// <summary>
            /// 使用hashset去重的泛型方法
            /// </summary>
            /// <param name="items"></param>
           public static List<T> RemoveT<T>(List<T> items)
            {
                HashSet<T> set = new HashSet<T>();
    
                var res = new List<T>();//返回
    
                for (int i = 0; i < items.Count; i++)
                {
                    if (!set.Contains(items[i]))
                    {
                        set.Add(items[i]);
                        res.Add(items[i]);
                    }
                }
                return res;
            }
    
        }
    }
    
    
    • 代码中,也提供了对象集合按照对象的某个字段进行去重的方法。
    展开全文
  • list本身是可以元素重复的,一般面试或者实际开发中需要给list去重,以下推荐几个方法 首先创建一个list进行复制 List list = new ArrayList(); list.add("1"); list.add("1"); list.add("2"); list.add("2"); ...

    list本身是可以元素重复的,一般面试或者实际开发中需要给list去重,以下推荐几个方法

    首先创建一个list进行复制

    List list = new ArrayList();
            list.add("1");
            list.add("1");
            list.add("2");
            list.add("2");
            list.add("3");
            list.add("3");
    

    打印结果:[1, 1, 2, 2, 3, 3]

    开始去重

    1 把list putlistlld到set中,借助Set的特性进行去重,因为set是没有重复元素的

     Set s = new HashSet();
     s.addAll(list);
    

    打印结果 [1, 2, 3]

    2 利用set集合特性保持顺序一致去重

     List list2 = new ArrayList(new LinkedHashSet(list));
    

    打印结果 [1, 2, 3]

    3 把list里的对象遍历一遍,用list.contains(),如果不存在就放入到另外一个list集合中

     List listNew = new ArrayList();
            for (Object str : list) {
                if (!listNew.contains(str)) {
                    listNew.add(str);
                }
            }
    

    打印结果 [1, 2, 3]

    3 第三种方式 使用Java8特性去重

    Object collect = list.stream().distinct().collect(Collectors.toList());
    
    

    打印结果 [1, 2, 3]

    5 使用list自身方法remove()–>不推荐,类似于冒泡排序思想,效率较低

           for (int i = 0; i < list.size(); i++) {
                for (int j = 0; j < list.size(); j++) {
                    if(list.get(i)==list.get(j)){
                         list.remove(j);
                    }
                }
            }
    

    打印结果 [1, 2, 3]

    展开全文
  • 记录一下使用stream流对List的常用操作以便以后忘了的时候查看,先准备下测试数据 public static List<Goods> getList(){ Goods goods = Goods.builder().id(1L).goodsName("测试").goodsAddress("济南")....
  • 主要介绍了Java实现对两个List快速去重并排序操作,结合实例形式较为详细的分析了Java针对list的遍历、去重、排序相关操作技巧与注意事项,需要的朋友可以参考下
  • list去重和统计技巧

    2020-08-20 10:42:18
    list去重和统计技巧 import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class Test03 { public static void main(String[] args) { // 新建List List&...
  • Java8 List去重

    2019-12-31 18:37:28
    1.distinct去重 List<String> newList = list.stream().distinct().collect(Collectors.toList()); 注意:distinct方法在List元素为基本数据类型及String类型时没问题,但是如果是对象的话不不好使的。 2....
  • 大数据List去重

    千次阅读 2018-03-09 17:16:42
    MaxList模块主要是对Java集合大数据去重的相关...直接两个List去重说到去重,稍微多讲一点啊,去重的时候有的小伙伴可能直接对2500万List foreach循环后直接删除, 其实这种是错误的(java.util.ConcurrentModificati...
  • Java集合List去重的几种方式

    万次阅读 多人点赞 2020-12-15 19:13:08
    } } 输出: [1, 1, 2, 3, 3, 3, 4, 5, 6, 6, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] 2、使用java8新特性stream进行List去重 要从arraylist中删除重复项,我们也可以使用java 8 stream api。使用steam的distinct()方法...
  • C# list去重方法

    千次阅读 2019-02-19 13:51:34
    循环去重 方法一:循环元素删除 // 删除ArrayList中重复元素 public static void removeDuplicate(List list) { for ( int i = 0 ; i &amp;lt; list.size() - 1 ; i ++ ) { for ( int j = list.size...
  • Java List 去重的方法

    千次阅读 2019-11-12 15:56:49
    最近项目中需要对list集合中的重复值进行处理,大部分是采用两种方法,一种是用遍历list集合判断后赋给另一个list集合,一种是用赋给set集合再返回给list集合。 但是赋给set集合后,由于set集合是无序的,原先的...
  • List 去重操作

    2021-08-18 16:21:20
    List中保存数据是有序不唯一的,所以经常会出现重复的数据,在我们通过List中的数据对其他数据进行操作时就会出现重复操作,我在进行财务金额计算的时候出现的重复的数据,导致金额数目不对,因此发现去重操作的重要...
  • QStringList去重

    2020-09-29 14:10:08
    friendGroupName_List=friendGroupName_List.toSet().toList();//去掉重复
  • 一、逻辑比较简单,直接用for遍历 old_list = [2, 3, 4, 5, 1, 2, 3] new_list = [] ...因为dict不能有重复的key,所以可以将list转换成dict的key,去重之后,也会保留原顺序。 old_list = [2, 3, 4,
  • List去重3种方式

    千次阅读 2019-05-03 22:45:44
    1.在实战中list去重是非常频繁的,下面就讲讲它的三种用法。 二、第一种(原始代码去重) 1.测试类 public class DemoTest { public static void main(String[] args) { ArrayList<String> list = Lists...
  • Flutter: List去重

    2020-12-09 14:09:40
    利用List提供的toSet()去重,再转回List: calculatedRectList = calculatedRectList.toSet().toList();
  • JDK1.8List去重

    千次阅读 2020-01-07 12:08:43
    其中 b.getUserId是list中的一个属性 List<?> list = (具体实体)list.stream().filter(MapUtil.distinctByKey(b -> b.getUserId())).collect(Collectors.toList());... * list去重 * @param keyExtr...
  • 主要介绍了简述Java List去重五种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • List<T> list = new ArrayList<>(); Set set = new HashSet(); List<T> newList = new ArrayList<>(); for (T element : list) { //set能添加进去就代表不是重复的元素 if (set.add...
  • python多维list去重

    千次阅读 2018-12-09 18:00:55
    一维的list去重可以用set(list),但是二维的list转set就会报错 unhashable type: ‘list’ 原因是set传进来的是不可哈希的变量 Python中那么哪些是可哈希元素?哪些是不可哈希元素? 可哈希的元素有:int、float、...
  • list去重

    2019-11-14 11:01:13
    java8的新特性使用Stream 的distinct()方法对list集合去重 去重时需要泛型重写hashCode和equals方法 方法为: list = list.stream().distinct().collect(Collectors.toList()); 1.Stream 的distinct()方法 distinct()...
  • package com.lxz.test; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List;...import java.util.Set;... * description: List去重 * date: 2018年2月10日 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,417
精华内容 32,166
关键字:

list去重