JAVA-排序处理

排序处理 list比较器

      // 输入list=[0.0.0.0, 1.4.5.6, 8.8.8.8]
        //输出 list=[8.8.8.8, 1.4.5.6, 0.0.0.0]
   Collections.sort(list, new Comparator()
    {
        @Override
        public int compare(String next, String prev) {
        //ip转数字和
            String[] nextarray = next.split("\.");
            String[] prevarray = prev.split("\.");

            int nextsum = 0;
            int prevsum = 0;
            for (int i = 0; i < nextarray.length; i++) {
                nextsum += Integer.parseInt(nextarray[i]);
                prevsum += Integer.parseInt(prevarray[i]);
            }

            // 降序-后面的大于前面的
            if (prevsum < nextsum) {
                // 返回-1，需要调整
                return -1;
            }
            else {
                return 0;
            }
        }
    });

    System.out.println(list.toString());

list冒泡排序

       int len = list.size();

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                String[] prevarray = list.get(j).split("\.");
                String[] nextarray = list.get(j + 1).split("\.");
                int prevsum = 0;
                int nextsum = 0;
                for (int k = 0; k < nextarray.length; k++) {
                    prevsum += Integer.parseInt(prevarray[k]);
                    nextsum += Integer.parseInt(nextarray[k]);
                }
                // 降序
                if (prevsum < nextsum) {
                    String temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }

        System.out.println(list.toString());

插入排序

// 插入排序
        for (int i = 1; i < len; i++) {
            String data = list.get(i);
            int dataNum = getSum(data);
            int j = i - 1;
            for (; j >= 0; j--) {
                if (getSum(list.get(j)) < dataNum) {
                    list.set(j + 1, list.get(j));
                }
                else {
                    break;
                }
            }
            list.set(j + 1, data);
        }
        System.out.println(list.toString());

优先级队列排序

   Comparator Comparator = new Comparator()
        {
            @Override
            public int compare(String next, String prev) {
                // 降序-后面的大于前面的
                if (getSum(next) > getSum(prev)) {
                    // 返回-1，需要调整
                    return -1;
                }
                else {
                    return 0;
                }
            }
        };

        Queue ipQueue = new PriorityQueue(10, Comparator);

        List list = new ArrayList<>();
        for (String string2 : strArray) {
            if (check(string2) && !list.contains(string2)) {
                // list.add(string2);
                ipQueue.offer(string2);
            }
        }
        
        System.out.println(Arrays.toString(ipQueue.toArray()));

TreeMap排序

public class MyTreeMap {
 
 
	
	public static void main(String[] args) {
		Map map = new TreeMap();
		map.put("c", 2);
		map.put("ad", 1);
		map.put("bc", 1);
		map.put("abc", 3);
 
 
		List> treeMapList =
		    new ArrayList>(map.entrySet());
 
 
		//排序前
		System.out.println("排序前------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
 
 
		//通过key倒序排序
		Collections.sort(treeMapList, new Comparator>() {   
		    public int compare(Map.Entry o1, Map.Entry o2) {      
		        return (o2.getKey()).toString().compareTo(o1.getKey());
		    }
		}); 	
 
 
		System.out.println("key倒序排列------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
		
		//通过value倒序排序
		Collections.sort(treeMapList, new Comparator>() {   
		    public int compare(Map.Entry o1, Map.Entry o2) {      
		        return (o2.getValue() - o1.getValue()); 
		    }
		}); 
 
 
		System.out.println("value倒序排列------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
 
 
	}

实例

package com.epoint.ga.a20220407;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;



public class Test
{

    static String valid = "[0-9\.,]*";

    public static void main(String[] args) {

        String str = "1.4.5.6,6.5.6.56.3,8.8.8.8,0.0.0.0,0.0.0.0";
        if (!checkValid(str)) {
            System.out.println("no pass....");
            return;
        }
        String[] ipArray = str.split(",");
        //冒泡排序
        //        maaoPaoSort(ipArray);

        //插入排序
        //        chaRuSort(ipArray);

        //list排序
        //                listSort(ipArray);

        //set排序
        //                setSort(ipArray);

        //treeMap排序
        //                mapSort(ipArray);

        //优先级队列排序
        //                queueSort(ipArray);

        //map，collection比较
        mapToListSort(ipArray);

    }

    
    public static void mapToListSort(String[] ipArray) {
        Map map = new HashMap<>();
        for (String ip : ipArray) {
            if (checkIP(ip)) {
                map.put(ip, ip);
            }
        }

        List> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator>()
        {
            @Override
            public int compare(Map.Entry o1, Map.Entry o2) {
                if (getSum(o1.getKey()) > getSum(o2.getKey())) {
                    return -1;
                }
                else if (getSum(o1.getKey()) < getSum(o2.getKey())) {
                    return 1;
                }
                return 0;
            }
        });

        System.out.println(list.toString());
    }

    
    public static void queueSort(String[] ipArray) {
        PriorityQueue queue = new PriorityQueue<>(new Comparator()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip) && !queue.contains(ip)) {
                queue.offer(ip);
            }
        }

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }

    public static void mapSort(String[] ipArray) {
        TreeMap treeMap = new TreeMap(new Comparator()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip)) {
                treeMap.put(ip, ip);
            }
        }

        System.out.println(Arrays.toString(treeMap.keySet().toArray()));
        ;

        //        for (String s : treeMap.keySet()) {
        //        }

        //        for (Map.Entry stringStringEntry : treeMap.entrySet()) {
        //            stringStringEntry.getKey();
        //            stringStringEntry.getValue();
        //        }

    }

    
    public static void setSort(String[] ipArray) {
        TreeSet set = new TreeSet<>(new Comparator()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip)) {
                set.add(ip);
            }
        }

        System.out.println(Arrays.toString(set.toArray()));
        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for (String s : set) {
            builder.append(s + ",");
        }
        String str = builder.toString();
        str = str.substring(0, str.length() - 1) + "]";
        System.out.println(str);

        System.out.println();

        System.out.print("[");
        for (int i = 0, len = set.size(); i < len; i++) {
            System.out.print(set.pollFirst());
            if (i != len - 1) {
                System.out.print(",");
            }
        }

        System.out.print("]");

    }

    
    private static void listSort(String[] ipArray) {
        List ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        Collections.sort(ipList, new Comparator()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        System.out.println(ipList.toString());

    }

    
    private static void chaRuSort(String[] ipArray) {
        List ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        int len = ipList.size();
        for (int i = 0; i < len; i++) {
            int data = getSum(ipList.get(i));
            String dataStr = ipList.get(i);
            int j = i - 1;
            for (; j >= 0; j--) {
                if (getSum(ipList.get(j)) < data) {
                    ipList.set(j + 1, ipList.get(j));
                }
                else {
                    break;
                }
            }
            ipList.set(j + 1, dataStr);
        }
        System.out.println(ipList.toString());
    }

    private static void maaoPaoSort(String[] ipArray) {
        List ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        int listLen = ipList.size();
        boolean hasSort = false;
        for (int i = 0; i < listLen - 1; i++) {
            for (int j = 0; j < listLen - 1 - i; j++) {
                String temp;
                if (getSum(ipList.get(j)) < getSum(ipList.get(j + 1))) {
                    temp = ipList.get(j);
                    ipList.set(j, ipList.get(j + 1));
                    ipList.set(j + 1, temp);
                    hasSort = true;
                }
            }
            if (!hasSort) {
                break;
            }
        }
        System.out.println(ipList.toString());
    }

    
    public static int getSum(String str) {
        String[] split = str.split("\.");
        int sum = 0;
        for (String s : split) {
            sum += Integer.parseInt(s);
        }
        return sum;
    }

    
    public static boolean checkIP(String ip) {
        String[] ipnum = ip.split("\.");

        int len = ipnum.length;
        if (len == 4) {
            for (int i = 0; i < len; i++) {
                if (!validNum(ipnum[i])) {
                    System.out.println("存在非数字");
                    return false;
                }

                int num = Integer.parseInt(ipnum[i]);
                if (num < 0 && num > 255) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean checkValid(String s) {
        Pattern compile = Pattern.compile("[0-9,\.]*");
        if (compile.matcher(s).matches()) {
            System.out.println("pattern 验证");
            return true;
        }

        if (s.matches(valid)) {
            System.out.println("String 验证");
            return true;
        }
        return false;
    }

    
    public static boolean validNum(String s) {
        if ("".equals(s) || !Character.isDigit(s.charAt(0))) {
            System.out.println("非数字校验");
            return false;
        }
        return true;
    }
}

JAVA-排序处理

Java相关栏目本月热门文章