我喜欢你喜欢我的歌

JVM 1.0

2018-02-01

1.Java程序执行流程

Java技术的核心就是Java虚拟机，因为所有的Java程序都在虚拟机上运行。Java程序的运行需要Java虚拟机、Java API和Java Class文件的配合。Java虚拟机实例负责运行一个Java程序。当启动一个Java程序时，一个虚拟机实例就诞生了。当程序结束，这个虚拟机实例也就消亡。

分为编译时环境和运行时环境，很基础很重要。

架构演变背景

2018-01-01

架构演变背景

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

修改jar包中的配置文件

2017-12-01

修改jar包中的配置文件

一通过vim命令直接修改保存jar。超方便。

1.通过vim命令直接编辑jar
vim xxx.jar 该命令首先会列出全部文件，可以通过输入/abc来搜索，定位到对应的abc文件后回车进入配置文件内进行编辑，:wq保存。

二通过jar命令替换jar包中的文件(也可新增)

1.列出jar包中的文件清单
jar tf client.jar

2.提取出内部jar包的指定文件
jar xf client.jar BOOT-INF/classes/realtime/t_ivr_data_bj.json

3.然后可以修改文件
vim BOOT-INF/classes/realtime/t_ivr_data_bj.json

4.更新配置文件到内部jar包.(存在覆盖，不存在就新增)
jar uf client.jar BOOT-INF/classes/realtime/t_ivr_data_bj.json

4.1更新内部jar包到jar文件
jar uf client.jar 内部jar包.jar

5.可以查看验证是否已经更改
vim client.jar

Java 使用数组实现栈

2017-05-11

使用数组实现栈

自己实现一个栈，要求这个栈具有push()、pop()（返回栈顶元素并出栈）、peek() （返回栈顶元素不出栈）、isEmpty()、size()
这些基本的方法。

提示：每次入栈之前先判断栈的容量是否够用，如果不够用就用Arrays.copyOf()进行扩容；


package program;

import java.util.Arrays;

public class MyStack {

	/*
	 * 使用数组实现栈： 自己实现一个栈，要求这个栈具有push()、pop()（返回栈顶元素并出栈）、peek()
	 * （返回栈顶元素不出栈）、isEmpty()、size()这些基本的方法。
	 * 提示：每次入栈之前先判断栈的容量是否够用，如果不够用就用Arrays.copyOf()进行扩容；
	 */

	/*
	 * 存数据的数组
	 */
	private int[] storage;

	/*
	 * 容量
	 */
	private int capacity;

	/*
	 * 元素个数
	 */
	private int count;

	/*
	 * 每次以当前容量进行扩容
	 */
	private static final int GROW_FACTOR = 2;

	// TODO：默认构造函数
	public MyStack() {
		this.capacity = 8;
		this.count = 0;
		this.storage = new int[8];
	}

	// TODO：带初始容量的构造方法
	public MyStack(int initialCapacity) {
		if (initialCapacity < 1)
			throw new IllegalArgumentException("Capacity too small.");

		this.capacity = initialCapacity;
		this.storage = new int[initialCapacity];
		this.count = 0;
	}

	// TODO： 入栈
	public void push(int value) {
		if (count == capacity) {
			scrollUpCapacity();
		}
		storage[count++] = value;		
	}

	// TODO: 扩容
	private void scrollUpCapacity() {
		int newCapacity = capacity * GROW_FACTOR;
		storage = Arrays.copyOf(storage, newCapacity);
		capacity = newCapacity;
	}

	// TODO： 返回栈顶元素(出栈)
	public int pop() {
		count--;
		if (count == -1) {
			throw new IllegalArgumentException("Stack is empty.");
		}
		return storage[count];
	}

	// TODO： 返回栈顶元素(不出栈)
	public int peek() {
		if (count == 0) {
			throw new IllegalArgumentException("Stack is empty.");
		} else {
			return storage[count - 1];
		}
	}

	// TODO: 判断是否为空
	public boolean isEmpty() {
		return count == 0;
	}

	// TODO: 返回长度(元素个数)
	public int size() {
		return count;
	}

	public static void main(String[] args) {
		MyStack myStack = new MyStack(3);
		myStack.push(1);
		myStack.push(2);
		myStack.push(3);
		myStack.push(4);
		myStack.push(5);
		myStack.push(6);
		myStack.push(7);
		myStack.push(8);
		System.out.println(myStack.peek());// 8
		System.out.println(myStack.size());// 8
		for (int i = 0; i < 8; i++) {
			System.out.println(myStack.pop());
		}
		System.out.println(myStack.isEmpty());// true
		myStack.pop();// 报错：java.lang.IllegalArgumentException: Stack is empty.

		myStack.push(520);
	}

}

Java 实现最小值函数

2017-05-11

实现最小值函数

自己设计一个泛型的获取数组最小值的函数.并且这个方法只能接受Number的子类并且实现了Comparable接口。

//注意：Number并没有实现Comparable
private static <T extends Number & Comparable<? super T>> T min(T[] values) {
    if (values == null || values.length == 0) return null;
    T min = values[0];
    for (int i = 1; i < values.length; i++) {
        if (min.compareTo(values[i]) > 0) min = values[i];
    }
    return min;
}

测试：

1
2
3

int minInteger = min(new Integer[]{1, 2, 3});//result:1
double minDouble = min(new Double[]{1.2, 2.2, -1d});//result:-1d
String typeError = min(new String[]{"1","3"});//报错

Java IO

2017-04-15

#Java IO

Java 中 IO 流分为几种?

java 中 IO 流分为几种?
按照流的流向分，可以分为输入流和输出流；
按照操作单元划分，可以划分为字节流和字符流；
按照流的角色划分为节点流和处理流。

Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系，
Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

字符： Reader/Writer
字节： InputStream/OutputStream

BIO,NIO,AIO 有什么区别?

BIO (Blocking I/O):

同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，
这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。
线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，
传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

NIO (New I/O):

NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。
NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的
Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和
非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。
对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；
对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发。

AIO (Asynchronous I/O):

AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，
也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的
业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，
我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

异常处理

2017-04-10

异常处理

分类：
====StackOverFlowError(栈溢出)

                    ====VirtualMachineError

                                            ====OutOfMemoryError  (内存溢出)
==== Error

                    ====AWTError

Throwable ======================================================

                                            ====EOFException

                    ====IOException

                                            ====FileNoFoundException

==== Exception   

                                            ====ClassNoFoundException

                                            ====NullPointerException

                    ====RuntimeException   ====IllegalArgumentException

                                            ====ArrayIndexOutOfBoundsException

                                            ====UnknownTypeException

                                            ====MissingResourceException

                                            ====ArrithmeticException(除数为0的异常 ArrithmeticException,就是运行时异常)

在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable：
有两个重要的子类：Exception（异常）和 Error（错误）
二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时
JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时
，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误
（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许
出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。
在 Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由
Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，
一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException （下标越界异常）。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

Throwable类常用方法

public string getMessage():返回异常发生时的详细信息
public string toString():返回异常发生时的简要描述
public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

关于 final 关键字的一些总结

2017-04-05

#关于 final 关键字的一些总结
final关键字主要用在三个地方：变量、方法、类。(初始化之后不能修改)

1.对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。.

2.当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

3.使用final方法的原因有两个。
第一个原因是把方法锁定，以防任何继承类修改它的含义;
第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。
但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。
类中所有的private方法都隐式地指定为final。

hashCode 与 equals

2017-04-04

hashCode 与 equals

hashCode（）介绍

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！

意义：可以快速找到所需要的对象。

为什么要有 hashCode？

我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，
同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。
但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。
如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。
这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

通过我们可以看出：hashCode() 的作用就是获取哈希码，也称为散列码；它实际上是返回一个int整数。
这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 在散列表中才有用，在其它情况下没用。
在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

hashCode（）与equals（）的相关规定

如果两个对象相等，则hashcode一定也是相同的
两个对象相等,对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的
因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，
则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

== 与 equals

2017-04-04

== 与 equals

== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，
引用数据类型==比较的是内存地址)。

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。

情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true
(即，认为这两个对象相等)。

public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 为一个引用
        String b = new String("ab"); // b为另一个引用,对象的内容一样
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 从常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一对象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }

Notice:

String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，
而 String 的 equals 方法比较的是对象的值。

当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，
如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

正确使用 equals 方法

// 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常
String str = null;
if (str.equals("dick")) {
  ...
} else {
  ..
}

运行上面的程序会抛出空指针异常，但是我们把第二行的条件判断语句改为下面这样的话，就不会抛出空指针异常，else 语句块得到执行。：

1	"dick".equals(str);// false

不过更推荐使用 java.util.Objects#equals(JDK7 引入的工具类)。

Objects.equals(null,"SnailClimb");// false

源码：

public static boolean equals(Object a, Object b) {
	// 可以避免空指针异常。如果a==null的话此时a.equals(b)就不会得到执行，避免出现空指针异常。
	return (a == b) || (a != null && a.equals(b));
}

架构演变背景

单一应用架构

垂直应用架构

分布式服务架构

流动计算架构

修改jar包中的配置文件

一 通过vim命令直接修改保存jar。超方便。

二 通过jar命令替换jar包中的文件(也可新增)

使用数组实现栈

实现最小值函数

Java 中 IO 流分为几种?

BIO,NIO,AIO 有什么区别?

BIO (Blocking I/O):

NIO (New I/O):

AIO (Asynchronous I/O):

异常处理

hashCode 与 equals

hashCode（）介绍

为什么要有 hashCode？

hashCode（）与equals（）的相关规定

== 与 equals

正确使用 equals 方法

一通过vim命令直接修改保存jar。超方便。

二通过jar命令替换jar包中的文件(也可新增)