Develop Reference

Combing two arrays in ascending order with unknown values inside the array

I have managed to create both arrays, however I can't figure out how to combine the two arrays. Every tutorial I see merges them as such:
int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};
// Output: 3, 4, 5, 6, 8, 9
What I need is something that would output: 3, 3, 3, 4, 5, 5, 6, 6, 8, 9
Here is the code I have written so far:
import java.util.Scanner;
public class Merger {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int[] arr1 = new int[10000];
int[] arr2 = new int[10000];
int[] merged = new int[20000];
int a1 = 0;
int a2 = 0;
int size = -1;
int size2 = -1;
int sizecheck = 0;
int size2check = 0;
System.out
.println("Enter the values for the first array, up to 10,000 values, enter a negative number to quit");
for (int i = 0; i < arr1.length; i++) {
arr1[i] = scan.nextInt();
merged[i] = arr1[i];
if (arr1[i] <= 0) {
break;
}
if (size <= arr1[i]) {
size = arr1[i];
sizecheck++;
}
a1++;
}
System.out
.println("Enter the values for the second array, up to 10,000 values, enter a negative number to quit");
for (int i = 0; i < arr2.length; i++) {
arr2[i] = scan.nextInt();
merged[i + a1] = arr2[i];
if (arr2[i] <= 0) {
break;
}
if (size2 <= arr2[i]) {
size2 = arr2[i];
size2check++;
}
a2++;
}
System.out.println("First Array: ");
for (int i = 0; i < a1; i++) {
System.out.print(" " + arr1[i]);
}
System.out.println("\nSecond Array: ");
for (int i = 0; i < a2; i++) {
System.out.print(" " + arr2[i]);
}
}
}
This prints both arrays out, however does not combine and sort the two.

Here's the code ! There may be a faster/easier way to do it but this one works as long as the 2 arrays are sorted
public static void main(String[] args) {
int[] a1 = {1, 2, 3, 5};
int[] a2 = {1, 3, 4, 4, 4, 5};
int[] a3 = merge(a1, a2);
for (int i : a3) {
System.out.print(i);
}
}
public static int[] merge(int[] a1, int[] a2) {
int[] a3 = new int[a1.length + a2.length];
int indexA1 = 0;
int indexA2 = 0;
for (int i = 0; i < a3.length; i++) {
int n;
if (indexA1 == a1.length && indexA2 < a2.length) {
n = a2[indexA2];
indexA2++;
} else if (indexA1 < a1.length && indexA2 == a2.length) {
n = a1[indexA1];
indexA1++;
} else {
if (a1[indexA1] < a2[indexA2]) {
n = a1[indexA1];
indexA1++;
} else {
n = a2[indexA2];
indexA2++;
}
}
a3[i] = n;
}
return a3;
}

I assume that you are not yet familiar with Streams, but I would like to give you an example of what you can do with them.
Add import
import java.util.stream.IntStream;
Add this at the end of your main method
System.out.println("");
IntStream arr1Stream = IntStream.of(arr1).limit(a1); //creates an InStream with the first a1 values of arr1
IntStream arr2Stream = IntStream.of(arr2).limit(a2);
int[] both = IntStream.concat(arr1Stream, arr2Stream).sorted().toArray(); //combines the two streams, sorts them an converts them to an Array
System.out.println(Arrays.toString(both)); //easy way to print an array

The easiest way is to use a Stream.
int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};
Stream both arrays.
flatMap them to a single IntStream
sort them
convert to an array
int [] combined = Stream.of(arr1,arr2)
.flatMapToInt(Arrays::stream)
.sorted()
.toArray();
System.out.println(Arrays.toString(combined));
Prints
[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]
A non-stream approach can be done as follows:
// increase arr1 to make room for arr2
int oldLen = arr1.length;
arr1 = Arrays.copyOf(arr1, arr1.length+arr2.length);
// copy arr2 starting at 0, to arr1 starting at the old length
// positon of arr1 for a length of arr2
System.arraycopy(arr2, 0, arr1, oldLen, arr2.length);
// sort and print
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
Prints
[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]
Although your question, as asked, said nothing about merging sorted arrays, here is how you would do it.
The algorithm is simple. Just iterate thru each array and compare current values.
if arr1[i] <= arr2[k], copy arr1[i] to result, advance i by 1
else copy arr2[k] to result, advance k by 1.
in all cases the index to result, r, is advanced by 1
public int[] merge(int[] arr1, int[] arr2) {
// result array
int[] result = new int[arr1.length + arr2.length];
int r = 0;
int k = 0;
int i = 0;
// Iterate thru the arrays, copying the lowest or equal value
// to the target array. This process will cease when one of the arrays
// has been fully processed.
for (; i < arr1.length && k < arr2.length; ) {
for (; k < arr2.length && i < arr1.length;) {
if (arr1[i] <= arr2[k]) {
result[r++] = arr1[i++];
}else {
result[r++] = arr2[k++];
}
}
}
Having reached this far in the algorithm, one of the arrays must have been completely processed. So try and copy both. For the empty array, the while loop basically acts like an if statement.
while (i < arr1.length) {
result[r++] = arr1[i++];
}
while (k < arr2.length) {
result[r++] = arr2[k++];
}
// return the result
return result;
}

public class Merger {
public static void main(String[] args) {
int[] arr1 = { 3, 3, 5, 6, 8, 9 };
int[] arr2 = { 3, 4, 5, 6 };
int[] res = merge(arr1, arr2);
System.out.println(Arrays.toString(res));
}
public static int[] merge(int[] arr1, int[] arr2) {
int[] res = new int[arr1.length + arr2.length];
for (int i = 0, a1 = 0, a2 = 0; i < res.length; i++) {
if (a1 == arr1.length)
res[i] = arr2[a2++];
else if (a2 == arr2.length)
res[i] = arr1[a1++];
else
res[i] = arr1[a1] <= arr2[a2] ? arr1[a1++] : arr2[a2++];
}
return res;
}
}

A simple solution can be written using the classes, Arrays and System.
Steps:
Copy elements of arr1[] into a new array (say, output[]) whose size is the sum of the sizes of the given arrays.
Copy the elements of arr2[], after the element of arr1[], into output[]
Sort output[]
Demo:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr1 = { 3, 3, 5, 6, 8, 9 };
int[] arr2 = { 3, 4, 5, 6 };
// Copy elements of arr1[] into a new array whose size is the sum of the sizes
// of the given arrays
int[] output = Arrays.copyOf(arr1, arr1.length + arr2.length);
// Copy the elements of arr2[], after the element of arr1[], into output[]
System.arraycopy(arr2.clone(), 0, output, arr1.length, arr2.length);
// Sort output[]
Arrays.sort(output);
// Display output[]
System.out.println(Arrays.toString(output));
}
}
Output:
[3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

You can use System.arraycopy method for this purpose:
int[] arr1 = {3, 3, 5, 6, 8, 9};
int[] arr2 = {3, 4, 5, 6};
// create a new array of total length
int[] arr3 = new int[arr1.length + arr2.length];
// copy first array to the beginning of the total array
System.arraycopy(arr1, 0, arr3, 0, arr1.length);
// copy second array to the end of the total array
System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);
// sort the total array
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3));
// [3, 3, 3, 4, 5, 5, 6, 6, 8, 9]

To Find Leaders in an array

Write a program to print all the LEADERS in the array. An element is leader if it is greater than all the elements to its right side. And the rightmost element is always a leader. For example int the array {16, 17, 4, 3, 5, 2}, leaders are 17, 5 and 2.
Let the input array be arr[] and size of the array be size.
o/p what i am getting is 2 5 17
Note: i want o/p in reverse order , also one below other(line break).
class LeadersInArray
{
/* Java Function to print leaders in an array */
void printLeaders(int arr[], int size)
{
int max_from_right = arr[size-1];
/* Rightmost element is always leader */
System.out.print(max_from_right + " ");
for (int i = size-2; i >= 0; i--)
{
if (max_from_right < arr[i])
{
max_from_right = arr[i];
System.out.print(max_from_right + " ");
}
}
}
public static void main(String[] args)
{
LeadersInArray lead = new LeadersInArray();
int arr[] = new int[]{16, 17, 4, 3, 5, 2};
int n = arr.length;
lead.printLeaders(arr, n);
}
}
Expected output:
17
5
2

Intead of printing those within the loop, add those to a list, and then print those separately.
Following are the changes in your code.
class LeadersInArray {
List<Integer> printLeaders(int[] arr, int size) {
List<Integer> list = new ArrayList<>();
int max_from_right = arr[size - 1];
list.add(max_from_right);
for (int i = size - 1; i >= 0; i--) {
if (max_from_right < arr[i]) {
max_from_right = arr[i];
list.add(max_from_right);
}
}
return list;
}
public static void main(String[] args) {
LeadersInArray lead = new LeadersInArray();
int arr[] = new int[]{16, 17, 4, 3, 5, 2};
List<Integer> integers = lead.printLeaders(arr, arr.length);
for(int i = integers.size()-1; i>=0 ;i--){
System.out.println(integers.get(i));
}
}
}

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;
}

retain specific elements in an array from an array that are in another array

let's say I have two array;
Integer[] array= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
Integer[] array2= { 12, 2 ,3, 2, 200, 5 };
Im trying to make a method that return an array with all the element removed except those who are in also present in array2, so the output of this method should be
{2 ,3, 5, 200, 5, 5 }
I dont want to use another data structure and i have no idea how to code what im trying to do, im not sure how i can determinate the resulting array length
thanks

Here is a solution which uses only arrays and no other data structure at all. The retainAll method will return an array with some nulls in it. You can make some code to use that array and create an array with no nulls. Its really easy.
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Integer[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
Integer[] array2 = { 12, 2, 3, 2, 200, 5 };
Integer[] res = retainAll(array, array2);
String str = Arrays.toString(res);
System.out.println(str);
res = removeArrayDuplicates(res);
str = Arrays.toString(res);
System.out.println(str);
}
public static Integer[] retainAll(Integer[] a, Integer[] b) {
int ln1 = a.length;
int ln2 = b.length;
Integer[] res = new Integer[(ln1 < ln2) ? ln1 : ln2];
Integer[] small = (ln1 < ln2) ? a : b;
Integer[] big = (ln1 < ln2) ? b : a;
boolean found = false;
for (int i = 0; i < small.length; i++) {
found = arrayContains(big, small[i]);
if (found == true) {
res[i] = small[i];
}
}
return res;
}
public static Integer[] removeArrayDuplicates(Integer[] a) {
int len = a.length;
int dups = 0;
boolean noNulls = false;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
noNulls = a[i] != null && a[j] != null;
if (noNulls && a[i].equals(a[j])) {
a[j] = null;
dups++;
}
}
}
return a;
}
public static boolean arrayContains(Object[] a, Integer b) {
boolean contains = false;
for (Object c : a) {
if (c != null && c.equals(b)) {
contains = true;
break;
}
}
return contains;
}
}

If I understand your question, you could begin by creating a contains(Integer[], Integer) method. Iterate the array and return true if the array contains the value.
private static boolean contains(Integer[] a, Integer v) {
for (Integer t : a) {
if (t.equals(v)) {
return true;
}
}
return false;
}
Then you can leverage that to iterate your arrays twice. Once to perform a count, and the second time to populate a newly created array with the count number of elements. Something like,
public static Integer[] retainAll(Integer[] a, Integer[] b) {
int count = 0;
for (Integer val : a) {
if (contains(b, val)) {
count++;
}
}
Integer[] out = new Integer[count];
count = 0;
for (Integer val : a) {
if (contains(b, val)) {
out[count++] = val;
}
}
return out;
}
Then to test it,
public static void main(String[] args) {
Integer[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
Integer[] array2 = { 12, 2, 3, 2, 200, 5 };
System.out.println(Arrays.toString(retainAll(array, array2)));
}
Output is the requested
[2, 3, 5, 200, 5, 5]
Of course, you could also use Arrays.asList(T...) and retainAll() like
public static Integer[] retainAll(Integer[] a, Integer[] b) {
List<Integer> al = new ArrayList<>(Arrays.asList(a));
al.retainAll(Arrays.asList(b));
return al.toArray(new Integer[al.size()]);
}

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.