如何在Java中实现Arraylist中的二进制搜索过程

我不知道如何在Java中实现Arraylist中的二进制搜索过程

有两个arraylist显示机场名称和两个机场名称之间的路线

下面是airportName和Route类的定义

public class AirportName{
    private String airportName;
}

public class Route{
    private String takeOffPoint;
    private String landingPoint;
}

机场名称在Arraylist中定义为（JFK）等机场名称的缩写 管线名称定义为管线对象，包括Arraylist中的起飞点和着陆点，如 （肯尼迪机场-TLV）

因为每个arraylist中有很多机场名称和路线，其大小超过30000，所以我必须使用二进制搜索来实现代码优化

我已经完成了这个过程，没有使用二进制搜索

我如何通过二进制搜索来实现它

下面是我的代码片段，如下所示

ArrayList<AirportName> airportNames = ShowProcess.getAirports();
ArrayList<Route> routeNamesList = ShowProcess.getAirportRoutes();

路线名称

public static ArrayList<String> searchProcess(String airportName, ArrayList<Route> routeNamesList) {
        ArrayList<String> destinationNames = new ArrayList<String>();
        for(Route route : routeNamesList) {
            if(route.getTakeOffPoint().equals(airportName)) {
                destinationNames.add(route.getLandingPoint());
            }
        }

        return destinationNames;
}

公共静态ArrayList searchProcess（字符串airportName，ArrayList RouteNameList）{
ArrayList destinationNames=新ArrayList（）；
用于（路由：routeNamesList）{
if（route.getTakeOffPoint（）.equals（airportName））{
add（route.getLandingPoint（））；
}
}
返回目的地名称；
}

这是我的解决方案。它起作用了

public static Integer[] binarySearch(ArrayList<Route> routeNamesList, Comparable key) {
        ArrayList<Integer> arrList = new ArrayList<Integer>();
        int lo = 0, hi = routeNamesList.size() - 1, mid;
        routeNamesList.sort((str1, str2) -> str1.getTakeOffPoint().compareTo(str2.getTakeOffPoint()));

        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                int lowerBoundary = lowerIndex(routeNamesList, key, lo, mid);
                int upperBoundary = upperIndex(routeNamesList, key, mid, hi);
                for(int i = lowerBoundary; i <= upperBoundary; i++) {
                    arrList.add(i);
                }
                break;
            } else if (cmp < 0)
                hi = mid - 1;
            else
                lo = mid + 1;
        }
        return arrList.stream().toArray(Integer[]::new);
    }

    public static int lowerIndex(ArrayList<Route> routeNamesList, Comparable key, int lo, int hi) {
        int mid;
        int lastMatch = hi;
        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                lastMatch = mid;
                hi = mid - 1;
            } else if (cmp < 0) {
                lo = mid + 1;
            } else {
                break;
            }
        }

        return lastMatch;
    }

    public static int upperIndex(ArrayList<Route> routeNamesList, Comparable key, int lo, int hi) {
        int mid;
        int lastMatch = lo;
        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                lastMatch = mid;
                lo = mid + 1;
            } else if (cmp < 0) {
                hi = mid - 1;
            } else {
                break;
            }
        }

        return lastMatch;
    }

    public static ArrayList<String> searchProcess(String airportName, ArrayList<Route> routeNamesList) {
        ArrayList<String> destinationNames = new ArrayList<String>();

        Integer[] indices = binarySearch(routeNamesList, airportName);
        for (int i = 0; i < indices.length; i++) {
            if(routeNamesList.get(i).getTakeOffPoint().equals(airportName)) {
                destinationNames.add(routeNamesList.get(i).getLandingPoint());
            }
        }

        return destinationNames;
    }

publicstaticinteger[]binarySearch（arraylistroutenameslist，可比较键）{
ArrayList arrList=新的ArrayList（）；
int lo=0，hi=routeNamesList.size（）-1，mid；
排序（（str1，str2）->str1.getTakeOffPoint（）.compareTo（str2.getTakeOffPoint（））；
while（lo）是您的列表预排序的吗？@user这是一种线性搜索，但我必须使用二进制搜索来搜索列表中的项目，因为它的大小很长。好的，但是您的列表已经排序了吗？@user它没有排序。那么二进制搜索可能不值得。线性搜索是O（n），二进制搜索是O（nlogn）（更确切地说）
public static Integer[] binarySearch(ArrayList<Route> routeNamesList, Comparable key) {
        ArrayList<Integer> arrList = new ArrayList<Integer>();
        int lo = 0, hi = routeNamesList.size() - 1, mid;
        routeNamesList.sort((str1, str2) -> str1.getTakeOffPoint().compareTo(str2.getTakeOffPoint()));

        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                int lowerBoundary = lowerIndex(routeNamesList, key, lo, mid);
                int upperBoundary = upperIndex(routeNamesList, key, mid, hi);
                for(int i = lowerBoundary; i <= upperBoundary; i++) {
                    arrList.add(i);
                }
                break;
            } else if (cmp < 0)
                hi = mid - 1;
            else
                lo = mid + 1;
        }
        return arrList.stream().toArray(Integer[]::new);
    }

    public static int lowerIndex(ArrayList<Route> routeNamesList, Comparable key, int lo, int hi) {
        int mid;
        int lastMatch = hi;
        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                lastMatch = mid;
                hi = mid - 1;
            } else if (cmp < 0) {
                lo = mid + 1;
            } else {
                break;
            }
        }

        return lastMatch;
    }

    public static int upperIndex(ArrayList<Route> routeNamesList, Comparable key, int lo, int hi) {
        int mid;
        int lastMatch = lo;
        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(routeNamesList.get(mid).getTakeOffPoint());
            if (cmp == 0) {
                lastMatch = mid;
                lo = mid + 1;
            } else if (cmp < 0) {
                hi = mid - 1;
            } else {
                break;
            }
        }

        return lastMatch;
    }

    public static ArrayList<String> searchProcess(String airportName, ArrayList<Route> routeNamesList) {
        ArrayList<String> destinationNames = new ArrayList<String>();

        Integer[] indices = binarySearch(routeNamesList, airportName);
        for (int i = 0; i < indices.length; i++) {
            if(routeNamesList.get(i).getTakeOffPoint().equals(airportName)) {
                destinationNames.add(routeNamesList.get(i).getLandingPoint());
            }
        }

        return destinationNames;
    }