Finding an element in an Array using ONLY If statement

If you are limited to avoid use the for-loop and use the if-else only, the recursive call is an alternative:

public Photo searchByTitle(String title) {
    return searchByIndex(title, 0); 
}

private Photo searchByIndex(String title, int index) {
    if (index < photos.size()) {                       // Has next? If yes ...
        Photo next = photos.get(index);                //   Get next
        if (!title.equals(next.getPhotoName())) {      //   Does the title match? If not...
            return searchByIndex(title, ++index);      //      Check the next one
        } else return next;                            //   Otherwise you found it
    } return null;                                     // ... if no next, return null
}

I assume the Photo class has a field String photoName accessible with a getter which is about to be compared with the String title.

1. Implement Comparable on Photo that returns true if the title is the same.
2. Construct a temporary Photo object with the given type.
3. Leverage the indexOf method on ArrayList to find index of Album with the Photo title.
4. Use get(int) to get the Album.

I've implemented the code from the comments above.
The idea here is to build a temporary object in the searchByTitle method and passing it to the List.indexOf method having the Photo class that overrides Object.equals.

public class Album {

    class Photo {
        private String title;

        public Photo(String title) {
            this.title = title;
        }

        public String getTitle() {
            return title;
        }

        @Override
        public boolean equals(Object anObject) {
            return title.equals(((Photo)anObject).getTitle());
        }
    }

    private String albumtitle;
    private ArrayList<Photo> photos;

    /**
     * This constructor should initialize the
     * instance variables of the class.
     */
    public Album(String title) {
        this.albumtitle = title;
        photos = new ArrayList<>();
    }

    /** When passed a title, this method should
     * return the first Photo object in the album with
     * a matching title. If there is no such object, it 
     * should return null.
     * 
     * @param title A title to search for
     * @return A Photo object, or null
     */
    public Photo searchByTitle(String title) {
        Photo tmp = new Photo(title);
        int index = photos.indexOf(tmp);
        if (index >= 0)
            return photos.get(index);
        return null;
    }

}

This is a very basical implementation of equals which doesn't take into account null argument and its type.

You can bring another ArrayList of String which keeps names of photo titles. Then in search function search with photo title in String arrayList. If find an index then return the Photo object of that index from photoTitles, as you are inserting in both arrayList in same order.

public class Album {

    private String albumtitle;
    private ArrayList<Photo> photos;
    private ArrayList<String> photoTitles;


    public Album(String title) {

        this.albumtitle = title;
        photos = new ArrayList<>();
        photoTitles = new ArrayList<>();
    }

    public Photo searchByTitle(String title) {

        int index = photoTitles.indexOf(title);
        if(index >= 0) {
            return photos.get(index);
        }
        return null;
    }
}

Just because I like the recursion idea but using it with an index search on a List is not optimal, let's use an iterator instead. The recursive method will simply check if there is one value to take, check and call again until we find the value or reach the end.

//Just hide the used of an iterator
public static Photo getFirstWithTitle(List<Photo> list, String value){
    return getFirstWithTitle(list.iterator(), value);
}

//recursive method
private static Photo getFirstWithTitle(Iterator<Photo> it, String value){
    if(it.hasNext()){ 
        Photo p = it.next();
        return p.getTitle().equals(value)?
            p
            : getFirstWithTitle(it, value);
    } else
        return null;
}

You can use built in binarySearch and a comparator. Probably the most elegant way and how I usually do it

public Photo searchByTitle(String title) {
    Photo item = null
    Comparator<Photo> comparator = new Comparator<Photo>() {
        public int compare(Photo it1, Photo it2) {
            return it1.getTitle().compareTo(it2.getTitle());
        }
    };
    Collections.sort(photos, comparator); //This should go after you set the items, ie. you sort it once
    int index = Collections.binarySearch(photos, comparator);

    if (index >= 0) {
        item = photos.get(index);
    }
    return item
}

Using Java you don't even need a 'if' statement. This can be achieved through this:

public Photo searchByTitle(String title) {

    return photos.stream().filter(photo -> title.
            equals(photo.getTitle())).findAny().get();      
}

p.s: I did not have access to your enunciate question (the link provided)