java面向对象之查找

这篇文章的代码示例不再使用基本类型，而是更深入一些，模拟实际开发中的场景，oop的代码比较多，所以把java和C#拆成了两篇文章，以一个骨灰级的模型为切入点，在一个存放若干对象的表结构中查找指定的那个对象，javascript代码实现，性别枚举值使用注释约束，也可以使用代码约束，这里简化了，复制到浏览器控制台看输出

//初始化数据源，使用对象字面量快速赋值
//var genders = {1: "男", 2: "女"}
var people = [
    {
        name: "小萌",
        gender: 1,
        age: 10
    },
    {
        name: "小强",
        gender: 1,
        age: 23
    },
    {
        name: "小爱",
        gender: 2,
        age: 15
    },
    {
        name: "小A",
        gender: 2,
        age: 18
    }
]

//找到名字中有A的女性
var result1 = people.find(
    function (e) {
        return e.name.indexOf("A") > 0 && e.gender === 2;
    }
)

//找到所有年龄10岁以上的男性
var result2 = people.filter(
    function (e) {
        return e.gender === 1 && age > 10;
    }
)

console.log(result1, result2)

find和filter和上一篇用到的map一样都是数组原型中的高阶函数，他接收一个函数作为参数，对数组中的每一个元素做函数操作，他的返回是bool求值表达式，这个表达式就是查找条件，也就是每次使用对象做求值操作，找到使值为true的对象，find只返回第一个符合条件的对象，而filter返回所有符合条件的对象，注意find是es6的新增函数，如果考虑兼容请使用filter

class Person {
        private String name;
        private int gender;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getGender() {
            return gender;
        }

        public void setGender(int gender) {
            this.gender = gender;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public Person(String name, int gender, int age) {
            this.name = name;
            this.gender = gender;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", gender=" + gender +
                    ", age=" + age +
                    '}';
        }
    }

回到强类型的java，java要使用自定义对象必须设置对象模板，就是所谓的Class，所以代码量比弱类型的js多，Class大部分是由IDE生成的祖传代码，这部分很多java coder闭着眼睛用记事本都能敲得出来了吧，这里省略了equal和hashCode这两个常用的方法

public class Main {

    //工厂方法
    public static Person giveMePerson(String name, int gender, int age) {
        return new Person(name, gender, age);
    }

    public static void main(String[] args) {
        Person[] ps = new Person[]{
                giveMePerson("小萌", 1, 10),
                giveMePerson("小强", 1, 23),
                giveMePerson("小爱", 2, 15),
                giveMePerson("小A", 2, 18)
        };

        Person person = Arrays.stream(ps).filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getName().contains("A") && person.getGender() == 2;
            }
        }).findFirst().get();

        Object[] objects = Arrays.stream(ps).filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() > 1 && person.getGender() == 1;
            }
        }).toArray();

        System.out.println(person);
        System.out.println(Arrays.toString(objects));
    }
}

这里可以很直观的看到强类型和弱类型语言的风格对比，java使用很多的声明保证类型的一致性，这在大型应用中可以极大减慢代码腐烂的速度，这里用到了一个工厂方法，实际是对构造方法的封装，然后怎么说呢，对于filter这样的常用操作，用java写出来不太好看比较臃肿，不知道有没有更好的写法，下篇C#的linq则简洁很多