Java에서 ArrayList의 교차 및 결합

그렇게하는 방법이 있습니까? 찾고 있었지만 찾을 수 없었습니다.

또 다른 질문 : 파일을 필터링 할 수 있도록 이러한 방법이 필요합니다. 일부는 AND필터이고 일부는 OR(이론과 같은) 필터이므로 모든 파일에 따라 필터링해야하며 해당 파일을 보유하는 Unite / intersects ArrayList를 필터링해야합니다.

파일을 보유하기 위해 다른 데이터 구조를 사용해야합니까? 더 나은 런타임을 제공하는 다른 것이 있습니까?

다음은 타사 라이브러리를 사용하지 않는 일반 구현입니다. 주요 장점을 통해 retainAll, removeAll그리고 addAll이러한 방법은 방법 원래 목록 입력을 수정하지 않는 것이 있습니다.

public class Test {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<String>(Arrays.asList("B", "C", "D", "E", "F"));

        System.out.println(new Test().intersection(list1, list2));
        System.out.println(new Test().union(list1, list2));
    }

    public <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<T>();

        set.addAll(list1);
        set.addAll(list2);

        return new ArrayList<T>(set);
    }

    public <T> List<T> intersection(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if(list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

컬렉션 (따라서 ArrayList도)은 다음과 같습니다.

col.retainAll(otherCol) // for intersection
col.addAll(otherCol) // for union

반복을 수락하면 List 구현을 사용하고, 그렇지 않으면 Set 구현을 사용하십시오.

Collection<String> col1 = new ArrayList<String>(); // {a, b, c}
// Collection<String> col1 = new TreeSet<String>();
col1.add("a");
col1.add("b");
col1.add("c");

Collection<String> col2 = new ArrayList<String>(); // {b, c, d, e}
// Collection<String> col2 = new TreeSet<String>();
col2.add("b");
col2.add("c");
col2.add("d");
col2.add("e");

col1.addAll(col2);
System.out.println(col1); 
//output for ArrayList: [a, b, c, b, c, d, e]
//output for TreeSet: [a, b, c, d, e]

이 게시물은 상당히 오래되었지만 그럼에도 불구하고 해당 주제를 찾을 때 Google에 처음 나타나는 게시물입니다.

Java 8 스트림을 사용하여 한 줄에 (기본적으로) 동일한 작업을 수행하여 업데이트를 제공하고 싶습니다.

List<T> intersect = list1.stream()
    .filter(list2::contains)
    .collect(Collectors.toList());

List<T> union = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

누구든지 더 나은 / 빠른 솔루션을 가지고 있다면 알려주세요. 그러나이 솔루션은 불필요한 도우미 클래스 / 메소드를 추가하지 않고 메소드에 쉽게 포함시킬 수 있고 여전히 가독성을 유지하는 좋은 라이너입니다.

list1.retainAll(list2) - is intersection

노동 조합이 될 것입니다 removeAll다음과addAll .

collection (ArrayList is collection) 문서에서 자세한 내용을 확인 하십시오. http://download.oracle.com/javase/1.5.0/docs/api/java/util/Collection.html

합집합과 교집합은 목록이 아닌 세트에 대해서만 정의됩니다. 당신이 언급했듯이.

필터는 구아바 라이브러리를 확인하십시오 . 또한 구아바는 실제 교차로와 노조를 제공합니다

 static <E> Sets.SetView<E >union(Set<? extends E> set1, Set<? extends E> set2)
 static <E> Sets.SetView<E> intersection(Set<E> set1, Set<?> set2)

당신은 아파치 커먼즈CollectionUtils 에서 사용할 수 있습니다 .

표시된 솔루션이 효율적이지 않습니다. 시간 복잡도는 O (n ^ 2)입니다. 우리가 할 수있는 일은 두 목록을 정렬하고 아래와 같이 교차 알고리즘을 실행하는 것입니다.

private  static ArrayList<Integer> interesect(ArrayList<Integer> f, ArrayList<Integer> s) { 
    ArrayList<Integer> res = new ArrayList<Integer>();

    int i = 0, j = 0; 
    while (i != f.size() && j != s.size()) { 

        if (f.get(i) < s.get(j)) {
            i ++;
        } else if (f.get(i) > s.get(j)) { 
            j ++;
        } else { 
            res.add(f.get(i)); 
            i ++;  j ++;
        }
    }


    return res; 
}

이것은 O (n log n)에있는 O (n log n + n)의 복잡성을가집니다. 노조도 비슷한 방식으로 이루어집니다. if-elseif-else 문을 적절히 수정하십시오.

원하는 경우 반복자를 사용할 수도 있습니다 (C ++에서 더 효율적이라는 것을 알고 있습니다 .Java에서도 이것이 사실인지 모르겠습니다).

Set교차로를 만들고 결합하려면 파일을 보유하기 위해 a 를 사용해야한다고 생각 합니다. 그럼 당신은 사용할 수 있습니다 구아바 의 세트 클래스 할 수있는 union, intersectiona로하고 필터링 Predicate아니라. 이 방법들과 다른 제안들 간의 차이점은이 모든 방법 들이 두 세트의 결합, 교차점 등에 대한 게으른 견해 를 만든다는 것 입니다. Apache Commons는 새 콜렉션을 작성하고 여기에 데이터를 복사합니다. retainAll컬렉션에서 요소를 제거하여 컬렉션 중 하나를 변경합니다.

다음은 스트림과의 교차점을 수행하는 방법입니다 (스트림에 java 8을 사용해야 함을 기억하십시오).

List<foo> fooList1 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<foo> fooList2 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
fooList1.stream().filter(f -> fooList2.contains(f)).collect(Collectors.toList());

유형이 다른 목록의 예입니다. foo와 bar 사이에 실현이 있고 스트림을 수정할 수있는 것보다 foo에서 bar 객체를 얻을 수있는 경우 :

List<foo> fooList = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<bar> barList = new ArrayList<>(Arrays.asList(new bar(), new bar()));

fooList.stream().filter(f -> barList.contains(f.getBar()).collect(Collectors.toList());

• retainAll은 목록을 수정합니다
• 구아바에는 목록에 대한 API가 없습니다 (세트 전용)

ListUtils 가이 사용 사례에 매우 유용하다는 것을 알았습니다.

기존 목록을 수정하지 않으려면 org.apache.commons.collections에서 ListUtils를 사용하십시오.

ListUtils.intersection(list1, list2)

commons-collections4 CollectionUtils를 사용할 수 있습니다

Collection<Integer> collection1 = Arrays.asList(1, 2, 4, 5, 7, 8);
Collection<Integer> collection2 = Arrays.asList(2, 3, 4, 6, 8);

Collection<Integer> intersection = CollectionUtils.intersection(collection1, collection2);
System.out.println(intersection); // [2, 4, 8]

Collection<Integer> union = CollectionUtils.union(collection1, collection2);
System.out.println(union); // [1, 2, 3, 4, 5, 6, 7, 8]

Collection<Integer> subtract = CollectionUtils.subtract(collection1, collection2);
System.out.println(subtract); // [1, 5, 7]

Java 8에서는 다음과 같은 간단한 도우미 메서드를 사용합니다.

public static <T> Collection<T> getIntersection(Collection<T> coll1, Collection<T> coll2){
    return Stream.concat(coll1.stream(), coll2.stream())
            .filter(coll1::contains)
            .filter(coll2::contains)
            .collect(Collectors.toSet());
}

public static <T> Collection<T> getMinus(Collection<T> coll1, Collection<T> coll2){
    return coll1.stream().filter(not(coll2::contains)).collect(Collectors.toSet());
}

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

목록의 객체가 해시 가능하면 (즉, 적절한 hashCode 및 equals 함수가있는 경우) 테이블 간의 가장 빠른 접근 방법은 약입니다. size> 20은 두 목록 중 더 큰 HashSet을 구성하는 것입니다.

public static <T> ArrayList<T> intersection(Collection<T> a, Collection<T> b) {
    if (b.size() > a.size()) {
        return intersection(b, a);
    } else {
        if (b.size() > 20 && !(a instanceof HashSet)) {
            a = new HashSet(a);
        }
        ArrayList<T> result = new ArrayList();
        for (T objb : b) {
            if (a.contains(objb)) {
                result.add(objb);
            }
        }
        return result;
    }
}

나는 비슷한 상황에서 일하고 있었고 여기에 도움을 요청했습니다. Arrays에 대한 내 솔루션을 찾게되었습니다. ArrayList AbsentDates = new ArrayList (); // Array1-Array2를 저장합니다

참고 : 누군가이 페이지를 방문하여 도움을받을 수있는 경우 게시하십시오.

ArrayList<String> AbsentDates = new ArrayList<String>();//This Array will store difference
      public void AbsentDays() {
            findDates("April", "2017");//Array one with dates in Month April 2017
            findPresentDays();//Array two carrying some dates which are subset of Dates in Month April 2017

            for (int i = 0; i < Dates.size(); i++) {

                for (int j = 0; j < PresentDates.size(); j++) {

                    if (Dates.get(i).equals(PresentDates.get(j))) {

                        Dates.remove(i);
                    }               

                }              
                AbsentDates = Dates;   
            }
            System.out.println(AbsentDates );
        }

공통 키를 기반으로 한 다른 객체의 두 목록 교차-Java 8

 private List<User> intersection(List<User> users, List<OtherUser> list) {

        return list.stream()
                .flatMap(OtherUser -> users.stream()
                        .filter(user -> user.getId()
                                .equalsIgnoreCase(OtherUser.getId())))
                .collect(Collectors.toList());
    }

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    Set<T> set1, set2;
    if (col1 instanceof Set) {
        set1 = (Set) col1;
    } else {
        set1 = new HashSet<>(col1);
    }

    if (col2 instanceof Set) {
        set2 = (Set) col2;
    } else {
        set2 = new HashSet<>(col2);
    }

    Set<T> intersection = new HashSet<>(Math.min(set1.size(), set2.size()));

    for (T t : set1) {
        if (set2.contains(t)) {
            intersection.add(t);
        }
    }

    return intersection;
}

JDK8 + (아마도 최고의 성능)

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    boolean isCol1Larger = col1.size() > col2.size();
    Set<T> largerSet;
    Collection<T> smallerCol;

    if (isCol1Larger) {
        if (col1 instanceof Set) {
            largerSet = (Set<T>) col1;
        } else {
            largerSet = new HashSet<>(col1);
        }
        smallerCol = col2;
    } else {
        if (col2 instanceof Set) {
            largerSet = (Set<T>) col2;
        } else {
            largerSet = new HashSet<>(col2);
        }
        smallerCol = col1;
    }

    return smallerCol.stream()
            .filter(largerSet::contains)
            .collect(Collectors.toSet());
}

성능에 신경 쓰지 않고 더 작은 코드를 선호하는 경우 다음을 사용하십시오.

col1.stream().filter(col2::contains).collect(Collectors.toList());

마지막 해결책:

//all sorted items from both
public <T> List<T> getListReunion(List<T> list1, List<T> list2) {
    Set<T> set = new HashSet<T>();
    set.addAll(list1);
    set.addAll(list2);
    return new ArrayList<T>(set);
}

//common items from both
public <T> List<T> getListIntersection(List<T> list1, List<T> list2) {
    list1.retainAll(list2);
    return list1;
}

//common items from list1 not present in list2
public <T> List<T> getListDifference(List<T> list1, List<T> list2) {
    list1.removeAll(list2);
    return list1;
}

먼저 배열의 모든 값을 단일 배열로 복사 한 다음 중복 값을 배열로 제거합니다. 12 번 줄, 같은 숫자가 시간보다 많이 발생하는지 설명하고 여분의 가비지 값을 "j"위치에 넣습니다. 마지막에, 시작점에서 순회하여 동일한 가비지 값이 발생하는지 확인한 후 폐기하십시오.

public class Union {
public static void main(String[] args){

    int arr1[]={1,3,3,2,4,2,3,3,5,2,1,99};
    int arr2[]={1,3,2,1,3,2,4,6,3,4};
    int arr3[]=new int[arr1.length+arr2.length];

    for(int i=0;i<arr1.length;i++)
        arr3[i]=arr1[i];

    for(int i=0;i<arr2.length;i++)
        arr3[arr1.length+i]=arr2[i];
    System.out.println(Arrays.toString(arr3));

    for(int i=0;i<arr3.length;i++)
    {
        for(int j=i+1;j<arr3.length;j++)
        {
            if(arr3[i]==arr3[j])
                arr3[j]=99999999;          //line  12
        }
    }
    for(int i=0;i<arr3.length;i++)
    {
        if(arr3[i]!=99999999)
            System.out.print(arr3[i]+" ");
    }
}   
}

테스트 후 여기에 가장 좋은 교차 접근법이 있습니다.

순수한 HashSet 접근 방식에 비해 빠른 속도. 아래의 HashSet 및 HashMap은 1 백만 개가 넘는 레코드가있는 어레이에 대해 유사한 성능을 갖습니다.

Java 8 Stream 접근 방식의 경우 배열 크기가 10k보다 큰 경우 속도가 매우 느립니다.

이것이 도움이되기를 바랍니다.

public static List<String> hashMapIntersection(List<String> target, List<String> support) {
    List<String> r = new ArrayList<String>();
    Map<String, Integer> map = new HashMap<String, Integer>();
    for (String s : support) {
        map.put(s, 0);
    }
    for (String s : target) {
        if (map.containsKey(s)) {
            r.add(s);
        }
    }
    return r;
}
public static List<String> hashSetIntersection(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();

    List<String> r = new ArrayList<String>();
    Set<String> set = new HashSet<String>(b);

    for (String s : a) {
        if (set.contains(s)) {
            r.add(s);
        }
    }
    print("intersection:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
    return r;
}

public static void union(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();
    Set<String> r= new HashSet<String>(a);
    r.addAll(b);
    print("union:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
}

공통 요소를 찾기위한 retainAll () 메소드 사용.

세트에 데이터가 있다면 Guava의 Sets클래스를 사용할 수 있습니다 .

내가 확인하는 것보다 숫자가 일치하면 처음으로 발생하거나 "indexOf ()"의 도움으로 숫자가 처음으로 일치하면 인쇄하고 문자열에 저장하여 다음 번에 같은 숫자가 일치하면 ' "indexOf ()"조건으로 인해 인쇄가 실패합니다.

class Intersection
{
public static void main(String[] args)
 {
  String s="";
    int[] array1 = {1, 2, 5, 5, 8, 9, 7,2,3512451,4,4,5 ,10};
    int[] array2 = {1, 0, 6, 15, 6, 5,4, 1,7, 0,5,4,5,2,3,8,5,3512451};


       for (int i = 0; i < array1.length; i++)
       {
           for (int j = 0; j < array2.length; j++)
           {
               char c=(char)(array1[i]);
               if(array1[i] == (array2[j])&&s.indexOf(c)==-1)
               {    
                System.out.println("Common element is : "+(array1[i]));
                s+=c;
                }
           }
       }    
}

}