精华内容
下载资源
问答
  • java 数组去重
    2021-03-14 02:24:27

    uniq.java

    import java.util.Arrays;

    import java.util.ArrayList;

    import java.util.List;

    public class uniq {

    public static void main(String[] args){

    ArrayList oList = new ArrayList<>(Arrays.asList(new Obj[]{

    new Obj("1:00"), new Obj("2:00"), new Obj("3:00"),

    new Obj("1:00"), new Obj("2:00"), new Obj("3:00")

    })); // 测试数组,有重复值

    ArrayList oUniq = new ArrayList(); // 存储不重复的数组

    for(Obj o:oList){

    boolean exists = false;

    for(Obj e:oUniq){ // 循环已经存在的列表,你是不是想在个循环里面动oUniq数组?

    if(o.time.equals(e.time)){ // 判断是否相等

    exists = true;

    break;

    }

    }// oUniq循环结束,你现在可以动了!

    if(!exists){ // 不存在加入

    oUniq.add(o); // 修改oUniq数组

    }

    }

    System.out.println(oUniq); // 只输出 [1:00, 2:00, 3:00] 没有重复

    }

    }

    // 测试对象

    class Obj {

    String time;

    Obj(String t){

    this.time = t;

    }

    public String toString(){

    return this.time;

    }

    }

    run.sh

    [jesse@Jesse-iMac:~/project/test/java$] javac uniq.java && java uniq

    [1:00, 2:00, 3:00]

    更多相关内容
  • 本文主要介绍了java list 去重的方法,其中有带类型写法和不带类型写法,并举例测试,具有一定参考借鉴价值,希望能对有需要的小伙伴有所帮助
  • 主要介绍了Java实现的数组去重与排序操作,结合实例形式分析了Java针对数组去重及排序操作相关遍历、排序、判断等使用技巧与注意事项,需要的朋友可以参考下
  • Java去重TXT文件内容,两个TXT文件内容对比去重复,使用了Java8的新特性,所以只能Java8以上即可使用
  • 主要介绍了Java中对List去重, Stream去重的问题解答,文中给大家介绍了Java中List集合去除重复数据的方法,需要的朋友可以参考下
  • 主要介绍了Java8新特性之字符串去重介绍,新的字符串去重特性可以帮助减少应用中String对象的内存占用,目前该特性只适用于G1垃圾收集器,并且默认不被开启,需要的朋友可以参考下
  • Java List中数据的去重

    2020-08-26 09:52:03
    今天小编就为大家分享一篇关于Java List中数据的去重,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要介绍了Java中字符串去重的特性,是Java8中引入的一个新特性,至于是否真的用起来顺手就见仁见智了...需要的朋友可以参考下
  • 主要介绍了简述Java List去重五种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java中List集合对象去重及按属性去重的8种方法,本文给大家介绍的非常详细,对大家的学习或工作具有一地的参考借鉴价值,需要的朋友可以参考下
  • java去重的五种方式

    千次阅读 2021-12-08 10:01:32
    java去重的五种方式

    main方法

    public static void main(String[] args) {
    		String s = "aaabbbcccddddqweqwertt";
    		System.out.println(remove1(s));//方法一
    		System.out.println(remove2(s));//方法二
    		System.out.println(remove3(s));//方法三
    		System.out.println(remove4(s));//方法四
    		System.out.println(remove5(s));//方法五
    }

    方法一:

    //字符串
    	public static String remove1(String str){
    		String s = "";
    		
    		for (int i = 0; i < str.length(); i++) {
    			String arr =str.charAt(i) + "";
    			if (s.indexOf(arr) == -1) {
    				s=s+arr;
    			}
    		}
    		return s;
    	}

    方法二:

    //Set
    	public static String remove2(String str){
    		String s = "";
    		Set set = new HashSet();
    		for (int i = 0; i <str.length(); i++) {
    			String arr = str.charAt(i) + "";
    			set.add(arr);
    		}
    		return toString(set);
    	}
    	public static String toString(Set set){
    		String str = "";
    		for (Object obj : set) {
    			str = str+ (String)obj;
     		}
    		return str;
    	}

    方法三:

    //List
    	public static String remove3(String str){
    		
    		List list = new ArrayList();
    		
    		for (int i = 0; i < str.length(); i++) {
    			
    			String s = str.charAt(i)+"";
    			if (!list.contains(s)) {
    				list.add(s);
    			}
    		}
    		
    		return toString(list);
    	}
    	public static String toString(List list){
    		String str = "";
    		for (Object obj : list) {
    			str = str+ (String)obj;
     		}
    		return str;
    		
    	}

    方法四:

    //HashMap
    	public static String remove4(String str){
    		
    		Map map = new HashMap();
    		for (int i = 0; i < str.length(); i++) {
    			String s = str.charAt(i)+"";
    			map.put(s, 1);
    			
    		}
    		Set set =map.keySet();
    		return toString1(set);
    	}
    	public static String toString1(Set set){
    		String str = "";
    		for (Object obj : set) {
    			str = str+ (String)obj;
     		}
    		return str;
    	}

    方法五:

    //字符串数组集合
    	public static String remove5(String str){
    		String[] arr = new String[str.length()];
    		String s = "";
    		for (int i = 0; i < str.length(); i++) {
    			arr[i] = str.charAt(i)+"";
    		}
    		
    		for (int i = 0; i < arr.length; i++) {
    			for (int j = i+1; j <arr.length; j++) {
    				if (arr[i].equals(arr[j])) {
    					arr[j] = "s";
    					
    				}
    			}
    		}
    		for (int i = 0; i < arr.length; i++) {
    			if (!arr[i].equals("s")) {
    				s= s+arr[i];
    			}
    		}
    		return s;
    	}

    展开全文
  • java jsonarray 踢重 去重操作
  • 1、java8多条件过滤事例: // 筛选短信黑名单数据 List smsBlackListSet = allBlacklist.stream().filter(sms -> (sms.getCorpcode().equals(corpCode) && sms.getBltype().equals(MessageTypeEnum.SMS.getKey()) ...
  • java基础,多线程,去重等功能..txt
  • 主要介绍了如何实现java8 list按照元素的某个字段去重,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,,需要的朋友可以参考下
  • 今天小编就为大家分享一篇Java中字符串中连续相同字符去重方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了Java实现对两个List快速去重并排序操作,结合实例形式较为详细的分析了Java针对list的遍历、去重、排序相关操作技巧与注意事项,需要的朋友可以参考下
  • JAVA多种去重方式

    2021-12-08 11:08:48
    字符串去重 /** * 字符串去重 * @param str * @return */ public static String getByStr(String str){ String result=""; for (int i = 0; i < str.length(); i++) { String s=str.charAt(i)+""; if ...

    字符串去重

    /**
         * 字符串去重
         * @param str
         * @return
         */
        public static String getByStr(String str){
            String result="";
            for (int i = 0; i < str.length(); i++) {
                String s=str.charAt(i)+"";
                if (result.indexOf(s)<0){
                    result+=s;
                }
            }
            return result;
        }
    

    字符串数组去重

    /**
         * 数组去重
         * @param str
         * @return
         */
        public static String getByArry(String str){
            String result="";
            String[] strs=new String[str.length()];
            String[] arr=new String[str.length()];
            for (int i = 0; i < str.length(); i++) {
                arr[i]=str.charAt(i)+"";
            }
            out:for (int i = 0; i < arr.length; i++) {
                for (int j = i+1; j < arr.length; j++) {
                    if (arr[i].equals(arr[j])){
                        continue out;
                    }
                }
                // 后面没有与当前元素重复的值,保存这个数
                strs[i] = arr[i];
            }
            for (int i = 0; i < strs.length; i++) {
                if (strs[i]!=null){
                    result+=strs[i];
                }
            }
            return result;
        }
    

    List去重

    /**
         * list去重
         * @param str
         * @return
         */
       public static String getByList(String str){
            String result="";
            List strLsit=new ArrayList();
           for (int i = 0; i < str.length(); i++) {
               String s=str.charAt(i)+"";
               if (!strLsit.contains(s)){
                   strLsit.add(s);
               }
           }
            return getListString(strLsit);
       }
    
    	/**
         * 将list转换为字符串
         * @param list
         * @return
         */
       public static String getListString(List list){
            String result="";
           for (Object obj: list) {
               String str= (String) obj;
               result+=str;
           }
           return result;
       }
    

    Set去重

    /**
         * set去重
         * @param str
         * @return
         */
       public static String getBySet(String str){
           String result="";
           Set strSet=new HashSet();
           for (int i = 0; i < str.length(); i++) {
               String s=str.charAt(i)+"";
               strSet.add(s);
           }
           return getSetString(strSet);
       }
    /**
         * 将Set转换为字符串
         * @param set
         * @return
         */
        public static String getSetString(Set set){
            String result="";
            for (Object obj: set) {
                String str= (String) obj;
                result+=str;
            }
            return result;
        }
    

    Map去重

    /**
         * map去重
         * @param str
         * @return
         */
       public static String getByMap(String str){
           String result="";
           Map map=new HashMap();
           for (int i = 0; i < str.length(); i++) {
               String s=str.charAt(i)+"";
               map.put(s,s);
           }
           return getMapString(map);
       }
    /**
         * 将map转换为字符串
         * @param map
         * @return
         */
        public static String getMapString(Map map){
            String result="";
            for (Object obj: map.keySet()) {
                String str= (String) obj;
                result+=str;
            }
            return result;
        }
    

    测试

     public static void main(String[] args) {
            String str="abcabcvfvv";
            //字符串去重
            //String byStr = getByStr(str);
            //List去重
            //String byStr = getByList(str);
            //Set去重
            //String byStr = getBySet(str);
            //map去重
            //String byStr = getByMap(str);
            //数组去重
            String byStr = getByArry(str);
            System.out.println(byStr);
        }
    
    展开全文
  • Java集合去重

    2022-04-21 19:12:28
    在日常工作中,我们时常会遇到需要对数据进行遍历去重的操作,笔者便将自己所熟知的几种方法分享给大家。 首先模拟一个实体类,并创建一个main方法调用。 public static void main(String[] args) { List<...
    在日常工作中,我们时常会遇到需要对数据进行遍历去重的操作,笔者便将自己所熟知的几种方法分享给大家。
    

    首先模拟一个实体类,并创建一个main方法调用。

    public static void main(String[] args) {
            List<User> list = new ArrayList(4);
            list.add(new User("张三","杭州"));
            list.add(new User("李四","上海"));
            list.add(new User("王五","深圳"));
            list.add(new User("赵六","深圳"));
    
    }
    public class User{
            private String name;
            private String city;
    
            public User(String name, String city) {
                this.name = name;
                this.city = city;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public String getCity() {
                return city;
            }
            public void setCity(String city) {
                this.city = city;
            }
        }
    1.双重循环比较
     思路:创建一个新的不重复列表 每次遍历元素都和之前存放的元素进行比较,若重复则移除,遍历一次后再放入。这也是初学者们最先运用到的一种方法。
    public List duplicateRemovalByCircle(List<User> list){
           
            List newList = new ArrayList();
            for (int i = 0;i < list.size();i++){
                for (int j = 0;j < i;j++){
                    if(list.get(i).getCity().equals(list.get(j).getCity())){
                        newList.remove(list.get(j).getCity());
                    }
                }
                newList.add(list.get(i).getCity());
            }
            return list;
        }
    2.使用Set集合
    思路:Set是元素不可重复的集合,遍历列表直接将元素放入Set集合即可完成去重,或者直接使用Set转换成List的方法
    拓展:查看源码可知,HashSet的底层是HashMap,而HashSet的Add方法也就是调用了HashMap的put方法,Set的元素作为Map中的key,Object实例作为值。
    public List duplicateRemovalBySet(List<User> list){
            Set set = new HashSet();
            list.addAll(set);
            for(int i = 0;i < list.size();i++){
                set.add(list.get(i).getCity());
            }
            List newlist = new ArrayList();
            newlist.addAll(set);
            return newlist;
        }
    3.使用Java8的新特性 stream进行去重
    思路:使用流操作集合,高效易懂,并且拓展性强。
        public List duplicateRemovalByStream(List<User> list){
            List newList = new ArrayList();
            newList = list.stream().map(User::getCity).distinct().collect(Collectors.toList());
            return newList;
        }

    展开全文
  • 今天小编就为大家分享一篇关于海量数据去重排序bitmap(位图法)在java中实现的两种方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要介绍了关于java中List对象列表实现去重或取出以及排序的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面跟着小编来一起学习学习吧。
  • java set 去重

    2015-10-20 18:27:30
    java set 去重
  • 如果要不去重的话就需要传入自定义比较器并重写compareTo()方法,这里用匿名表达式来写: TreeSet treeSet=new TreeSet((o1, o2) -> { int dif=o1.compareTo(o2); //noinspection ComparatorMethodParameterNotUsed...
  • java 去重排序

    千次阅读 2019-03-21 21:15:22
    参考https://blog.csdn.net/u011781521/article/details/80124896 JAVA 集合 升序|降序|随机|去重排序 (1)集合排序 List<Integer> list= new ArrayList<Integer>(); list.add(3); list.add(1); .....
  • Java去重算法

    千次阅读 2017-11-24 21:51:09
    1. 循环list中的所有元素然后删除重复 ...[java] view plain copy public static List removeDuplicate(List list) {   for ( int i = 0 ; i 1 ; i ++ ) {   for ( int 
  • java 对象去重

    千次阅读 2019-09-26 10:07:06
    Java 对象 去重 List reuslt = lists.stream().filter(item -> !listAll.stream().map(e -> e.getEquipNum()) .collect(Collectors.toList()).contains(item.getEquipNum())).collect(Collectors.toList()); ...
  • Java数据去重

    2021-08-05 09:40:18
    数组去重,建议使用特性(List和Set) int [] arrays={11,22,55,66,11,22,33,66,55};//List去重 List list=new ArrayList(); for (int i = 0; i <arrays.length ; i++) { if (!list.contains(arrays[i])){ ...
  • Java数组去重

    2021-11-05 10:18:04
    //方法1:通过List去重  public static void test1(String [] arr) { List<String> list = new ArrayList<>(); for (int i=0; i<arr.length; i++) { if(!list.contains(arr[i])) { list.add(arr...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,522
精华内容 30,608
关键字:

java去重是什么意思

java 订阅