Think in java-Array16

对于数组我们可以使用Arrays.fill()进行填充或者部分填充，但是这种方式只能填充称为单一的值，不能动态生成，所以需要编写生成器进行数据的生成。

1.按照顺序生成的生成器

package com.mao.thinkinjava.generator;

public class CountingGenerator {
    //private static Random rm = new Random(47);
    public static class Character implements Generator<java.lang.Character>{
        public  static char[] chars = ("abcdefgh"+"ABCDEFG").toCharArray();
        int value = -1;
        @Override
        public java.lang.Character generate() {
            value=(value+1)%chars.length;
            return chars[value];
        }
    }

    public static class String implements Generator<java.lang.String> {
        //后面RandomGenerator这里可以进行替换
         Generator<java.lang.Character> cg = new Character();
        private int length = 4;
        public String(){}
        public String(int length){this.length = length;}
        @Override
        public java.lang.String generate() {
            char[] res = new char[length];
             //错误写法，不能用于赋值
//            for(char c : res){
//                c = cg.generate();
//            }
            for(int i=0;i<length;i++){
                res[i] = cg.generate();
            }
            return new java.lang.String(res);
        }
    }
}

2.按照随机的策略进行生成

package com.mao.thinkinjava.generator;

import java.util.Random;

public class RandomGenerator {
    public static Random rm = new Random(47);
    public static class Character implements Generator<java.lang.Character>{
        char[] chars = CountingGenerator.Character.chars;//复用了CountingGenerator里面的。
        @Override
        public java.lang.Character generate() {
            return chars[rm.nextInt(chars.length)];
        }
    }

    public static class String extends CountingGenerator.String{
        { cg = new Character(); } //这是父类的成员变量，必须写在初始化块。
        public String(){}
        public String(int length){super(length);}
    }
}

3.测试类

package com.mao.thinkinjava.generator;

public class TestGenerator {
    public  void test(Class<?> generatorsClass){
        //generatorsClass 也算是一个对象，所以他也可以getClass，结果就是class java.lang.Class
        //可以这么理解Class是JDK里面的一个类，这个类的对象可以容纳别的类的字节码，Class类本身就有字节码。
//        Class<Class> aClass = (Class<Class>) generatorsClass.getClass();
//        System.out.println(aClass);
        Class<?>[] classes = generatorsClass.getClasses();
        for(Class clazz : classes){
            try {
                Generator<?> gen = (Generator<?>)clazz.newInstance();
                System.out.println(gen.getClass());
                for(int i=0;i<10;i++){
                    Object generated = gen.generate();
                    System.out.println(generated);
                }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        new TestGenerator().test(RandomGenerator.class);
    }
}

对于不同的生成需求只需要更改生成器即可，不同的生成器代表不同的生成策略。

4.Collection.reverseOrder()

Integer[] a = {1,2,4,4,5,6};
Comparator<Object> objectComparator = Collections.reverseOrder();
//这里对于实现了Comparable的对象，Collections.reverseOrder()才有效果。Arrays.sort(a,objectComparator);
System.out.println(Arrays.toString(a));

5.使用生成器生成对象数组

public class Generated {
   public static <T> T[] array(T[] a,Generator<T> gen){
       for(int i=0;i<a.length;i++){
           a[i] = gen.generate();
       }
       return a;
   }

   public static <T> T[] array(Class<T> clazz,Generator<T> gen,int size){
       //这样行不通，因为类型擦除；
      // T[] a = new T[size];
       T[] a = (T[])java.lang.reflect.Array.newInstance(clazz,size);
       for(int i=0;i<a.length;i++){
           a[i] = gen.generate();
       }
       return a;
   }

    public static void main(String[] args) {
        Character[] chars = Generated.array(new Character[10], new CountingGenerator.Character());
        System.out.println(Arrays.toString(chars));
        String[] ss = Generated.array(String.class, new CountingGenerator.String(),10);
        System.out.println(Arrays.toString(ss));
    }
}

题外：lambada

• lambada实际类型是接口，本质是将一段代码赋值给了一个变量。

		 Comparable<Integer> com=(a)->a;
        int i = com.compareTo(3);
        System.out.println(i);

        //lambada类似于C++里面的回调函数。
        Comparator<Integer> comparator = (o1,o2)->o1-o2;
        int compare = comparator.compare(3, 4);
        System.out.println(compare);