We Keep Coding

add data after every 2nd element in an array

I want to add object/data in an array after every 2nd element ....just for making more clear I am going to use a simple example
I have arrayList of :
List<Object> list = new ArrayList<>();
list.add("messi");
list.add("ronaldo");
list.add("rooney");
list.add("pogba");
list.add("hazard");
print(list);
//output : [messi, ronaldo, rooney, pogba,hazard]
What I want is:
//[messi, ronaldo, DATA, rooney, pogba, DATA, hazard]
how I can achieve this.
Adding data in an array after every 2nd element.

By maintaining a counter.
public class Main {
public static void main(String[] args) {
List<Object> list = new ArrayList<>();
list.add("messi");
list.add("ronaldo");
list.add("rooney");
list.add("pogba");
list.add("hazard");
int counter = 0 ;
List<Object> data = new ArrayList<>();
for(Object obj : list){
data.add(obj);
counter = counter + 1;
if(counter%2 == 0)
data.add("DATA");
}
for(Object obj : data)
System.out.println(obj);
}
}

So, you can do is create a new list to store the old data with new object:
List<Object> list = new ArrayList<>();
List<Object> newlist = new ArrayList<>();
list.add("messi");
list.add("ronaldo");
list.add("rooney");
list.add("pogba");
list.add("hazard");
for(int i = 0; i < list.size(); i++) {
if(i%2==0) {
// Add DATA after 2 items
newlist.add(data);
}
newlist.add(list.get(i));
}
Please someone format since I'm writing from my phone.

class sample {
public static void main(String[] args) {
List<Object> list = new ArrayList<>();
sample.addList("messi", list);
sample.addList("ronaldo", list);
sample.addList("rooney", list);
sample.addList("pogba", list);
sample.addList("hazard", list);
System.out.println(list);
}
private static void addList(String value, List<Object> objects) {
if (!objects.isEmpty() && (objects.size() % 3 == 2)) {
objects.add("Data");
}
objects.add(value);
}
}
You can create one utility method as mentioned above.
For every time before adding element check that if list.size() % 3 == 2 then add extra element.
This will help you.

Look at the desired output and the indexes of the inserted DATA values:
[messi, ronaldo, DATA, rooney, pogba, DATA, hazard]
0 1 2 3 4 5 6
The DATA values go in index 2, 5, 8, 11, ...
Which means it's a simple for loop calling add(int index, E element):
List<Object> list = new ArrayList<>();
list.add("messi");
list.add("ronaldo");
list.add("rooney");
list.add("pogba");
list.add("hazard");
System.out.println(list);
for (int i = 2; i < list.size(); i += 3) {
list.add(i, "DATA");
}
System.out.println(list);
Output
[messi, ronaldo, rooney, pogba, hazard]
[messi, ronaldo, DATA, rooney, pogba, DATA, hazard]

how can I slice my list in chunks before I call a method on each of the chunk?

I have a List of objects in Java:
ArrayList<myObj> objs = generateObjs();
and I have a method responsible for sending the objects further, this method takes the list above as an argument:
sendObjectsFurther(objs)
I want to split the list objs so that I can send further objects in a group of five elements.
What is the best approach to do it?
I thought about implementing something like this:
public void sendSliced(List objs) {
ArrayList<myObj> tempList = new ArrayList()<>;
for (int i = 0; i < objs.size(); i++) {
tempList.add(objs.get(i));
if (i % 5 == 0) {
sendObjectsFurther(tempList);
tempList.clear();
}
}
}
but I think it won't cover all edge cases, could you help me with that? Thanks!

You can use Java 8 Stream API for this.
List<myObj> objs = generateObjs();
int chunkSize = 5;
AtomicInteger counter = new AtomicInteger();
Collection<List<myObj>> result = objs.stream()
.collect(Collectors.groupingBy(it -> counter.getAndIncrement() / chunkSize))
.values();
for (myObj chunk: result){
sendObjectsFurther(tempList);
}
Also, class names should start with an upper case.

You could use guava Lists.partition which will split into sub lists.
Example :
for (List<String> slice : Lists.partition(bigList, 5)) {
send(slice);
}
The relevant javadoc link https://guava.dev/releases/23.0/api/docs/com/google/common/collect/Lists.html#partition-java.util.List-int-

You can add one line to your code
public void sendSliced(List objs) {
ArrayList<myObj> tempList = new ArrayList()<>;
for (int i = 0; i < objs.size(); i++) {
tempList.add(objs.get(i));
if (i % 5 == 0) {
sendObjectsFurther(tempList);
tempList.clear();
}
}
sendObjectsFurther(tempList);
}
Which will add remaining items.

Please check the below code, here each sublist will represents a chunk with 5 elements, So suppose I have total of 8 elements in my obj list, so first chunk will have 5 and next chunk will have 3.
public static void main(String[] args) throws IOException {
List<Employee> objs = new ArrayList<>();
objs.add(new Employee(1));
objs.add(new Employee(2));
objs.add(new Employee(3));
objs.add(new Employee(4));
objs.add(new Employee(5));
objs.add(new Employee(6));
objs.add(new Employee(7));
objs.add(new Employee(8));
sendSliced(objs);
}
private static void sendSliced(List<Employee> objs) {
int chunkSize = 5;
final AtomicInteger counter = new AtomicInteger();
Collection<List<Employee>> subLists = objs.stream()
.collect(Collectors.groupingBy(it -> counter.getAndIncrement() / chunkSize))
.values();
subLists.stream().forEach( sublist -> System.out.print(sublist));
subLists.stream().forEach( sublist -> sendObjectsFurther(sublist));
}
}
class Employee {
private int id;
Employee(int id) {
this.id = id;
}
}
Ouput Will be something like:
index = 0
[com.practice.stackoverflow.Employee#77459877, com.practice.stackoverflow.Employee#5b2133b1, com.practice.stackoverflow.Employee#72ea2f77, com.practice.stackoverflow.Employee#33c7353a, com.practice.stackoverflow.Employee#681a9515]
index=1
[com.practice.stackoverflow.Employee#3af49f1c, com.practice.stackoverflow.Employee#19469ea2, com.practice.stackoverflow.Employee#13221655]

How to retrieve element from ArrayList containing long array

How to retrieve element from ArrayList<long[]>?
I wrote like this:
ArrayList<long []> dp=new ArrayList<>();
//m is no of rows in Arraylist
for(int i=0;i<m;i++){
dp.add(new long[n]); //n is length of each long array
//so I created array of m row n column
}
Now how to get each element?

every element in that list is an array... so you need to carefully add those by:
using anonymous arrays new long[] { 1L, 2L, 3L }
or especifying the size using the new keyword new long[5]
public static void main(String[] args) throws Exception {
ArrayList<long[]> dp = new ArrayList<>();
// add 3 arrays
for (int i = 0; i < 3; i++) {
dp.add(new long[] { 1L, 2L, 3L });
}
// add a new array of size 5
dp.add(new long[5]); //all are by defaul 0
// get the info from array
for (long[] ls : dp) {
for (long l : ls) {
System.out.println("long:" + l);
}
System.out.println("next element in the list");
}
}

You get the arrays the same way you get anything from an ArrayList. For example, to get the tenth long[] stored in the ArrayList, you'd use the get method:
long[] tenthArray = dp.get(9);

You could also have an ArrayList of objetcs that contain an array of longs inside. But the problem so far with your code is that you are not putting any values in each long array.
public class NewClass {
private static class MyObject {
private long []v;
public MyObject(int n) {
v = new long[n];
}
#Override
public String toString() {
String x = "";
for (int i = 0; i < v.length; i++) {
x += v[i] + " ";
}
return x;
}
}
public static void main(String[] args) {
ArrayList<MyObject> dp = new ArrayList();
int m = 3;
int n = 5;
for (int i = 0; i < m; i++) {
dp.add(new MyObject(n));
}
for (MyObject ls : dp) {
System.out.println(ls);
}
}
}

random elements from a list DURING the addition

There are 20 names in my code.
my function has 2 options to add elements to a list I've:
1.
Inserting all the 20 names to the list:
public void addNames() {
list.add("name1");
list.add("name2");
...
list.add("name20");
}
2.
Adding only 5 random names(from the 20 names) to the list. For doing it, I thought about 2 ways. What's the best way to random 5 names from the 20? maybe you have a better way.
A.
Using a random set of indices (each value will be between 0 to 19 because there are 20 names) and before the 'add' I'll check if adding them or not by some counter:
public void addNames() {
// adding 5 random indices between 0 to 19 to the set
Set<Integer> set = new HashSet<Integer>();
Random r = new Random();
Set<Integer> indices = new HashSet<>(numRandomNames); //==5
for (int i = 0; i < numRandomNames; ++i) {
int index = r.nextInt(numNames - 0); //==19
indices.add(index);
}
int counter = 0;
if (indices.contains(counter)) {
list.add("name1");
}
counter++;
if (indices.contains(counter)) {
list.add("name2");
}
counter++;
if (indices.contains(counter)) {
list.add("name3");
}
...
}
B.
RandomList that extends List and overrides the 'add' function to do the same as 'A.' does BUT the override 'add' will decide whether adding the value inside the function so my function will look the same as 1. with the override 'add' function
Do you think about a better solution? if not, then which one is better? (A or B?). I just saw that people recommends not to extend the java collection but I think it's the best solution from these 2 solutions.
NOTE
====
my code can have 10000 names or more even so I don't want to add all the 10,000 names to this\other list and then random 5 of them to other list. I prefer to do it DURING the addition in order to avoid many places of the list while I don't really need them.
EDIT
an answer to ProgrammerTrond:
I'm not sure I'll do it but what I asked me to show is my suggestion of 2.B:
public class RandomList<Integer> implements List<Integer> {
private int addCallsCounter;
private Set<Integer> setIndices = null;
public RandomList(final int numElements, final int maxVal, final int minVal) {
addCallsCounter = 0;
setIndices = new HashSet<Integer>(numElements);
Random r = new Random();
while (setIndices.size() < numElements) {
int index = r.nextInt(maxVal - minVal + 1) + minVal;
if (setIndices.contains(index) == false) {
setIndices.add(index);
}
}
}
#Override
public boolean add(Integer object) {
if (setIndices.contains(addCallsCounter++)) {
this.add(object);
return true;
}
return false;
}
}
and from my code I'll do so:
RandomList randList = new RandomList(5);
randList.add("name1");
randList.add("name2");
randList.add("name3");
...
randList.add("name19");
randList.add("name20");
but my problem is that I need to implement MANY abstract methods of List pfff. RandomList cann't be abstract too because then it won't be able to be instantiated.

try this:
List<Integer> index = new ArrayList<>();
List<String> five_names = new ArrsyList<>();
List<String> allnames = new ArrayList<>();
store five random values
for(int i = 0;i < 5;i++){
int index_no = getrandomNumber();
index.add(index_no);
five_names.add(allnames.get(index_no));
}
getRandomNumber method:
public int getRandomNumber(){
Random rnd = new Random();
int x = rnd.nextInt(20);
if(index.contains(x)){
return getRandomNumber();
}else{
return x
}
}

Why not like this? You don't need the random index list in your list implementation. Didn't you just want a method that would add to a list 5 random names drawn from a set of available names?
import java.util.*;
public class ListAdding {
private static List<String> allNames = Arrays.asList("name1", "name2", "name3", "name4", "name5", "name6", "name7");
public static void main(String[] args) {
new Temp().test();
}
void test() {
List<String> list = new ArrayList<>();
list.add("Bernie");
addFiveRandom(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(i + ": " + list.get(i));
}
// Example: 0: Bernie
// 1: name2
// 2: name3
// 3: name6
// and so on
}
void addFiveRandom(List<String> toBeAddedTo) {
List<Integer> indices = new ArrayList<>();
while (indices.size() < 5) {
int newIndex = new Random().nextInt(5);
if (!indices.contains(newIndex))
indices.add(newIndex);
}
for (Integer index : indices) {
toBeAddedTo.add(allNames.get(index));
}
}
}

Array are not selecting values randomly and split into two arrays

I have got an array list of animals, on click on 'select' button I
would like to randomly select these animals and pass animals into two
arrays (split) called 'teamA and teamB'. Here is my code, but I am getting the same array list always as per screenhot link ? Could someone please
help me to figure out the problem ?
import java.lang.Math;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class RandomExample {
private Random random = new Random();
public static void main(String[] args) {
// 'list' array list contains animals
List<String> list = new ArrayList<String>();
list.add("Tiger");
list.add("Crocodile");
list.add("Cat");
list.add("Dog");
list.add("Elephant");
list.add("Lion");
list.add("Deer");
list.add("Eagle");
RandomExample obj = new RandomExample();
for(int i = 0; i < 10; i++){
obj.getRandomList(list);
List<String> teamA = list.subList(0, 4);
List<String> teamB = list.subList(4, 8);
System.out.println(teamA);
System.out.println(teamB);
}
}
public String getRandomList(List<String> list) {
//0-4
int index = random.nextInt(list.size());
System.out.println("\nIndex :" + index );
return list.get(index);
}
}

As I asked I am not sure why you do not capture the returned string from getRandomList()… I am guessing you are thinking that the list gets returned? Another issue is that when you get a random number from the list you could get the same number. Therefore you will possibly get the same animal on both teams or even the same animal twice or more on the same team. When you put an animal on a team… you need to remove them from the list.
Below I create the two teams. Then setup two loops, one for each team. Using your getRandomList method to get a random animal then remove that animal from the list. After we have both lists, print the results. Hope this helps.
Edit: As per OP request to have a different number of animals for the teams.
Example: use 5 total animals for the teams.
Obviously it’s better to look at the amount of available data before you actually set the team sizes. Example: if you want teamB to have 5 and teamA to have 4, then there better be at least 9 animals in the list. So check the team sizes before you start the loops. If totalAnimalsForTeams is greater than the number of animals in the list or totalAnimalsForTeams is less than two , then we need to indicate this to the user and exit. This approach allows you to use only part of the list if needed. In the implementation below, if the totalAnimalsForTeams is an odd number the second loop will have the extra animal member.
public class Main
{
private static Random random = new Random();
public static void main(String[] args)
{
// 'list' array list contains animals
List<String> list = new ArrayList<String>();
list.add("Tiger");
list.add("Crocodile");
list.add("Cat");
list.add("Dog");
list.add("Elephant");
list.add("Lion");
list.add("Deer");
list.add("Eagle");
list.add("Monster");
list.add("Alien");
list.add("Vombie");
list.add("Politician");
list.add("Donkeye");
List<String> teamA = new ArrayList<String>();
List<String> teamB = new ArrayList<String>();
String newAnimal;
int totalAnimalsForTeams = 7; // <- probably get this value from the user?
if (totalAnimalsForTeams > list.size())
{
System.out.println("There are only " + list.size() + " animals in the list. Requested animals was: " + totalAnimalsForTeams);
return;
}
int firstHalf = totalAnimalsForTeams / 2;
if (firstHalf < 1)
{
System.out.println("Requested " + totalAnimalsForTeams + " animals for teams... not enough to make two teams!");
return;
}
for(int i = 0; i < firstHalf; i++)
{
newAnimal = getRandomList(list);
teamA.add(newAnimal);
list.remove(newAnimal);
}
int secondHalf = totalAnimalsForTeams - firstHalf;
for(int i = 0; i < secondHalf; i++)
{
newAnimal = getRandomList(list);
teamB.add(newAnimal);
list.remove(newAnimal);
}
System.out.println(teamA);
System.out.println(teamB);
}
public static String getRandomList(List<String> list) {
//0-4
if (list.size() > 1)
{
int index = random.nextInt(list.size());
//System.out.println("\nIndex :" + index );
return list.get(index);
}
else
{
return list.get(0);
}
}
}

try this .. it should work ..
import java.lang.Math;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Collections;
import java.util.Random;
public class RandomExample {
private Random random = new Random();
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("Tiger");
list.add("Crocodile");
list.add("Cat");
list.add("Dog");
list.add("Elephant");
list.add("Lion");
list.add("Deer");
list.add("Eagle");
RandomExample obj = new RandomExample();
List<String> teamA = list.subList(0,4);
List<String> teamB = list.subList(4,8);
for(int i = 0; i < 10; i++){
obj.getRandomList(list);
teamA = list.subList(0,4);
teamB = list.subList(4,8);
Collections.rotate(teamA, 1);
Collections.rotate(teamB, 1);
System.out.println(teamA);
System.out.println(teamB);
}
}
public String getRandomList(List<String> list) {
//0-4
int index = random.nextInt(list.size());
System.out.println("\nIndex :" + index );
return list.get(index);
}
}

Calling obj.getRandomList(list); returns a String but you donot do anything with it. I know this method is supposed to return a randomly picked item.
To correctly do what you are asking for, You would have to declare a new ArrayList say temp and then assign list to it.
To avoid Repetition of the same object, you need to remove the randomly generated item from the temp ArrayList created.
Then after you are done, remove the temp ArrayList created.
I have made the necessary changes to your main method as per the suggestions I made.
public static void main(String[] args) {
// 'list' array list contains animals
List<String> list = new ArrayList<String>();
list.add("Tiger");
list.add("Crocodile");
list.add("Cat");
list.add("Dog");
list.add("Elephant");
list.add("Lion");
list.add("Deer");
list.add("Eagle");
RandomExample obj = new RandomExample();
List<String> teamA = new ArrayList<String>();
List<String> teamB = new ArrayList<String>();
List<String> temp = list;
String animal;
for(int i = 0; i < 10; i++){
if(temp.isEmpty() == false){
animal = obj.getRandomList(temp);
if(i <= 3){
teamA.add(animal);
}else{
teamB.add(animal);
}
temp.remove(animal);
//System.out.println("temp is "+temp);
}
}
temp.clear();
System.out.println(teamA);
System.out.println(teamB);
}