Using Java-8 Collection#removeIf

myList.removeIf(obj -> obj.id == 10);

With Java-7 you'll have to use iterator:

for(Iterator<MyType> iterator = myList.iterator(); iterator.hasNext(); ) {
    if(iterator.next().id == 10)
        iterator.remove();
}

Note that list iteration is necessary in any case. In Java-8 removeIf method it's just performed internally.

ArrayList removes objects based on the equals(Object obj) method. So you should implement properly this method. Something like:

public boolean equals(Object obj) {
    if (obj == null) return false;
    if (obj == this) return true;
    if (!(obj instanceof ArrayTest)) return false;
    ArrayTest o = (ArrayTest) obj;
    return o.i == this.i;
}

Or

public boolean equals(Object obj) {
    if (obj instanceof ArrayTest) {
        ArrayTest o = (ArrayTest) obj;
        return o.i == this.i;
    }
    return false;
}

What you can do it to stream over original list, and leave only objects which satisfy the condition. It might look something like this:

List<Product> filtered = productList.stream()
      .filter( p -> p.attributeList().stream().anyMatch( a -> a.attributeId.equals(x))
      .collect(Collectors.toList()) 

in this live we are actually checking if nested list contains at least one object with attributeId = x p.attributeList().stream().anyMatch( a -> a.attributeId.equals(x)

You can use Collection::removeIf(Predicate filter) (available from Java8 onwards), here is a simple example:

final Collection<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
list.removeIf(value -> value < 2);
System.out.println(list); // outputs "[2]"

In your case, there's no need to iterate through the list, because you know which object to delete. You have several options. First you can remove the object by index (so if you know, that the object is the second list element):

 a.remove(1);       // indexes are zero-based

Or, you can remove the first occurence of your string:

 a.remove("acbd");  // removes the first String object that is equal to the
                    // String represented by this literal

Or, remove all strings with a certain value:

 while(a.remove("acbd")) {}

It's a bit more complicated, if you have more complex objects in your collection and want to remove instances, that have a certain property. So that you can't remove them by using remove with an object that is equal to the one you want to delete.

In those case, I usually use a second list to collect all instances that I want to delete and remove them in a second pass:

 List<MyBean> deleteCandidates = new ArrayList<>();
 List<MyBean> myBeans = getThemFromSomewhere();

 // Pass 1 - collect delete candidates
 for (MyBean myBean : myBeans) {
    if (shallBeDeleted(myBean)) {
       deleteCandidates.add(myBean);
    }
 }

 // Pass 2 - delete
 for (MyBean deleteCandidate : deleteCandidates) {
    myBeans.remove(deleteCandidate);
 }

If you change the class Item equals() and compareTo() methods, so that they check only one object field, such as a quantity, it could result in strange behavior in other parts of your application. For example, two items with different itemNo, itemName, and itemPrice, but with the same quantities could be considered equal. Besides, you wouldn't be able to change the comparison attribute without changing the equals() code every time.

Also, creating a custom contains() method makes no sense, since it belongs to the ArrayList class, and not to Item.

If you can use Java 8, a clean way to do it is to use the new Collection's removeIf method:

Suppose you have an Item class with the num and name properties:

class Item {
    final int num;
    final String name;

    Item(int num, String name) {
        this.num = num;
        this.name = name;
    }
}

Given a List<Item> called items and an int variable called number, representing the number of the item you want to remove, you could simply do:

items.removeIf(item -> item.num == number);

If you are unable to use Java 8, you can achieve this by using custom comparators, binary search, and dummy objects.

You can create a custom comparator for each attribute you need to look for. The comparator for num would look like this:

class ItemNumComparator implements Comparator<Item> {
    @Override
    public int compare(Item a, Item b) {
        return (a.num < b.num) ? -1 : ((a.num == b.num) ? 0 : 1);
    }
}

Then you can use the comparator to sort and search for the desired elements in your list:

public static void main(String[] args) {
    List<Item> items = new ArrayList<>();
    items.add(new Item(2, "ball"));
    items.add(new Item(5, "cow"));
    items.add(new Item(3, "gum"));

    Comparator<Item> itemNumComparator = new ItemNumComparator();
    Collections.sort(items, itemNumComparator);

    // Pass a dummy object containing only the relevant attribute to be searched
    int index = Collections.binarySearch(items, new Item(5, ""), itemNumComparator);
    Item removedItem = null;
    // binarySearch will return -1 if it does not find the element.
    if (index > -1) {
        // This will remove the element, Item(5, "cow") in this case, from the list
        removedItem = items.remove(index);
    }
    System.out.println(removedItem);
}

To search for another field like name, for example, you would need to create a name comparator and use it to sort and run the binary search on your list.

Note this solution has some drawbacks though. Unless you are completely sure that the list didn't change since the last sort, you must re-sort it before running the binarySearch() method. Otherwise, it may not be able to find the correct element. Sorting complexity is O(nlogn), so running it multiple times can get quite expensive depending on the size of your list.

You have many, many bugs in this code.

2 scanners

You should have only one Scanner object. Why do you have both kb and in? Delete one.

mixing nextLine and nextAnythingElse

You can't mix those. The usual thing to do is to never use nextLine(); to read a line of text, just use next(). This does require that you update the scanner's delimiter; immediately after making the scanner object, call in.useDelimiter("\r?\n"); on it.

AList isn't a thing

Whatever might 'AList' be? It's not in core java and it doesn't sound like it is required here; just use ArrayList<Patient> instead

naming a class with a plural name.

Clearly a single Patients instance represents a single patient, therefore, you should call it Patient, because what you have is clearly confusing you.

You're breaking with convention.

thisIsAVariableName, ThisIsATypeName, THIS_IS_A_CONSTANT. That should be aPatients, not APatients. This makes your code hard to read, and given that you're using a community resource (Stack Overflow), that's not good.

Your actual question

Given that AList is not a thing and you didn't paste it, it is not possible for anybody on SO to answer this question. Update the question and include the API of AList, or stop using it (there is no reason to use this, unless it is mandated because this is homework, in which case, you should ask your teacher for help on this; they get paid, and are the ones who are supposed to support this AList class you're using). Had you been using ArrayList, there are a number of ways to do this. But first a concern: If you loop through each item by way of 'index', then removing an element shifts all indexes down by one, which makes the math complicated. One extremely easy way out of that dilemma is to loop through the list backwards to forwards, because then the shifting of indices doesn't have an impact.

Option #1: Iterators

var it = aPatients.iterator();
while (it.hasNext()) {
    Patient p = it.next();
    if (p.getAge() > 25) it.remove();
}

Option #2: Backwards loop

for (int i = aPatients.size() - 1; i >= 0; i--) {
    if (aPatients.get(i).getAge() > 25) aPatients.remove(i);
}

Option #3: removeIf

aPatients.removeIf(pat -> pat.getAge() > 25);

1. If you don't need to keep a reference to the object you remove, you can just

   linkedAccount.removeIf(acc -> acc.getStudentID() == accountNumber);
   

2. If you want to keep a reference to the element you remove you can

   for (Account acc : linkedAccount) {
       if (acc.getStudentID() == accountNumber) {
           obj1 = acc;
           linkedAccount.remove(acc);
           break;
       }
   }
   
   // OR
   
   for (int i = 0; i < linkedAccount.size(); i++) {
       if (linkedAccount.get(i).getStudentID() == accountNumber) {
           obj1 = linkedAccount.remove(i);
           break;
       }
   }
   

3. Notice that in most case and basiclly an ArrayList is sufficient When to use LinkedList over ArrayList in Java?

To Remove element from the list

objectA.removeIf(x -> conditions);

eg:

objectA.removeIf(x -> blockedWorkerIds.contains(x));

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

str1.removeIf(x -> str2.contains(x)); 

str1.forEach(System.out::println);

OUTPUT: A B C

As per the JavaDoc:

public boolean remove(Object o)

Removes the first occurrence of the specified element from this list, if it is present. If the list does not contain the element, it is unchanged. More formally, removes the element with the lowest index i such that (o==null ? get(i)==null : o.equals(get(i))) (if such an element exists). Returns true if this list contained the specified element (or equivalently, if this list changed as a result of the call).

Which essentially means that borrowers.remove(libraryNumber); will work if and only if you have some Borrower object which is equal to that string. Unless you have added an override to the equals method in your Borrower class, it is unlikely that this will ever work. Thus, you have two options:

1. Override the equals (and for good practice, the hashcode()) methods within your Borrower class such that two borrower items are considered equal if they have the same libraryNumber.

2. The second option would be to use an iterator to go through your Borrower items stored within borrower and use the iterator's remove method to delete the objects which have the same property values.

As a side note, although the first approach might be more elegant for some, caution must be taken since in your particular scenario, Borrower objects might not be equal just because they have the same libraryNumber.