Day01 Java中级03 集合框架 04泛型 05Lambda

ArrayList

1. 
        比数组多了个容量（capacity）的概念，数组的长度是固定的，而ArrayList 会自动增加，所以存放对象时，用ArrayList

2.常用的方法

      这里都是先提前重写了对象内部的toString方法，返回的是对象的名字
     import java.util.ArrayList;
                增加             add(2,object);               // 在下标为2处添加对象
                获得对象     get(2);                           //获得下标为2处的对象
                contains();     indexOf();                   //前者是是否包含，后者是获得对象在集合的下标，注：括号给的对象具体是看该引                                                                           //用中存的对象地址，而与引用的名字是否相同无关。
                 删除               remove();                  //括号可以写对象在集合中的下标，也可以写数组集合对象的名字
                 替换              set(2,object);              //把集合中下标为2的对象替换成object
                 大小                 .size();                     //一个方法

冒泡法，选择法，二叉树性能比较

   创建1W个随机数，分别用三种方法排序，比较消耗时间：
            做这个练习的时候，我先在纸上大致写了一个思路：
                   1.创建一个数组，然后用for循环遍历，给它一个一个的复制。
                  这里用到了Math.random()的方法。

                   2.三种排序方法，在每次排序前，因为直接排序的话，后边的方法排的数组就是前边方法排好后的，
                 所以这里先提前定义一个中间数组，在每次排序之前，都接收一次原数组。

                   3.因为要记录每次时间，所以创建一个记录时间的方法，这时候就考虑到因为有三种方法，所以将三种排序方法定义                  方法定义成内部类，都实现一个接口（排序），利用了多态的原理，这样只需要把参数传给记录时间的方法，在下面                     这个方法里用结束时间减去开始时间就得到了用时，这里在记时中间调用了内部类的排序方法。最后返回排序后的数                    组。这个方法把第二个参数传进来只是为了在打印时间的时候，注明是哪种方法。

[code]private static int[] method(Sort algorithm, String type) {
long start = System.currentTimeMillis();
algorithm.sort();
int sortedNumbers[] = algorithm.values();
long end = System.currentTimeMillis();
。。。。。。。

}

HashMap

   用键值对的方式存储数据，key,value 
    import java.util.HashMap
                 HashMap<String,int>   xxx =  new HashMap<>;
                 put(String,int)        //这个方法是String作为key，放String对应的value，若已经有了，则覆盖。


取一定长度的随机字符
   String str = randomString(5);

[code]private static String randomString(int length) {
String pool = "";
for (short i = '0'; i <= '9'; i++) {
pool += (char) i;
}
for (short i = 'a'; i <= 'z'; i++) {
pool += (char) i;
}
for (short i = 'A'; i <= 'Z'; i++) {
pool += (char) i;              //poor = "0123456789...Z";
}
char cs[] = new char[length];
for (int i = 0; i < cs.length; i++) {
int index = (int) (Math.random() * pool.length());
cs[i] = pool.charAt(index);
}
String result = new String(cs);
return result;
}

Collections
   impot java.util.reverse
             Collections.reverse(numbers);               //将集合中数据反转
             Collections.shuffle(numbers);                //混淆
             Collections.sort(numbers);                     //排序
             Collections.reverse(numbers，0，1);    //交换下标0和1的数据
             Collections.rotate(numbers，2);             //向右滚动指定单位的长度
            

泛型

           通配符： ？extends     ?super     ?
                    当只取出不插入时，使用？extends
                    当只插入不取出时，使用？super
                    想取出和插入，就不使用通配符

            子类泛型不能够转换成父类泛型，因为父类泛型不确定，他有可能是父类，也有可能是父类的其他子类。

Lambda

             从匿名类演变成Lambda表达式

[code]IsObject o1 = new IsObject() {
public boolean test(Object o) {
return (o.name>20 && o.length<5);
}
};

//只留下方法参数与方法体
IsObject o1 = (Object o) ->{
return o.name>20 && o.length<5;

};

IsObject o1 = (Object o) -> o.name>20 && o.length<5;

IsObject o1 = o -> o.name>20 && o.length<5;

//传参的时候
check(objects,o1);

check(objects,o -> o.name>20 && o.length<5);