Intern with no mentor struggling with refactoring and OOP

for (int i = 0; i < limit; i++) {
        if (row[i].contains(input)) {
            // The way I'm instantiating and calling from PartList here seems off to me
            PartList partList = new PartList();
            partList.setList(reader, row);
        }
    }

package com.myproject.se;

public class Part {

    enum Serviceability {
        SERVICEABLE("SVCBLE"), NOT_SERVICEABLE("NOT SVC"), UNDEFINED("");

        private String value;

        Serviceability(String value) {
            this.value = value;
        }

        public String toString() {
            return value;
        }

        static Serviceability fromValue(String value) {
            if (value != null) {
                String valueToCompare = value.toUpperCase();
                for (Serviceability current : Serviceability.values()) {
                    if (current.value.equals(valueToCompare)) {
                        return current;
                    }
                }
            }
            return UNDEFINED;
        }
    }

    enum PartType {
        PART("PART"), ASSEMBLY("ASSEMBLY"), UNDEFINED("");

        private String value;

        PartType(String value) {
            this.value = value;
        }

        public String toString() {
            return value;
        }

        static PartType fromValue(String value) {
            if (value != null) {
                String valueToCompare = value.toUpperCase();
                for (PartType current : PartType.values()) {
                    if (current.value.equals(valueToCompare)) {
                        return current;
                    }
                }
            }
            return UNDEFINED;
        }
    }

    private int modelLevel;
    private String partNumber;
    private String name;
    private Serviceability serviceability;
    private int quantity;
    private PartType partType;

    public Part(String[] values) {
        // TODO: sanity checking for desired number of columns
        setModelLevel(Integer.parseInt(values[0]));
        setPartNumber(values[1]);
        setName(values[2]);
        setServiceability(values[3]);
        setQuantity(Integer.parseInt(values[4]));
        setPartType(values[5]);
    }

    public int getModelLevel() {
        return modelLevel;
    }

    public void setModelLevel(int modelLevel) {
        this.modelLevel = modelLevel;
    }

    public String getPartNumber() {
        return partNumber;
    }

    public void setPartNumber(String partNumber) {
        // normalize to upper case
        this.partNumber = partNumber.toUpperCase();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        // normalize to upper case
        this.name = name.toUpperCase();
    }

    public Serviceability getServiceability() {
        return serviceability;
    }

    public void setServiceability(Serviceability serviceability) {
        this.serviceability = serviceability;
    }

    public void setServiceability(String serviceability) {
        this.serviceability = Serviceability.fromValue(serviceability);
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

package com.myproject.se;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class PartList implements Iterable<Part> {
    private List<Part> partList = new ArrayList<Part>();

    public PartList(Part part) {
        addPart(part);
    }

    public void addPart(Part part) {
        // simple constraint
        if (partList.isEmpty() && !part.isTopLevelPart()) {
            throw new RuntimeException("This is not a top-level part.");
        }
        partList.add(part);
    }

    @Override
    public Iterator<Part> iterator() {
        return partList.iterator();
    }

    public Part getTopLevelPart() {
        return partList.get(0);
    }

    public int size() {
        return partList.size();
    }

    public List<Part> getServiceableParts() {
        List<Part> result = new ArrayList<Part>();
        for (Part part : partList) {
            if (part.isServiceable()) {
                result.add(part);
            }
        }
        return result;
    }
}

package com.myproject.se;

import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class RecordSupplier implements Iterable<Part>, Closeable {
    private static final List<String[]> testValues = new ArrayList<String[]>();

    static {
        testValues.add(new String[] { "2", "ABC", "NAME 1", "", "1", "" });
        testValues.add(new String[] { "3", "DEF", "NAME 2", "SVCBLE", "2", "PART" });
        testValues.add(new String[] { "4", "GHI", "NAME 3", "NOT SVC", "3", "ASSEMBLY" });
        testValues.add(new String[] { "2", "JKL", "NAME 4", "", "1", "" });
        testValues.add(new String[] { "3", "MNO", "NAME 5", "SVCBLE", "5", "PART" });
    }

    @Override
    public void close() throws IOException {
        // do nothing
    }

    @Override
    public Iterator<Part> iterator() {
        return new Iterator<Part>() {
            private Iterator<String[]> innerIterator = testValues.iterator();

            @Override
            public boolean hasNext() {
                return innerIterator.hasNext();
            }
            @Override
            public Part next() {
                return new Part(innerIterator.next());
            }
            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

}

package com.myproject.se;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        @SuppressWarnings("unused")
        Scanner scanner = new Scanner(System.in);
        String partNumber1;
        String partNumber2;
        System.out.println("Enter first part number:");
        // partNumber1 = scanner.next();
        partNumber1 = "JKL";
        System.out.println("Enter second part number:");
        // partNumber2 = scanner.next();
        partNumber2 = "ABC";
        Map<String, PartList> result = getPartLists(partNumber1, partNumber2);
        for (Entry<String, PartList> entry : result.entrySet()) {
            System.out.println("Part number search term: " + entry.getKey());
            Iterator<Part> iterator = entry.getValue().iterator();
            while (iterator.hasNext()) {
                System.out.println(iterator.next());
            }
            System.out.println("====================");
        }
    }

    public static Map<String, PartList> getPartLists(String... partNumbers) {
        // only searching for two parts now, easily extensible
        if (partNumbers.length != 2) {
            throw new RuntimeException("Only two part numbers needed.");
        }
        Map<String, PartList> result = new HashMap<String, PartList>();
        RecordSupplier supplier = new RecordSupplier();
        Iterator<Part> iterator = supplier.iterator();
        PartList partList = null;
        while (iterator.hasNext()) {
            Part part = iterator.next();
            if (part.isTopLevelPart()) {
                String match = partNumberMatches(part, partNumbers);
                if (match.isEmpty()) {
                    partList = null;
                } else {
                    // match belongs to a new PartList
                    partList = new PartList(part);
                    // add the new PartList to result
                    result.put(match, partList);
                }
            } else if (partList != null) {
                // keep adding current Part to existing PartList
                partList.addPart(part);
            }
        }
        try {
            supplier.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // returning just a List of PartList should be good enough actually
        return result;
    }

    public static String partNumberMatches(Part part, String... partNumbers) {
        for (String partNumber : partNumbers) {
            if (part.hasPartNumberContains(partNumber)) {
                return partNumber;
            }
        }
        return "";
    }
}