We Keep Coding

findElement not working as expected in for-each loop

I'm completely stuck and have no idea why I'm getting the output that I am. Here's the relevant snippet.
WebElement section = driver.findElement(By.xpath("//div[contains(#class,'_main')]"));
List<WebElement> searchResults = new ArrayList<WebElement>();
searchResults.addAll(section.findElements(By.xpath("//div[contains(#class,'_listing')]")));
for (WebElement element : searchResults) {
System.out.println(element.getAttribute("innerHTML"));
System.out.println(element.findElement(By.xpath("//p[contains(#class,'_2tux')]")).getText());
currentlistings.add(newListing('f',element.findElement(By.xpath("//a[contains(#class,'_1oem')]")).getAttribute("href"),
element.findElement(By.xpath("//p[contains(#class,'_2tux')]")).getText(),
element.findElement(By.xpath("//div[contains(#class,'_f3l _4x3g')]")).getText()));
}
The code seemingly functions fine when storing elements to the list, the size is correct and when I iterate through the list elements innerHTML outputs as expected.
However when I then try and use findElement on each of the iterated elements, it seemingly reads the HTML from the element at index 0, even though the command immediately prior outputs the html from the correct index. Any pointers would be much appreciated.

You need to use .//.
element.findElement(By.xpath(".//p[contains(#class,'_2tux')]")).getText(),
element.findElement(By.xpath(".//div[contains(#class,'_f3l _4x3g')]")).getText()));

Permutations of ArrayList<Integer>

im working on a problem where i have to obtain all permutations of an arraylist of numbers. The only restriction is that any number cant start with 0, so if we have [0,1,2] we would obtain
[1,2,0]
[1,0,2]
[2,0,1]
[2,1,0]
i know how to do this with 3 loops but the thing is that i have to repeat this to different sets of numbers with differentes sizes, so i need one method that i can apply to different sets of numbers but i have no clue on how to do this. I imagine i have to used some kind of recursive function but i dont know how to implement it so the numbers cant start with a 0. Any ideas? please dont just post the code i want to understand the problem, thank you in advantage!!

Curious question! Interesting code kata.
I naively think I would have a recursive method that takes:
a list of the items currently chosen by the caller
a set of the items available for the callee
The method would iterate over the set to chose 1 more item and call itself with the list extended by this item, and the set reduced by this item. Upon return, remove from list, add back to set and go on with next item (take a defensive copy of the set of course).
If the current list is empty, the selected first item cannot be 0, as per your rules. If you must collect the permutations somewhere (not just print), a 3rd argument would be required for a collection or an observer.
The recursion obvioulsy stops when the available set is empty, at which point the permutation is sent to the collection or observer.
If items can repeat, you may have benefit from sorting them first in order to skip electing the same item again at a given position.
Beware this quires a recursion depth of N, for N items. But the danger is minimal because even with N=10000, it may not stackoverflow, but the CPU time to complete would be order(N!) (probably end of universe...)

You could solve this recursively as described here: Permutation of an ArrayList of numbers using recursion.
The only thing that is missing there is your restriction with the zeros, which could be solved somehow like this (the loop is taken from the example above):
for (List<Integer> al : myLists) {
// The part you need to add:
if (al.get(0) == 0) {
continue;
}
String appender = "";
for (Integer i : al) {
System.out.print(appender + i);
appender = " ";
}
System.out.println();
}
You basically check the first element of each permutation and skip the ones with a leading zero. The continue jumps to the next iteration of the loop and therefore to the next permutation.

Iterate through each element in java to see if it's displayed

I am new to Java and would like assistance on the best way to perform the following:
I wanted to grab all of the elements that belongs to a class but I want to perform a count on how many of these elements are displayed. I have set up the code to create an int counter, the findelements and the assertion but basically my question is how in java do you create a for loop to simply check if an element within the elements list is displayed, then +1 on the count?
int testNumber = 0;
List<WebElement> testItems = _driver.findElements(By.className("test"));
//Loop each element from the list and if it's displayed then +1 for test Number
Assert.assertEquals(testNumber, 4,
"Mismatch between the number of test items displayed");

Use the method WebElement#isDisplayed (documentation) to get the status of an element.
All you need to do is to setup a counter like int counter = 0. Then create a loop over all elements like for (WebElement e : testItems) { ... }. Then, inside the loop, create some sort of if (e.isDisplayed()) { ... }. And inside this you increase the counter like counter++. All in all:
int counter = 0;
for (WebElement e : testItems) {
if (e.isDisplayed()) {
counter++;
}
}
This variant uses the enhanced for-loop. You can of course use other loop variants too.
Using streams this could be made a compact one-liner like
int count = testItems.stream()
.filter(WebElement::isDisplayed)
.count();
Note that WebElements can, depending on the website, quickly stale if they aren't processed quickly after their generation. This is indicated by them throwing a StaleElementReferenceException. It happens whenever the website rebuilds itself (completely or partially), your element was then retrieved from an old state of the website and is thus invalid.
If you experience this, you may directly collect the display status of an element before finding the other elements. This decreases the time between generation and access of a single WebElement.

Finding Adjacent Element in ArrayList

I am trying to create a for loop which if C2 is adjacent (either previous or next in the array) to C then it continues. I am new to working with these and cant figure out how its meant to be done?
I have done the following method to try and find the adjacent elements:
private static List<Station>Adjacent(ArrayList H,Station station) {
ListIterator<Station> listIterator = H.listIterator();

JavaDoc says that previouse() returns the previouse element in the list and moves the cursor position backwards.
So you don't actually move iterator any further. Try to save previouse item in separate value or use indexes instead of iterator.

select odd/even elements of array using recursion

Am working on some programming homework and am a bit lost. The project is to select the even/odd elements of a listarray and store in another array. It is not the even numbers in each element, but the elements themselves so if an array had values "1,2,5,7,9" and returned the even elements it would give "1, 5, 9". Also have to use recursion. Would anyone be able to give me a starting point or some advice. Though about starting with 2 elements and taking 2nd element and then building up from that, but don't know how it would add on the 2nd pass
public static ArrayList<Integer> even(ArrayList<Integer> list)
ArrayList<Integer> evenlist = ListMethods.deepClone(tList);//make copy of list
if (evenlist.size()<=1) // The list is empty or has one element
{
// return null;// Return the list as is
}
if
(evenlist.size()==2)
{
//return right element
//call method again
//add to list
}

Psuedocode
int[] evens,odds;
function categorize(List<Integer> in,int idx)
if(idx>=in.length)
return
int cur = in[idx]
if(even), add to evens
else add to odds
categorize(in,idx+1)

This sounds similar to the homework I just completed, so if it is (And you're in my class!), I'll not tell you to use any terminology we haven't covered as I know it can be daunting trying to discover something new for practicals (beyond what we have to do).
First, set your exit condition. As you've already said, you have to create a new ArrayList out of the existing one. You are going to remove items from the existing ArrayList, storing the integers that are at even (or odd) indices, until the list is empty.
So your exit condition is:
if (evenList is Empty)
return evenList;
Then, work your way through the steps. I would advise determining if the Array you start with has an even of odd number of steps, something like this:
if (evenList has Even Elements)
int holderForIntsAtEvenElements = last evenList EVEN element
Note we start at the last element, so when you are coming OUT of the recursive method, this will be the last one added to your new ArrayList, and thus it'll be in numerical order. You might find this post interesting to do this: What does this boolean return mean?
We then want to remove the last element from the list and recursively call the method again.
Finally, when we hit our exit condition and start to come out, we want to add the ints we've been storing to them, e.g.:
evenList.add(holderForIntsAtEvenElements);
return evenList;
That doesn't solve one problem, which is what to do with the very first element if the list does NOT have an even number of elements - however, I'll let you try and solve that!
That's a good mix of code and pseudo code and will hopefully help to get you on the right track.

You could use a simple for loop like this:
for (int i = 0; i < list.size(); i += 2) {
System.out.println(list.get(i));
}
If you have to use recursion, here's an outline of the steps you might take. (I won't tell you exactly what to do because you haven't tried anything and it is like homework.)
Take first element and store it
Remove (new) first element from list
Call self