By yzq

第三周的 ARTS,继续加油。

Algorithm

Palindrome Number

Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward. Example

Input: 121
Output: true

Input: -121
Output: false

Input: 10
Output: false

解法1

思路是计算反转后的值，然后与输入值进行比较。

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        int tail = 0;
        int reverse = 0;
        int backx = x;
        while(x > 0) {
            tail = x % 10;
            reverse = reverse * 10 + tail;
            if ((reverse - tail) % 10 != 0) {
                return false;
            }
            x = x / 10;
        }
        if (backx == reverse) {
            return true;
        }
        else {
            return false;
        }         
    }
}

Review

文章主要介绍了自动化测试未来的发展趋势。

Tip

怎样给 List 成员排序

需求：将基站 enodeb 插入到一个链表中，并按照基站的分数高低进行排序 一种方法是让 List 中的成员实现 Comparable 接口，这里在类 enodeb 实现接口方法 compareTo，然后调用 Collections.sort(list) 进行排序。

public class Enodeb implements Comparable<Enodeb> {
    private String ip;
    private Double score;

    public Enodeb(String ip, Double score) {
        this.ip = ip;
        this.score = score;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    public int compareTo(Enodeb enodeb) {
        return this.getScore().compareTo(enodeb.getScore());
    }

    @Override
    public String toString() {
        return "Enodeb{" +
                "ip='" + ip + '\'' +
                ", score=" + score +
                '}';
    }
}   

public class TestEnodeb {
    public static void main(String[] args) {
        Enodeb e1 = new Enodeb("1.1.1.1", 93.2);
        Enodeb e2 = new Enodeb("1.1.1.2", 95.2);
        Enodeb e3 = new Enodeb("1.1.1.2", 91.2);
        List<Enodeb> list = new ArrayList<Enodeb>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        Collections.sort(list);
        System.out.println(list);
    }
}

前一种方法有其局限性，对于一个给定的类，只能够实现 Comparable 接口一次，如果在一个集合中需要按照一个维度排序，在另一个集合中却要按照另一个维度排序，该怎么办？另外，如果需要对一个类的对象排序，而这个类的创建者又没有实现 Comparable 接口，又该怎么办呢？
在这种情况下，可以通过将 Comparator 对象传递给 Collections.sort（） 告诉该函数使用定义的 compare 方法对类对象进行排序。

public class TestEnodeb {
    public static void main(String[] args) {
        Enodeb e1 = new Enodeb("1.1.1.1", 93.2);
        Enodeb e2 = new Enodeb("1.1.1.2", 95.2);
        Enodeb e3 = new Enodeb("1.1.1.2", 91.2);
        List<Enodeb> list = new ArrayList<Enodeb>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        Collections.sort(list, new Comparator<Enodeb>() {
            @Override
            public int compare(Enodeb o1, Enodeb o2) {
                return o1.getScore().compareTo(o2.getScore());
            }
        });
        System.out.println(list);
    }
}

Share

6 reasons why you should blog as a software developer