ARTS 打卡 (20.08.17-20.08.23)

 关注
发布于: 2020 年 08 月 23 日
AlgorithmLeetCode 11 Container With Most Water  
1.暴力解法 
时间复杂度 O(n^2)
空间复杂度O(1)
public int maxArea(int[] height) {
        int result = 0;
        if (height.length <= 1) {
            return result;
        }
        for (int start = 0; start < height.length - 1; start++) {
            for (int i = start + 1; i < height.length; i++) {
                int temp = height[start];
                if (height[start] > height[i]) {
                    temp = height[i];
                }
                int container = (i - start) * temp;
                if (container > result) {
                    result = container;
                }
            }
        }
        return result;
    }
2.双指针法
思路：短板需要向内部移动
时间复杂度 O(n)
空间复杂度O(1)
 public int maxArea(int[] height) {
        int i = 0, j = height.length - 1, res = 0;
        while(i < j){
            res = height[i] < height[j] ? 
                Math.max(res, (j - i) * height[i++]): 
                Math.max(res, (j - i) * height[j--]); 
        }
        return res;
    }
﻿
Review：Effective Java（第三版）英文版
Item2：
当构造器参数过多时考虑建造模式
构造函器参数过多时，构造函数也会相应增加，那个构造函数初始化那些参数会变得凌乱不堪，我们可以考虑JavaBean模式，只定义一个无惨构造函数，提供set方法，但是这种模式有一个致命的缺陷，这个缺陷就是多次调用set方法会导致对象状态不一致的情况出现，如果一个线程在set属性，而另外一个线程使用了该对象，很有可能出现对象构造不彻底就使用了该对象，引发BUG，你可以在构造对象的过程中使用锁，但是这种方法很少有人用，也非常笨拙。
我们可以用建造者模式来实现Bean的初始化，既能保证Bean状态的一致性又可以优雅的初始化Bean的属性。我们使用一个静态内部类来充当这个建造者，内部类的构造器可以指定出外部类所需的必要参数，将静态内部类对象作为参数传递给外部类的构造器，由外部构造器初始化外部类参数，内部类参数设置返回值为内部类对象，进而可以实现链式调用。
例：
public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;
    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;
        // Optional parameters - initialized to default values
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;
        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
        public Builder calories(int val) {
            calories = val;
            return this;
        }
        public Builder fat(int val) {
            fat = val;
            return this;
        }
        public Builder sodium(int val) {
            sodium = val;
            return this;
        }
        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
  	public static void main(String[] args) {
        NutritionFacts nutritionFacts = new Builder(10, 15).calories(15).build();
    }
}
﻿
Tip：java泛型的自限定
例：
public class SelfBounded<T extends SelfBounded<T>>{
//....
}
强制泛型当作其自己的边界参数来使用，也就是说自己就是边界，运行期可以明确类型了。
﻿
Share：最近的工作是跟mybaties相关的，想做个插件，必须先知道原理，分享两片文章，分别介绍了mybaites和配置文件xml的解析过程
https://cloud.tencent.com/developer/article/1173100
https://cloud.tencent.com/developer/article/1173104
﻿
发布于: 2020 年 08 月 23 日阅读数: 168
小王同学

 关注
还未添加个人签名 2019.03.04 加入
还未添加个人简介
发布
暂无评论