急求一个集合是否存在另一个集合元素,如果不存在则祛除

DE丶潇洒 发布于 2017/07/01 16:32
阅读 134
收藏 1

public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("1");
        a.add("2");
        a.add("3");
        List<String> b = new ArrayList<>();
        b.add("1");
        b.add("2");
        
        for (int i = 0; i < b.size(); i++) {
            for (int j = 0; j < a.size(); i++) {
            if(b.get(i) == a.get(j)){
                System.out.println(a.get(i));
                }
            }
        }
    }

两个list 元素,如果两个list中有元素不相等那么我要得到不相等的那个元素,为什么这样只能得到1呢,求改正

 

加载中
0
confused_man
confused_man

改成!=试试呢

0
你美你说的对
你美你说的对

API 有现成的方法怎么不用啊 

0
我_承宇
我_承宇

a.removeAll(b) 不就行了,不就是求个差集么

0
lymo0818
lymo0818

循环的游标不对应,另对象是否相等使用equals,==是比较引用地址的:

package com.java.base.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class TestMain {

	public static void main(String[] args) {
		List<String> a = new ArrayList<String>();
		a.add("1");
        a.add("2");
        a.add("3");
	    List<String> b = new ArrayList<String>();
	    b.add("1");
        b.add("2");
	    
	    for (int i = 0; i < b.size(); i++) {
	        for (int j = 0; j < a.size(); j++) {
	        	boolean isEqual = isEqual( b.get(i), a.get(j) );
	        	if( isEqual ){
	        		System.out.println(a.get(j));
	            }
	        }
	    }
	    
	    /*int min = 0;
	    int max = 100;
	    int size = 50;
	    for( int i=0;i<size;i++ ){
	    	a.add( randomInt(min,max)+"" );
	    }
	    for( int i=0;i<size;i++ ){
	    	b.add( randomInt(min,max)+"" );
	    }
	    
	    long f = System.currentTimeMillis();   
	    System.out.println( isEqual("123", 123) );
	    List<String> c = getCommonElement(a, b,true);
	    System.out.println( "相同:"+c.size()+ "集合:"+ c );
	    List<String> d = getDifferentElement(a, b,true);
	    System.out.println( "不同:"+d.size()+ "集合:"+ d );
	    System.out.println( existCommonElement(a, b) );
	    long g = System.currentTimeMillis();
	    
	    System.out.println("消耗的时间:"+ ( g - f ) + "ms");*/
	    
	}
	
	/**
	 * 获取第一个集合与另一个集合的相同元素(不包括null值)
	 * @param master 主集合
	 * @param sub 次集合
	 * @param duplicate 相同元素的集合,是否允许重复值
	 * @return 主集合中与次集合相同元素的集合
	 */
	public static <T> List<T> getCommonElement(List<T> master,List<T> sub,boolean duplicate){
		List<T> list = getCommonElement(master, sub);
		if( duplicate ){
			return list;
		}else{
			Map<Integer,T> m = listToMap(list);
			return mapValueToList(m);
		}
	}
	
	/**
	 * 获取第一个集合与另一个集合的相同元素(不包括null值)
	 * @param master 主集合
	 * @param sub 次集合
	 * @return 主集合中与次集合相同元素的集合(允许重复值)
	 */
	public static <T> List<T> getCommonElement(List<T> master,List<T> sub){
		List<T> commonElementList = new ArrayList<T>();
		if( master==null || sub==null || master.size()==0 || sub.size()==0 ){
			return commonElementList;
		}
		Map<Integer,T> m = listToMap( sub );
		for(T e : master){
			if(e!=null){
				Integer key = e.hashCode();
				T value = m.get(key);
				if( value!=null ){
					commonElementList.add(e);
				}
			}
		}
		return commonElementList;
	}
	
	/**
	 * 获取第一个集合与另一个集合的 <strong>不相同</strong> 元素(不包括null值)
	 * @param master 主集合
	 * @param sub 次集合
	 * @param duplicate  <strong>不相同</strong> 元素的集合,是否允许重复值
	 * @return 主集合中与次集合相同元素的集合
	 */
	public static <T> List<T> getDifferentElement(List<T> master,List<T> sub,boolean duplicate){
		List<T> list = getDifferentElement(master, sub);
		if( duplicate ){
			return list;
		}else{
			Map<Integer,T> m = listToMap(list);
			return mapValueToList(m);
		}
	}
	
	/**
	 * 获取第一个集合与另一个集合的 <strong>不相同</strong> 元素(不包括null值)
	 * @param master 主集合
	 * @param sub 次集合
	 * @return 主集合中与次集合 <strong>不相同</strong> 元素的集合(允许重复值)
	 */
	public static <T> List<T> getDifferentElement(List<T> master,List<T> sub){
		List<T> commonElementList = new ArrayList<T>();
		if( master==null || sub==null || master.size()==0 || sub.size()==0 ){
			return commonElementList;
		}
		Map<Integer,T> m = listToMap( sub );
		for(T e : master){
			if(e!=null){
				Integer key = e.hashCode();
				T value = m.get(key);
				if( value==null ){
					commonElementList.add(e);
				}
			}
		}
		return commonElementList;
	}
	
	
	/**
	 * 是否存在相同及元素(不包括null值)
	 * @param master 主集合
	 * @param sub 次集合
	 * @return 是否存在(true/false)
	 */
	public static <T> boolean existCommonElement(List<T> master,List<T> sub ){
		if( master==null || sub==null || master.size()==0 || sub.size()==0 ){
			return false;
		}
		Map<Integer,T> m = listToMap( sub );
		for(T e : master){
			if(e!=null){
				Integer key = e.hashCode();
				T value = m.get(key);
				if( value!=null ){
					return true;
				}
			}
		}
		return false;
	}
	
	/**
	 * 自定义对象须重写equals方法
	 */
	private static boolean isEqual(Object obj1,Object obj2){
		if( obj1==null ){
    		return ( obj2==null );
    	}else{
    		return obj1.equals( obj2 );
    	}
	}
	
	
	private static <K,V> List<V> mapValueToList(Map<K,V> m){
		List<V> list = new ArrayList<V>();
		if(m==null || m.size()==0){
			return list;
		}
		for(Map.Entry<K, V> entry : m.entrySet()){
			V value = entry.getValue();
			list.add( value );
		}
		return list;
	}
	
	/**
	 * 返回值Map中key值为对象的hashCode,故List中如是自定义的类须重写hashCode方法
	 * @return Map[hashCode , List中的值对象]
	 */
	private static <V> Map<Integer,V> listToMap(List<V> list){
		if(list==null || list.size()==0){
			return new HashMap<Integer, V>();
		}
		Map<Integer,V> m = new HashMap<Integer, V>( list.size() );
		for(V e : list){
			if(e!=null){
				m.put(e.hashCode(), e);
			}
		}
		return m;
	}
	
	/**
	 * 指定范围随机数
	 */
	private static int randomInt(int min,int max){
		Random random = new Random();
		return random.nextInt(max)%(max-min+1) + min;
	}

}

 

返回顶部
顶部