6.TDD实现最接近0的数

一.题目

Given a list of numbers find the closest to zero.If there is a tie, choose thepositive value.
本人修改了题目：给定一个数列表，找到最接近0的数。 如果两个数相等，选择正值。如果有多个相等的最接近数，选第一个出现的即可。
这题算是我做过的TDD中最简单的。

二.最终代码展示

1.实现

package cs.calcstats;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @author shuai.chen
 * @date 2018年9月21日
 * @Description
 * 
 *              Given a list of numbers find the closest to zero.If there is a tie, choose the
 *              positive value.
 * 
 *              修改了题目：给定一个数列表，找到最接近0的数。 如果两个数相等，选择正值。如果有多个相等的最接近数，选第一个出现的即可。
 */
public class ClosestToZero {
    public Map<Integer, Double> getNumber(double[] doubArray) {
        int index = 0;
        double minNum = doubArray[0];
        double minNumAbs = Math.abs(minNum);
        Map<Integer, Double> map = new HashMap<>();
        for (int i = 0; i < doubArray.length; i++) {
            if(minNumAbs > Math.abs(doubArray[i])) {
                minNum = doubArray[i];
                minNumAbs = Math.abs(minNum);
                index = i;
            }
            if(minNumAbs == Math.abs(doubArray[i])) {
                if(minNum < doubArray[i]) {
                    minNum = doubArray[i];
                    minNumAbs = Math.abs(minNum);
                    index = i;
                }
            }
        }
        map.put(index + 1, minNum);
        return map;
    }
}

2.测试

package cs.calcstatus;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

import cs.calcstats.ClosestToZero;
import junit.framework.Assert;

public class ClosestToZeroTest {
    @Test
    public void 只有一个数() {
        //given
        double[] givenDoubles = {0.88};
        int indexExpected = 1;
        double doubExpected = 0.88;
        int indexActual = 0;
        double doubActual = 0;
        
        //when
        ClosestToZero closesToZero = new ClosestToZero();
        Map<Integer, Double> map = closesToZero.getNumber(givenDoubles);
        Set<Integer> sets = map.keySet();
        for(Iterator<Integer> iter = sets.iterator(); iter.hasNext(); ) {
            indexActual = iter.next();
            doubActual = map.get(indexActual);
        }
        
        //then
        Assert.assertEquals(1, map.size());
        Assert.assertEquals(indexExpected, indexActual);
        Assert.assertEquals(doubExpected, doubActual);
    }
    
    @Test
    public void 只有正数() {
        //given
        double[] givenDoubles = {1, 3, 2, 0.5, 0.5};
        int indexExpected = 4;
        double doubExpected = 0.5;
        int indexActual = 0;
        double doubActual = 0;
        
        //when
        ClosestToZero closesToZero = new ClosestToZero();
        Map<Integer, Double> map = closesToZero.getNumber(givenDoubles);
        Set<Integer> sets = map.keySet();
        for(Iterator<Integer> iter = sets.iterator(); iter.hasNext(); ) {
            indexActual = iter.next();
            doubActual = map.get(indexActual);
        }
        
        //then
        Assert.assertEquals(1, map.size());
        Assert.assertEquals(indexExpected, indexActual);
        Assert.assertEquals(doubExpected, doubActual);
    }
    
    @Test
    public void 只有负数() {
        //given
        double[] givenDoubles = {-1, -3, -2, -0.5, -0.5};
        int indexExpected = 4;
        double doubExpected = -0.5;
        int indexActual = 0;
        double doubActual = 0;
        
        //when
        ClosestToZero closesToZero = new ClosestToZero();
        Map<Integer, Double> map = closesToZero.getNumber(givenDoubles);
        Set<Integer> sets = map.keySet();
        for(Iterator<Integer> iter = sets.iterator(); iter.hasNext(); ) {
            indexActual = iter.next();
            doubActual = map.get(indexActual);
        }
        
        //then
        Assert.assertEquals(1, map.size());
        Assert.assertEquals(indexExpected, indexActual);
        Assert.assertEquals(doubExpected, doubActual);
    }
    
    @Test
    public void 混合数() {
        //given
        double[] givenDoubles = {-1, -3, -2, -0.5, 0.5};
        int indexExpected = 5;
        double doubExpected = 0.5;
        int indexActual = 0;
        double doubActual = 0;
        
        //when
        ClosestToZero closesToZero = new ClosestToZero();
        Map<Integer, Double> map = closesToZero.getNumber(givenDoubles);
        Set<Integer> sets = map.keySet();
        for(Iterator<Integer> iter = sets.iterator(); iter.hasNext(); ) {
            indexActual = iter.next();
            doubActual = map.get(indexActual);
        }
        
        //then
        Assert.assertEquals(1, map.size());
        Assert.assertEquals(indexExpected, indexActual);
        Assert.assertEquals(doubExpected, doubActual);
    }
}

3.TDD

1.全是正数实现场景

public class ClosestToZero {
    public Map<Integer, Double> getNumber(double[] doubArray) {
        int index = 0;
        double maxNum = doubArray[0];
        Map<Integer, Double> map = new HashMap<>();
        for (int i = 0; i < doubArray.length; i++) {
            if(maxNum > doubArray[i]) {
                maxNum = doubArray[i];
                index = i;
            }
        }
        return map.put(index + 1, maxNum);
    }
}

2.全是负数实现场景

public class ClosestToZero {
    public Map<Integer, Double> getNumber(double[] doubArray) {
        int index = 0;
        double minNum = doubArray[0];
        double minNumAbs = Math.abs(minNum);
        Map<Integer, Double> map = new HashMap<>();
        for (int i = 0; i < doubArray.length; i++) {
            if(minNumAbs > Math.abs(doubArray[i])) {
                minNum = doubArray[i];
                minNumAbs = Math.abs(minNum);
                index = i;
            }
        }
        map.put(index + 1, minNum);
        return map;
    }
}

3.混合场景

public class ClosestToZero {
    public Map<Integer, Double> getNumber(double[] doubArray) {
        int index = 0;
        double minNum = doubArray[0];
        double minNumAbs = Math.abs(minNum);
        Map<Integer, Double> map = new HashMap<>();
        for (int i = 0; i < doubArray.length; i++) {
            if(minNumAbs > Math.abs(doubArray[i])) {
                minNum = doubArray[i];
                minNumAbs = Math.abs(minNum);
                index = i;
            }
            if(minNumAbs == Math.abs(doubArray[i])) {
                if(minNum < doubArray[i]) {
                    minNum = doubArray[i];
                    minNumAbs = Math.abs(minNum);
                    index = i;
                }
            }
        }
        map.put(index + 1, minNum);
        return map;
    }
}```