android - 如何使用计数器从被叫号码列表中对 10 个被叫次数最多的号码进行排序

Question

我正在使用 android 中的电话簿应用程序，它也包含经常被叫的号码活动。我已经得到了带有计数器的号码列表，它被调用了多少次。但现在我只想要该列表中的 10 个最常被叫的号码。这是工作代码：

我已经使用地图对数据进行了排序。

基本上我想按值对数据进行排序，这是被叫号码的计数器。

 ListView list_view2;
String[] PERMISSIONS = {Manifest.permission.READ_CALL_LOG};
ArrayList<Integer> listdata2;
ArrayList<Integer> key;
ArrayList<Integer> value;
int maxIndex = 0;
Integer val;

HashMap<String, Integer> map = new HashMap<String, Integer>();


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_frequently_called);

    list_view2 = findViewById(R.id.list_view2);
    listdata2 = new ArrayList<Integer>();

    getCallDetails();

}

@SuppressLint("LongLogTag")
private String getCallDetails() {

    StringBuffer sb = new StringBuffer();
    if (ActivityCompat.checkSelfPermission(this,
            Manifest.permission.READ_CALL_LOG)
            != PackageManager.PERMISSION_GRANTED) {
        requestContactsPermissions();
        return requestContactsPermissions();
    }


    Cursor managedCursor = getContentResolver().query(CallLog.Calls.CONTENT_URI, null, null, null, null);

    Integer number = managedCursor.getColumnIndex(CallLog.Calls.NUMBER);
    int type = managedCursor.getColumnIndex(CallLog.Calls.TYPE);
    int date = managedCursor.getColumnIndex(CallLog.Calls.DATE);
    int duration = managedCursor.getColumnIndex(CallLog.Calls.DURATION);


    while (managedCursor.moveToNext()) {
        String phNumber = managedCursor.getString(number);
        Integer callType = managedCursor.getInt(type);
        Integer callDate = managedCursor.getInt(date);
        Date callDayTime = new Date(Long.valueOf(callDate));
        Integer callDuration = managedCursor.getInt(duration);

        Log.e("Phone number", phNumber + "");
        Log.e("call type", callType + "");
        Log.e("call duration", callDuration + "");
       // Log.e("call date", callDate + "");
        Log.e("call day time", callDayTime + "");

        String dir = null;
        int dircode = new Integer(callType);
        switch (dircode) {
            case CallLog.Calls.OUTGOING_TYPE:
                dir = "OUTGOING";
                break;

            case CallLog.Calls.INCOMING_TYPE:
                dir = "INCOMING";
                break;

            case CallLog.Calls.MISSED_TYPE:
                dir = "MISSED";
                break;
        }

        if (map.get(phNumber) == null) {
            map.put(phNumber+"", 1);
        } else {
            Integer scount = map.get(phNumber).intValue();
            scount++;
            map.put(phNumber+"", scount);

            //Log.e("map values", map + "");
        }
    }
    managedCursor.close();

    //Log.e("map.keySet()",map.keySet().toString());

    HashSet<String> numbersset=new HashSet<String>(map.keySet());

    ArrayList<String> numbers= new ArrayList<String>();
    ArrayList<Integer> counts= new ArrayList<Integer>();

    Iterator iterator=numbersset.iterator();

    while(iterator.hasNext()) {
        String no = iterator.next().toString();
        numbers.add(no);
        counts.add(map.get(no));
        }

    Log.e("number count ",numbers.size()+"|");
    Log.e("count count ",counts.size()+"|");





    for (int i=0;i<counts.size();i++){
        for(int j=0;j<counts.size();j++){
            int t1=counts.get(i);
            int t2=counts.get(j);

            if(t1 > t2){
                for(t1=0;t1>=10;t1++) {
                    for(t2=0;t2>=10;t2++) {
                        int temp = counts.get(j);
                        counts.set(j, counts.get(i));
                        counts.set(i, temp);

                        String temps = numbers.get(j);
                        numbers.set(j, numbers.get(i));
                        numbers.set(i, temps);
                    }
                }
            }
        }
    }

//反向排序数据

    for (int i=0;i<counts.size();i++){
        Log.e("sort-"+numbers.get(i),counts.get(i)+"");
    }

    return sb.toString();
}

    private String requestContactsPermissions () {

        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_CALL_LOG)) {
            ActivityCompat.requestPermissions(this, PERMISSIONS, 1);
        } else {
            ActivityCompat.requestPermissions(this, PERMISSIONS, 1);
        }
        return null;
    }
}

标签： androidsorting

Answer 1

您可以创建一个循环 10 次，另一个循环每次都搜索最大的计数器并将对应的数字添加到新列表中。

@Override
protected void onCreate(Bundle savedInstanceState) {  // Exaple to show result
    ArrayList<String> number = new ArrayList<>();
    number.add("0521392");
    number.add("0521396");
    number.add("0521397");
    number.add("0521398");
    number.add("0521391");
    ArrayList<Integer> counts = new ArrayList<>();
    counts.add(10);
    counts.add(5);
    counts.add(6);
    counts.add(10);
    counts.add(7);

    for (String n : mostCalled(number, counts, 8)){   // Calling the function and printing the output  
        Log.i("go", "phone number: " + n);
    }
}

private ArrayList<String> mostCalled(ArrayList<String> number, ArrayList<Integer> counts, int howMuchNumbersToShow){   // function that get list of phone numbers and list of how meany times each number called and return the howMuchNumbersToShow most called numbers (who called the most times)
    if (number.size() != counts.size()){
        return new ArrayList<>();
    }
    int biggerNumber = -1; // will store the current biggest number
    int lastBiggerNumber = 10000000;  // will store the last bigger number
    int biggerNumberPlace = -1;     // will store the place of the biggest number in the array
    ArrayList<Integer> biggerNumberLocationList = new ArrayList<>();   // will store all the places of the biggest numbers in the array

    if (howMuchNumbersToShow > number.size())
        howMuchNumbersToShow = number.size();
    for (int l=0; l<howMuchNumbersToShow; l++){
        for (int x=0; x<counts.size(); x++){
            if (!biggerNumberLocationList.contains(x))      // to get each number one time (help in case more then one phone number called the same amount)
                if (counts.get(x) >= biggerNumber && counts.get(x)<= lastBiggerNumber){
                    biggerNumber = counts.get(x);
                    biggerNumberPlace = x;
                }

        }
        lastBiggerNumber = biggerNumber;
        biggerNumber = -1;
        biggerNumberLocationList.add(biggerNumberPlace);
    }

    ArrayList<String> mostCalledPhoneNumbers = new ArrayList();
    int place_in_array;
    String phoneNumber;


    for (int f=0; f<biggerNumberLocationList.size() ; f++) {
        place_in_array = biggerNumberLocationList.get(f);
        phoneNumber = number.get(place_in_array);
        mostCalledPhoneNumbers.add(phoneNumber);
   //     Log.i("go", "place in array " + biggerNumberLocationList.get(f) + ", the phone number "  + number.get(biggerNumberLocationList.get(f)) + " called " + counts.get(biggerNumberLocationList.get(f)) + " times ");
    }
    return mostCalledPhoneNumbers;
}

使用 HashMap 来完成这项工作会更容易，甚至使用 ArrayList<> 类型的对象来存储字符串和 int 会更容易。