Develop Reference

Get unique elements from Java array - where's the mistake? [duplicate]

This question already has answers here:
Get all unique values in a JavaScript array (remove duplicates)
(91 answers)
Closed 12 months ago.
I'm just a beginner and I'm trying to write a method returning only unique elements from Java array. What's wrong with this code? Could you please point my mistakes and help me correct them? I've got no idea what to do with it.
P.S. I know I could use packages, but it has to be done in the simplest way.
public static void main(String[] args) {
int[] arr = {1, 1, 2, 3};
int[] items = returnNonRepeated(arr);
System.out.print(items);
}
public static int[] returnNonRepeated(int[] arr) {
int[] temp = new int[0];
int n = 0;
for (int i = 0; i < arr.length; i++) {
if (i == 0) {
temp[i] = arr[i];
} else {
if (arr[i] != arr[i - 1]) {
temp[numbersCount] = arr[i];
numbersCount++;
}
}
}
return temp;
}
}

I know it's not code golf here, but:
if you want to keep only unique values (like a Set would do), you can use a "one-liner". You don't have to implement loops.
public static void main(String[] args) {
int[] dupes = {0, 1, 2, 1, 3, 2, 3};
int[] uniques = Arrays.stream(dupes) // stream ints
.boxed() // make Integer of int
.collect(Collectors.toSet()) // collect into set to remove duplicates
.stream() // stream Integers
.mapToInt(Integer::intValue) // make int of Integer
.toArray(); // and back into an array
System.out.println(Arrays.toString(uniques));
}
Please not that you have to use java.util.Arrays.toString() to get useful output in the last statement. With your variant it will print only something like "[I#531be3c5" which denotes that it is an array of int, but says nothing about the contents.
Nevertheless - if you want to understand, how arrays and loops work, the looping solution is better!

I'm not sure if you mean non-repeat or unique
But here is a method for checking for duplicates:
public static int[] returnUniqueArray(int[] arr) {
int dupes = new int[arr.length]; // The most dupes you could have is the length of the input
int numberOfDupes = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
if(arr[i] == arr[j]) {
dupes[numberOfDupes] = arr[i];
numberOfDupes++;
}
}
}
return dupes;
}
This loops round the arr array twice, therefore comparing every variable in arr to every other variable. If they are the same, it adds that value to a new array.
You could also do similar for non-repeat:
public static int[] returnNonRepeatArray(int[] arr) {
int dupes = new int[arr.length];
int numberOfDupes = 0;
for (int i = 0; i < arr.length - 1; i++) {
if(arr[i] == arr[i+1]) {
dupes[numberOfDupes] = arr[i];
numberOfDupes++;
}
}
return dupes;
}
This loops round the arr array once, but does not check the last item (-1 in the for loop). It then compares the item against the next item, if they are the same it adds that to the dupes.

public static void main(String[] args) {
int[] arr = {1, 1, 2, 2, 3, 4, 5, 5, 5, 6};
int[] items = returnNonRepeated(arr);
System.out.print(Arrays.toString(items));
}
public static int[] returnNonRepeated(int[] arr) {
int[] temp = new int[arr.length];
int numbersCount = 1;
for (int i = 0; i < arr.length; i++) {
if (i == 0) {
uniques[numbersCount] = arr[i];
numbersCount++;
} else {
if (arr[i] != arr[i - 1]) {
uniques[numbersCount] = arr[i];
numbersCount++;
}
}
}
return uniques;
}

Finding difference between two integer arrays

I'm writing a function which returns the difference between two integer arrays. I'm assuming that that all elements in input arrays are unique and also the input arrays are not sorted. For Example:
Input:
arr1 = [1,2,3,5,4]
arr2 = [1,2,3]
Expected Output: [4,5]
My Output: [1,2,3,4,5] (when first array is larger than second)
When I make the second array larger than first, I get ArrayIndexOutOfBoundsException.
public class Test{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter length of first array");
int ml = sc.nextInt();
System.out.println("Enter length of second array");
int nl = sc.nextInt();
int m[] = new int[ml];
int n[] = new int[nl];
System.out.println("Enter elements of first array");
for(int i=0;i<ml;i++)
{
m[i] = sc.nextInt();
}
System.out.println("Enter elements of second array");
for(int j=0;j<nl;j++)
{
m[j] = sc.nextInt();
}
ArrayList<Integer> arr1 = new ArrayList<Integer>();
for(int i: m){ arr1.add(i);}
ArrayList<Integer> arr2 = new ArrayList<Integer>();
for(int j: n){ arr2.add(j);}
if(ml>nl)
{
arr1.removeAll(arr2);
System.out.println(arr1);
}
else
{
arr2.removeAll(arr1);
System.out.println(arr2);
}
}
}

In the second iteration you should use n[j] = ... instead of m[j] = ...
You should use more descriptive variable names to prevent thing kind of thing from happening.

If it is not a homework that let you practice on array/iterations, you may consider using Set for much simpler logic:
// pseudo-code
Set<Integer> set1 = new HashSet<>(array1);
Set<Integer> set2 = new HashSet<>(array2);
// Using Guava
Set<Integer> diff = Sets.symmetricDifference(set1, set2);
// Java only
Set<Integer> diff1 = new HashSet<>(set1);
diff1.removeAll(set2); // diff1 contains entries in array1 but not 2
Set<Integer> diff2 = new HashSet<>(set2);
diff2.removeAll(set1); // diff2 contains entries in array2 but not 1
Set<Integer> diff = new HashSet<>(set1);
diff.addAll(set2);
// Java only, using stream
return Stream.concat(set1.stream(), set2.stream())
.filter(i -> ! (set1.contains(i) && set2.contains(i)))
.collect(Collectors.toSet());

You can check if element exist in second one if not can add to output array as below:
int[] array1 = new int[] { 1, 2, 3, 4, 5 };
int[] array2 = new int[] { 1, 2, 3 };
List<Integer> output = new ArrayList<>();
for (int i = 0; i < array1.length; i++) {
boolean flag = false;
for (int j = 0; j < array2.length; j++) {
if (array1[i] == array2[j]) {
flag = true;
break;
}
}
if (!flag) {
output.add(array1[i]);
}
}
System.out.println(output);

Java - Finding unique elements in two different arrays

I need to find the unique elements in two different arrays.
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr1[i]);
}
else{
contains = false;
}
}
System.out.println(list);
}
But here I'm getting [1,2,3,4] as output. But the expected output is [1,2,3,4,7,8]. I'm not sure what I'm doing wrong here. And I need it in a traditional way. I don't want to use any inbuilt methods to acheive this.
Note: I feel it is not a duplicate because, the solution provided is not finding the unique elements on two arrays.

This solves your problem:
public static void main(String[] args) {
// Make the two lists
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 4, 5, 6);
List<Integer> list2 = Arrays.asList(5, 6, 7, 8);
// Prepare a union
Set<Integer> union = new HashSet<Integer>(list1);
union.addAll(list2);
// Prepare an intersection
Set<Integer> intersection = new HashSet<Integer>(list1);
intersection.retainAll(list2);
// Subtract the intersection from the union
union.removeAll(intersection);
// Print the result
for (Integer n : union) {
System.out.println(n);
}
}

Using HashSet, for educative purposes, which could be very fast if lists are big:
public static void main(final String[] args) {
final List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
final Set<Integer> set1 = new HashSet<>(list1);
final List<Integer> list2 = new ArrayList<>(Arrays.asList(5, 6, 7, 8));
final Set<Integer> set2 = new HashSet<>(list2);
set1.retainAll(set2); // Keep union.
// Remove union to keep only unique items.
list1.removeAll(set1);
list2.removeAll(set1);
// Accumulate unique items.
list1.addAll(list2);
System.out.println(new HashSet<>(list1));
// [1,2,3,4,7,8]
}

Actually, there is a more simple solution using Java TreeSet.java TreeSet doesn't contain duplicate elements. Therefore, all you have to do is create a TreeSet and adding all elements to it. It also keeps the natural (sorted) Order.
public static void main(String[] args) {
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
TreeSet<Integer> set = new TreeSet<>();
for (int i:arr1) {
set.add(i);
}
for (int i:arr2) {
set.add(i);
}
System.out.println(set);
}
output: [1, 2, 3, 4, 5, 6, 7, 8]

If you are using java 8 i would suggest this solution :
public static void main(String[] args) {
int[] arr1 = new int[]{1, 2, 3, 4, 5, 6};
int[] arr2 = new int[]{5, 6, 7, 8};
List<Integer> list = new ArrayList<>();//create a list or Integers
//add the values of the two arrays in this list
list.addAll(Arrays.stream(arr1).boxed().collect(Collectors.toList()));
list.addAll(Arrays.stream(arr2).boxed().collect(Collectors.toList()));
//we need a set to check if the element is duplicate or not
Set<Integer> set = new HashSet();
List<Integer> result = new ArrayList<>(list);
//loop throw your list, and check if you can add this element to the set
// or not, if not this mean it is duplicate you have to remove it from your list
list.stream().filter((i) -> (!set.add(i))).forEachOrdered((i) -> {
result.removeAll(Collections.singleton(i));
});
System.out.println(result);
}
Output
[1, 2, 3, 4, 7, 8]
To solve this problem, i based to this posts : Identify duplicates in a List

And here another streaming (Java 8) solution. Using streams one should avoid modifying stream outside variables.
The idea here is to union the lists and then to count the occurance of each item. All items with count 1 are only in one list. Those are collected to the result list.
//using here Integer instead of atomic int, simplifies the union.
Integer[] arr1 = new Integer[]{1, 2, 3, 4, 5, 6};
Integer[] arr2 = new Integer[]{5, 6, 7, 8};
List<Integer> list = new ArrayList<>();
list.addAll(new HashSet<>(Arrays.asList(arr1)));
list.addAll(new HashSet<>(Arrays.asList(arr2)));
System.out.println(
list.stream()
.collect(groupingBy(identity(), counting()))
.entrySet().stream()
.filter(i -> i.getValue() == 1)
.map(i -> i.getKey())
.collect(toList())
);
EDIT:
Changed this answer to adress multiples within one list problem.

You have to add a second for-loop to check if elements of arr2 are in arr1 cause you are only checking if elements of arr1 are in arr2
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr1[i]);
}
else{
contains = false;
}
}
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr1.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if(!contains){
list.add(arr2[i]);
}
else{
contains = false;
}
}
System.out.println(list);
}

A more optimized way would be using list iterators.
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
List<Integer> list1 = IntStream.of(arr1).boxed().collect(Collectors.toList());
List<Integer> list2 = IntStream.of(arr2).boxed().collect(Collectors.toList());
Iterator list1Iter = list1.iterator();
boolean contains = false;
while(list1Iter.hasNext()) {
int val1 = (int)list1Iter.next();
Iterator list2Iter = list2.iterator();
while(list2Iter.hasNext()) {
int val2 = (int)list2Iter.next();
if( val1 == val2) {
// remove duplicate
list1Iter.remove();
list2Iter.remove();
}
}
}
list1.addAll(list2);
for( Object val : list1) {
System.out.println(val);
}
If you are using Java 8, you can do the following :
List resultList = list1.stream().filter(nbr -> !list2.contains(nbr)).collect(Collectors.toList());
resultList.addAll(list2.stream().filter(nbr -> !list1.contains(nbr)).collect(Collectors.toList()));

import java.util.Scanner;
import java.io.*;
public class CandidateCode{
static int count =0;
public static void main(String args[])
{
int n,n1;
Scanner sc=new Scanner(System.in);
System.out.println("Enter no. of elements for first array");
n=sc.nextInt();
int arr[]=new int[n];
System.out.println("Enter the elements of first array");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
}
System.out.println("Enter no. of elements for second array");
n1=sc.nextInt();
int arr1[]=new int[n1];
System.out.println("Enter the elements of second array");
for(int i=0;i<n1;i++)
{
arr1[i]=sc.nextInt();
}
unique_ele(arr,arr1);
unique_ele(arr1,arr);
System.out.println("The number of unique elements are");
System.out.println(count);
}
public static int unique_ele(int arr2[],int arr3[])
{
boolean contains = false;
for(int i=0;i<arr2.length;i++)
{
for(int j=0;j<arr3.length;j++)
{
if (arr2[i] == arr3[j]) {
contains = true;
break;
}
}
if(!contains){
count++;
}
else{
contains = false;
}
}
return count;
}
}

public static ArrayList<Integer> findUniqueAmongLists(ArrayList<Integer> a, ArrayList<Integer> b){
ArrayList<Integer> uniqueArr = new ArrayList<>();
ArrayList<Integer> duplicateArr = new ArrayList<>();
for(int i=0; i< a.size(); i++){
if(!duplicateArr.contains(a.get(i))){
uniqueArr.add(a.get(i));
duplicateArr.add(a.get(i));
}
else{
uniqueArr.remove(a.get(i));
}
}
for(int j=0; j< b.size(); j++){
if(!duplicateArr.contains(b.get(j))){
uniqueArr.add(b.get(j));
duplicateArr.add(b.get(j));
}
else{
uniqueArr.remove(b.get(j));
}
}
return uniqueArr;
}

int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
boolean contains = false;
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
contains = true;
break;
}
}
if (!contains) {
list.add(arr1[i]);
} else {
contains = false;
}
}
for (int j = 0; j < arr2.length; j++) {
for (int k = 0; k < arr1.length; k++) {
if (arr2[j] == arr1[k]) {
contains = true;
break;
}
}
if (!contains) {
list.add(arr2[j]);
} else {
contains = false;
}
}
System.out.println(list);
}

public class UniqueElementFrom2array {
public static void main(String[] args)
{
int[] a= {1,2,3,4,5,6,7};
int[] b= {1,2,3,8,9,4,10,11,12};
int[] c=new int[a.length+b.length];
int len1=a.length;
int len2=b.length;
System.arraycopy(a, 0, c, 0, len1);
System.arraycopy(b, 0, c, len1,len2);
Arrays.sort(c);
System.out.println(Arrays.toString(c));
Set s=new HashSet();
for(int i=0;i<c.length;i++)
{
if(!s.contains(c[i]))
{
s.add(c[i]);
System.out.print(c[i] + " ");
}
}
}
}

A complete code using TreeSet in java.
import java.util.*;
import java.util.Scanner;
public class Main
{
public static void uniqElements(int arr1[], int arr2[],int n){
TreeSet<Integer> set1 = new TreeSet<>();
TreeSet<Integer> set2 = new TreeSet<>();
TreeSet<Integer> set3 = new TreeSet<>();
TreeSet<Integer> set4 = new TreeSet<>();
for (int i:arr1) {
set1.add(i);
set3.add(i);
}
for (int i:arr2) {
set2.add(i);
set4.add(i);
}
set3.addAll(set4);
set1.retainAll(set2);
set3.removeAll(set1);
System.out.println(set3);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr1 = new int[n];
int[] arr2 = new int[n];
for(int i =0;i<n;i++){
arr1[i]=sc.nextInt();
}
for(int i =0;i<n;i++){
arr2[i]=sc.nextInt();
}
uniqElements(arr1,arr2,n);
}
}

public static void main(String[] args) {
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
System.out.println(Stream.concat(Arrays.stream(arr1).boxed(), Arrays.stream(arr2).boxed()).distinct().collect(Collectors.toList()));
}

Merge all array.
Remove elements at merged array that contains second array value.
import java.util.TreeSet;
public class ArrayUnique {
public static void getUniqueElements(int arr1[], int arr2[]){
// Merge all array with treeset
// it will remove duplicate element
TreeSet<Integer> all= new TreeSet<>();
TreeSet<Integer> secondArray= new TreeSet<>();
for(int i:arr1){
all.add(i);
}
for(int i:arr2){
all.add(i);
secondArray.add(i);
}
//Delete element that contains secondArray value
all.removeAll(secondArray);
//print to console
System.out.println(all);
}
public static void main(String[] args) {
int[] arr1 = {1,2,3,4};
int[] arr2 = {1,3,5,10,16};
getUniqueElements(arr1,arr2);
//Result: [2,4]
}
}

Try this:
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
int[] arr2 = new int[] { 5, 6, 7, 8 };
List<Integer> list = Stream.concat(Arrays.stream(arr1).boxed(), Arrays.stream(arr2).boxed()).distinct().collect(Collectors.toList());
System.out.println(list);
}
hope this will resolve issue.

This will give you the unique values from two arrays;
public static String[] uniqueArr(String[] names1, String[]
names2)
{
Set<String> set = new HashSet<>(new
LinkedList<>(Stream.of(names1,
names2).flatMap(Stream::of).collect(Collectors.toList())));
String[] arr = new String[set.size()];
set.toArray(arr);
return arr;
}

Java sort 4 arrays into 1 array

I need to efficiently sort through 4 arrays and return 2 results.
The first result will contain all numbers that exist in the arrays.
The second result will contain, all occurrences of each number in the result
int[] a = [1,2,3,4,5];
int[] b = [1,2,3,4,5,6];
int[] c = [1,3,7];
int[] d = [2,3,4,8,9,10];
int[] result1 = [1,2,3,4,5,6,7,8,9,10];
int[] result2 = [1,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,7,8,9,10];

Step 1: Combine all the arrays
Step 2: Sort arrays using Arrays.sort(array);
Step 3: Remove the duplicates.
int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5,6};
int[] c = {1,3,7};
int[] d = {2,3,4,8,9,10};
int[] resultArray1 = new int[a.length+b.length+c.length+d.length];
int arrayIndex = 0;
for (int i=0; i< a.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = a[i];
}
for (int i=0; i< b.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = b[i];
}
for (int i=0; i< c.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = c[i];
}
for (int i=0; i< d.length ; i++, arrayIndex++ )
{
resultArray1[arrayIndex] = d[i];
}
// Sorting Arrays
System.out.println("Array before Sort"+Arrays.toString(resultArray1));
Arrays.sort(resultArray1);
System.out.println("Array after Sort"+Arrays.toString(resultArray1));
// Removing duplicates
Set<String> set = new HashSet<String>();
for (int i = 0; i < resultArray1.length; i++) {
set.add(""+resultArray1[i]); // To convert to string
}
String[] uniqueStringArray = set.toArray(new String[set.size()]); ;
int [] uniqueIntArray = new int [uniqueStringArray.length];
// Converting string array to int array
for(int i=0;i<uniqueStringArray.length;i++)
{
uniqueIntArray[i]= Integer.parseInt(uniqueStringArray[i]);
}
Arrays.sort(uniqueIntArray);
System.out.println("Unique Array after Sort"+Arrays.toString(uniqueIntArray));
Output:
Array before Sort[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 1, 3, 7, 2, 3, 4, 8, 9, 10]
Array after Sort[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 8, 9, 10]
Unique Array after Sort[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Combine all 4 arrays in 1 array
sort Array
Remove Dublicate from array
import java.util.Vector;
class sort
{
public static void main(String args[])
{
int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5,6};
int[] c = {1,3,7};
int[] d = {2,3,4,8,9,10};
int[] s = combine(a,b,c,d); //concate array using concate function
int[] sort = sort(s);//sort array using sort function
//SORTING ARRAY
System.out.print("ARRAY AFTER SORT ");
System.out.print("[");
for(int i=0;i<sort.length;i++)
{
if(i==sort.length-1)
System.out.print(sort[i]);
else
System.out.print(sort[i]+",");
}
System.out.println("]\n");
//REMOVE DUPLICATE
int[] removedups=removedups(sort);// Remove Duplicate item from array using removedups
System.out.print("ARRAY REMOVE DUPLICATE ");
System.out.print("[");
for(int i=0;i<removedups.length;i++)
{
if(i==removedups.length-1)
System.out.print(removedups[i]);
else
System.out.print(removedups[i]+",");
}
System.out.print("]");
}
public static int[] combine(int a[],int b[],int c[],int d[])//combine array
{
int sort []=new int[a.length+b.length+c.length+d.length];
int j=0;
for(int i=0;i<a.length;i++)
{
sort[j]=a[i];
j++;
}
for(int i=0;i<b.length;i++)
{
sort[j]=b[i];
j++;
}
for(int i=0;i<c.length;i++)
{
sort[j]=c[i];
j++;
}
for(int i=0;i<d.length;i++)
{
sort[j]=d[i];
j++;
}
return sort;
}
public static int[] sort(int s[]) // sort array
{
int temp;
for(int i=0;i<s.length;i++)
{
for(int j=i+1;j<s.length-1;j++)
{
if(s[i]>s[j])
{
temp=s[i];
s[i]=s[j];
s[j]=temp;
}
}
}
return s;
}
public static int[] removedups(int s[])//remove dups from sorted array
{
Vector array=new Vector();
int l=0;
for(int i=0;i<s.length-1;i++)
{
if(s[i]!=s[i+1])
{
array.add(s[i]);
l++;
}
}
int[] temp=new int[array.size()];
for(int j=0;j<temp.length;j++)
{
temp[j]=Integer.parseInt(""+array.get(j));
}
return temp ;
}
}//end the program

Simpliest way is use sort and HashSet
public class SortClass {
public static void main(String[] args) {
//Define imput data
int[] a = {1, 2, 3, 4, 5};
int[] b = {1, 2, 3, 4, 5, 6};
int[] c = {1, 3, 7};
int[] d = {2, 3, 4, 8, 9, 10};
//Actual algorithm
List<Integer> all = new ArrayList<Integer>();
all.addAll(toList(a));
all.addAll(toList(b));
all.addAll(toList(c));
all.addAll(toList(d));
Collections.sort(all);
TreeSet<Integer> set = new TreeSet<Integer>();
set.addAll(all);
int[] sorted = toIntArray(all);
int[] sortedUniq = toIntArray(set);
//Output result
System.out.println("Sorted: " + Arrays.toString(sorted));
System.out.println("Sorted uniq: " + Arrays.toString(sortedUniq));
}
// We need pair of method to convert between `int[]` and `Collection<Integer>`
private static int[] toIntArray(Collection<Integer> all) {
int[] ints = new int[all.size()];
int i =0;
for (int val : all) {
ints[i] = val;
i++;
}
return ints;
}
private static Collection<? extends Integer> toList(int[] ints) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i : ints) {
list.add(i);
}
return list;
}
}
But if performance is critical we can utilize the fact that input arrays already sorted and us merge sort:
public class SortClass {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5};
int[] b = {1, 2, 3, 4, 5, 6};
int[] c = {1, 3, 7};
int[] d = {2, 3, 4, 8, 9, 10};
//Prepare data structure
List<ArrayTail> all = new ArrayList<ArrayTail>();
add(all, new ArrayTail(a));
add(all, new ArrayTail(b));
add(all, new ArrayTail(c));
add(all, new ArrayTail(d));
int[] sorted = sort(all);
int[] sortedUniq = getUniq(sorted);
System.out.println("Sorted: " + Arrays.toString(sorted));
System.out.println("Sorted uniq: " + Arrays.toString(sortedUniq));
}
private static int[] getUniq(int[] sorted) {
Collection<Integer> result = new ArrayList<Integer>();
int current = sorted[0];
result.add(current);
for (int i : sorted){
if(i != current){
current = i;
result.add(i);
}
}
return toIntArray(result);
}
private static int[] sort(List<ArrayTail> all) {
int totalLength = 0;
for (ArrayTail tail : all){
totalLength+=tail.size();
}
int[] result = new int[totalLength];
int pos = 0;
while(!all.isEmpty()){
//Take smallest value from smallest array
ArrayTail smallest = all.get(0);
result[pos] = smallest.take();
pos++;
// remove array if no more elements in it
if(smallest.size() ==0){
all.remove(0);
} else {
// ensure that first element steel smallest
sortFirstElement(all);
}
}
return result;
}
// This is actually on step of bubble sort, but it
// works because all other list except may be first already sorted
private static void sortFirstElement(List<ArrayTail> all) {
for (int i = 0; i < all.size()-1; i++) {
if(all.get(i).get() > all.get(i+1).get()){
Collections.swap(all, i, i + 1);
} else {
break;
}
}
}
private static void add(List<ArrayTail> all, ArrayTail arrayTail) {
// all sorted here
all.add(0, arrayTail);
sortFirstElement(all);
// all sorted here, again
}
private static int[] toIntArray(Collection<Integer> all) {
int[] ints = new int[all.size()];
int i =0;
for (int val : all) {
ints[i] = val;
i++;
}
return ints;
}
// Simpl data structure representing tail of array
private static class ArrayTail {
private final int[] arr;
private int pos;
public ArrayTail(int[] arr) {
this.arr = arr;
this.pos = 0;
}
public int size() {
return arr.length - pos;
}
public int take() {
return arr[pos++];
}
public int get() {
return arr[pos];
}
}
}
As you can see code become more complex but possible work faster.
PS: fun thing is that bubble sort can be used in real life :)

TRY Using merge sort algorithm. wikipedia page here

For result 1, dump the contents of your 4 lists into a TreeSet. This will sort and remove duplicates from the set at the same time. Then get the array of the set.
For result 2, use array copy to copy all the numbers into 1 array and then sort that array using Arrays.sort(...). There is no need to try to merge them on your own due to the nature of the sorting algorithm which is O(nlog(n)). Quadrupling the size results in a multiplying factor of only 2.

Method that creates new array only from the even numbers in Java

I am trying to create method that creates new array only from the even numbers from another array. However, I do not understand why I have the right length (only with the number of the even numbers) of my output array, but I have 0s instead of the actual numbers.
I know that the problem is simple, but right now I am stuck with it.
import java.util.*;
public class test{
public static int [] myMethod(int []arr){
int [] temp;
int howManyEven = 0;
for(int i=0;i<arr.length;i++){
if(arr[i]%2==0){
howManyEven++;
}
}
temp = new int [howManyEven];
int evenNum = 0;
for(int i=0;i<temp.length;i++){
boolean even = false;
for(int j=0;j<arr.length;j++){
if(arr[j]%2==0){
even = true;
evenNum = arr[j];
}
}
if(!even){
temp[i]=evenNum;
}
}
return temp;
}
public static void main (String[]args){
int [] myArray = {5,5,8,9,7,4,4,2,3};
System.out.println(Arrays.toString(myMethod(myArray)));
}
}

In the second part of your myMethod, where there is nested for loop, your outer loop should iterate over arr. It can be simplified to below
temp = new int [howManyEven];
int j = 0;
for(int i=0;i<arr.length;i++){
if(arr[i]%2 == 0) {
temp[j++] = arr[i];
}
}
Better you can use java collections and finish the work in single loop
public static Integer[] myMethod(int []arr){ //notice the return type is Integer[] instead of int[]
List<Integer> evens = new ArrayList<Integer>();
for(int a : arr) {
if(a%2 == 0) {
evens.add(a);
}
}
return evens.toArray(new Integer[evens.size()]);
}

Look again at this:
if(!even){
temp[i]=evenNum;
}
I think you will notice yourself what's wrong.

Instead of processing the information twice for even numbers, you can create a List of integers which are 'even' and return that, or convert into primitive int[] and return that.
public static int[] myMethod(int[] arr) {
List<Integer> even = new ArrayList<Integer>();
for (int i = 0; i < arr.length; i++) {
if(arr[i]%2==0){
even.add(arr[i]);
}
}
int []result = new int[even.toArray().length];
Iterator it = even.iterator();
int count=0;
while(it.hasNext()){
result[count++]=(int)it.next();
}
return result;
}
public static void main(String[] args) {
int[] myArray = {5, 5, 8, 9, 7, 4, 4, 2, 3};
System.out.println(Arrays.toString(myMethod(myArray)));
}
output
run:
[8, 4, 4, 2]
BUILD SUCCESSFUL (total time: 0 seconds)

The easiest way would be myMethod should create a temparory list which collects the even numbers from the input array and then convert it to an output array containing only the even elements which should be returned to the caller
Working Example
public static void main(String... str) {
// results array has only even numbers
Integer[] results = myMethod(new int[]{5, 5, 8, 9, 7, 4, 4, 2, 3});
for(int i=0;i<results.length;i++)
System.out.println(results[i]); // print each even number
}
static Integer[] myMethod(int[] inputArray) {
List<Integer> temp = new ArrayList<Integer>();
for (int i = 0; i < inputArray.length; i++) {
if (inputArray[i] % 2 == 0) {
temp.add(inputArray[i]);
}
}
return temp.toArray(new Integer[5]);
}
Hope this code clarifies you well.