什么是真正的架构设计

一.什么是架构和架构本质
    在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。
    Linux有架构，MySQL有架构，JVM也有架构，使用java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块和组件、框架和架构：

  view

more >>

int和Integer区别

int和Integer区别
    1.Integer是int的包装类，int则是java的一种基本数据类型。
    2.Integer变量必须实例化后才能使用，而int变量不需要。
    3.Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。
    4.Integer默认值是null，int默认值是0。

  view

more >>

小吴读源码记录之HashMap 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

/**
 * The maximum capacity, used if a higher value is implicitly specified
 * by either of the constructors with arguments.
 * MUST be a power of two <= 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

个人理解：由此可以看出，默认初始长度为1*2^4=16；最大容器长度为2^30。

  view

more >>

小吴读源码记录之AbstractMap 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public boolean containsValue(Object value) {
  Iterator<Entry<K,V>> i = entrySet().iterator();
    if (value==null) {
      while (i.hasNext()) {
        Entry<K,V> e = i.next();
        if (e.getValue()==null)
          return true;
      }
    } else {
      while (i.hasNext()) {
        Entry<K,V> e = i.next();
          if (value.equals(e.getValue()))
            return true;
      }
    }
  return false;
}

public boolean containsKey(Object key) {
  Iterator<Map.Entry<K,V>> i = entrySet().iterator();
  if (key==null) {
    while (i.hasNext()) {
      Entry<K,V> e = i.next();
      if (e.getKey()==null)
        return true;
    }
  } else {
    while (i.hasNext()) {
      Entry<K,V> e = i.next();
      if (key.equals(e.getKey()))
        return true;
    }
  }
  return false;
}

个人理解：判断是否包含某个key或者某个value，都是先取得map的迭代器，然后判断入参，再相应的判断key/value是否相等。

  view

more >>

小吴读源码记录之Vector 

1
2
3
4
5
6
7
public Vector(int initialCapacity, int capacityIncrement) {
  super();
  if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
  this.elementData = new Object[initialCapacity];
  this.capacityIncrement = capacityIncrement;
}

个人理解：由此可见，Vector底层为数组，所以具有查询快，读写慢的特点。

  view

more >>

小吴读源码记录之LinkedList 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public LinkedList(Collection<? extends E> c) {
  this();
  addAll(c);
}

public LinkedList() {
}

public boolean addAll(Collection<? extends E> c) {
  return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
  checkPositionIndex(index);

  Object[] a = c.toArray();
  int numNew = a.length;
  if (numNew == 0)
    return false;

  Node<E> pred, succ;
  if (index == size) {
    succ = null;
    pred = last;
  } else {
    succ = node(index);
    pred = succ.prev;
  }

  for (Object o : a) {
    @SuppressWarnings("unchecked") 
		E e = (E) o;
    Node<E> newNode = new Node<>(pred, e, null);
    if (pred == null)
      first = newNode;
    else
      pred.next = newNode;
    pred = newNode;
  }

  if (succ == null) {
    last = pred;
  } else {
    pred.next = succ;
    succ.prev = pred;
  }

  size += numNew;
  modCount++;
  return true;
}

private void checkPositionIndex(int index) {
  if (!isPositionIndex(index))
    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

个人理解：由此可见LinkedList底层为链表，所以具有查询慢，读写快的特点。

  view

more >>

小吴读源码记录之ArrayList 

1
2
3
4
5
6
7
8
9
public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
  } else if (initialCapacity == 0) {
    this.elementData = EMPTY_ELEMENTDATA;
  } else {
    throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
  }
}

个人理解：1.当入参大于0时，则声明一个长度为入参的集合；当入参等于0时，则声明一个空数组{}；当入参小于0，则抛出异常。
2.由此可以看出ArrayList的底层是数组，所以具有查询快，增删慢的特点。

  view

more >>

小吴读源码记录之AbstractList 

1
2
3
4
5
6
7
8
9
10
11
12
public boolean add(E e) {
  add(size(), e);
  return true;
}

public void add(int index, E element) {
  throw new UnsupportedOperationException();
}

public E remove(int index) {
  throw new UnsupportedOperationException();
}

个人理解：AbstractList没有add与remove的方法，使用则会抛出异常。

  view

more >>

小吴读源码记录之AbstractCollection 

1
2
3
4
5
6
7
8
9
10
11
12
13
public boolean contains(Object o) {
  Iterator<E> it = iterator();
  if (o==null) {
    while (it.hasNext())
      if (it.next()==null)
        return true;
  } else {
    while (it.hasNext())
      if (o.equals(it.next()))
        return true;
  }
  return false;
}

个人理解：如果传进来的参数为null，会通过迭代该集合，如果有null的则返回true。如果传进来的参数不为null，则还会迭代该集合，通过equals比较，如果相等则返回true。

  view

more >>