工作之余第二篇（看源码自己实现ArrayList和LinkList）
先看源码：
首先看构造器，构造器有三种，一种直接给定初始长度的，如下代码
public ArrayList(int initialCapacity) { if (initialCapacity > 0) { //判断长度是否大于0 如果大于0 则直接将长度给他 this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { //如果等于0，定义一个空数组实例 this.elementData = EMPTY_ELEMENTDATA; } else { //否则就抛出异常 为负数 throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity); } }
第二种构造函数是不给定长度的，如下代码
public ArrayList() { //直接给定一个空数组实例 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
第三种构造函数，直接包含指定元素的构造器，放一个集合，如下
public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); //集合直接转换为数组 if ((size = elementData.length) != 0) { //在数组长度不为0的情况下 // c.toArray might (incorrectly) not return Object[] (see 6260652) 在c.toArray之后返回的可能不是一个数组是需要进行下一步操作 if (elementData.getClass() != Object[].class)
//通过copyOf将其转换为数组 elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array.如果为0只直接替换一个空数组 this.elementData = EMPTY_ELEMENTDATA; } }
然后就是开始看添加了。
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! 标红的方式是要确定定义数组的容量是否足够，接下来有分析 elementData[size++] = e; //size是定义的全局变量 没进行一次赋值 size++之后会改变哟，每增加一个值的时候就加1，第一次赋值是size是0，赋值完成后加1，第二次size就是1了。 return true; }
private void ensureCapacityInternal(int minCapacity) { //这个minCapacity代表上边标红方法中的size+1,这个需要记住哟 ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); //接下来先介绍红色方法，介绍完后在介绍绿色方法。 }
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //这个就是一个空数组实例
private static int calculateCapacity(Object[] elementData, int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //判断如果是一个空数组实例的话 就拿数组默认长度值（10）来和size+1的值作比较，谁大取谁 return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; //不为空则直接返回size+1的值 }
接下来介绍绿色方法了。
private void ensureExplicitCapacity(int minCapacity) { modCount++; //修改次数，具体用途还不清楚，下边有解释 // overflow-conscious code if (minCapacity - elementData.length > 0) //判断size+1是否大于数组缓冲区的长度，如果大于则进行扩容了 grow(minCapacity); //grow这个方法就要开始扩容了 }
private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; //首先把最初的数组长度暂存 int newCapacity = oldCapacity + (oldCapacity >> 1); //最初的数组长度正常一半的长度赋给newCapacity if (newCapacity - minCapacity < 0) //再次进行判断 如果长度还是不够 newCapacity = minCapacity; //那么就直接将长度给size+1这个值 if (newCapacity - MAX_ARRAY_SIZE > 0) //数组也有默认的最大值，如果超出就要进行处理 newCapacity = hugeCapacity(minCapacity); //红色方法则是对于超出默认最大值的处理 // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); //在确定新数组长度之后就需要将原来已存在数组复制到新数组中，从而保证扩容后不会丢失原来的数据 }
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //这个值就是数组默认定义的最大值，下边有详细解释
private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? //检查是否超出数组最大值，如果超出了就将最大值给他，没有超出则给减去8之后的最大值。 Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
以上就是添加方法了。带参数的其他添加跟这个类似，不过添加了下标验证。如下
public void add(int index, E element) { rangeCheckForAdd(index); //验证数组下标是否越界 ensureCapacityInternal(size + 1); // Increments modCount!! //检查是否需要扩容 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }
addAll同上，先判断是否扩容以及扩容的大小，然后进行arraycopy
public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount 先进行扩容 System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; }
获取元素：
public E get(int index) { rangeCheck(index); //先检查下标是否在数组下标范围内，然后就取值 return elementData(index); }
private void rangeCheck(int index) { //下标超出 报异常 if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
删除元素：
public E remove(int index) { rangeCheck(index); //检查下标 modCount++; E oldValue = elementData(index); //先将原来的数组保存 int numMoved = size - index - 1; //需要移动的值 if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // clear to let GC do its work return oldValue; }
以下是自己实现的代码，比较粗糙
package com.interact.test.webService; import java.util.Arrays; public class ArrayListTest { Object [] arr = new Object[default_size]; private static int size = 0; private static int default_size = 10; public int getSize(){ return size; } //获取元素 public Object getIndex(int index){ //需要校验index的值，是否大于0并且小于最大长度 if(index >= 0 && index < arr.length){ return arr[index]; }else{ return "数组下标越界"; } } //添加元素 public void add(Object o){ if(size >= default_size){ //默认长度不够的时候 进行扩容 default_size += default_size/2; //扩容到原来长度的1.5倍，就是就是加上原来长度的一半 } arr = Arrays.copyOf(arr,default_size); //扩容之后通过底层的复制数组的方法，将之前保存的数据放到扩容之后的数组中 arr[size++] = o; } public void remove(int index){ Object [] temp = new Object[size-1]; if(index >= 0 && index <= size){ //先进行校验 for (int i = 0; i < index; i++) { temp[i] = arr[i]; } for (int i = index + 1; i < size ; i++) { temp[i-1] = arr[i]; } }else{ System.out.println("下标越界"); } arr = Arrays.copyOf(temp,size-1); size--; } public static void main(String [] args){ ArrayListTest arrayListTest = new ArrayListTest(); for (int i = 0; i < 16; i++) { arrayListTest.add(i); } arrayListTest.remove(3); for (int i = 0; i < arrayListTest.getSize(); i++) { System.out.println(arrayListTest.getIndex(i)); } } }
native关键字的作用
告诉编译器调用的方法是外部定义的，一般是指C写的底层方法。主要意思是java调用java以外的方法的标示。
毫秒以下的单位以及进度
微秒，纳秒，皮秒跟毫秒一样进度为1000,1000毫秒=1秒，1000微秒=1毫秒，1000皮秒=1微秒。
OutOfMemoryError
内存溢出，给定长度满足不了实际长度时就会导致内存溢出。
为什么有时候一下异常throw出去了，但是却没有在函数头部声明
异常分两种，Checked异常和Runtime异常，在使用checked异常时需要在函数头部声明，而Runtime异常则不需要，主要当发生非运行时异常你就需要try catch进行捕获，告诉你哪里出问题了，从而进行修改。而运行时异常，则是在运行过程中才可能出现的异常，编辑器无法帮助你定位，所以即使你声明throw，然后再由调用者try catch捕获也没有用，所以就不再需要在函数头部就行声明。
最大数组大小定义为Integer.MAX_VALUE - 8，减去8的原因
因为要存储2^31 = 2,147,483,648这些长度的数组需要8bytes，所以给定最大长度为Integer.MAX_VALUE - 8。
java中的>> <<的作用
位运算符，转换为二进制，左位移运算符，右位移运算符，三个>>>的跟两个的一样。
java的访问修饰符
public 同类同包不同包的子类不同包的非子类可以使用
protectd 同类同包不同包的子类可以使用
default 同类同包中可以使用
private 只有同类中可以使用
modCount
修改次数，找了找资料，理解之后的大概意思就是，ArrayList不是线程安全的，使用迭代器时，其他线程可能会同时对其进行修改，这时候就会报异常，ConcurrentModificationException，也就是所谓fail-fast策略。而这个策略实现的方式就是，modCount每次修改就会加1，而每次初始化就将这个值暂存起来，放到expectedModCount这个变量中，在迭代过程中会进行比较，如果一样则没问题，不相同则报异常。注意到 modCount 声明为 volatile，保证线程之间修改的可见性。
volatile
编译器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份，并且防止拿到的数据是编译器优化之后的代码。其实就是拿到最真实实时的数据。
泛型的实现原理
主要是类型擦除，在编译成字节码文件时，字节码文件是不包含泛型中的类型信息的，会将类型擦除掉。
还需要理解，参考链接：https://blog.csdn.net/aoxida/article/details/50774459
linkList的实现（已完善）
package com.interact.test.webService; public class LinkListTest { private static int size = 0; private static Node first; private static Node last; private static Node[] objects = new Node[100]; //用来存储数据 //定义一个静态内部类 private static class Node { private String current; private Node next; private Node prev; Node(String current, Node next, Node prev) { this.current = current; this.next = next; this.prev = prev; } } public void add(Object o) { Node temp = last; Node newNode = new Node(o.toString(), null, temp); last = newNode; if (temp == null) { first = newNode; } else { temp.next = newNode; } objects[size++] = newNode; //用数组存数据是否有问题 } public Object getIndex(int index) { //可能有问题 if(index < (size >> 1)){ //如果index小于总长度的一半 则从第一个开始找，从前往后推 Node node = first; for (int i = 0; i < index; i++) { node = objects[i].next; } return node.current; }else{ //如果index大于总长度的一半 则从最后一个开始找，从后往前推 Node node = last; for (int i = size-1; i > index; i--) { //这里需要注意 当寻找的下标大于总长度一半的时候 不再是从0开始，而且i开始逐渐减去1 node = objects[i].prev; } return node.current; } } public void linkFirst(String element){ //将该值作为第一个节点 Node node = first; //先将当前第一个值暂时保存 Node newNode = new Node(element,node,null); //通过Node构造器获取一个新的节点 first = newNode; //然后将新的节点给全局变量第一个节点first if(node == null){ //如果node是空的，也就说明当前first是空的，说明当前linkList没有值 last = newNode; //此时第一个节点是刚创建的新节点，最后一个也是这个新节点 }else{ node.prev = newNode; //如果不是空的，那么当前第一个节点的前一个节点应该是null，此时就需要将这个新的节点设置为之前第一个节点的前节点 } size++; } public void remove(Object o) { for (int i = 0; i < size; i++) { if (objects[i].current.equals(o)) { final Node prev = objects[i].prev; //前一个节点 final Node next = objects[i].next; prev.next = next; //将前一个节点的下一个节点设置成当前节点的下一个节点，从而达到连接后面节点的效果 next.prev = prev; //同样将要移除节点的前一个节点设置为移除节点的前一个节点。 objects[i].current = null; //进行垃圾回收 objects[i] = null; size--; } } } public static void main(String[] args) { LinkListTest listTest = new LinkListTest(); listTest.add("111"); listTest.add("222"); listTest.add("333"); listTest.add("444"); listTest.add("555"); listTest.add("666"); System.out.println(listTest.getIndex(1)); System.out.println(listTest.getIndex(4)); listTest.remove("222"); listTest.linkFirst("999"); System.out.println(listTest.getIndex(1)); System.out.println(listTest.getIndex(0)); } }
vue组件：主要是拆分代码，减少vue实例的代码量，方便ui的重用。
vue创建组件的方式，Vue.component(组件名称，组件构造器)，跟创建Vue对象相似，同样有data、methods、watch等，但是组件的data必须是一个函数，而且没有el获取根实例。
如下代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script src="vue.js" type="text/javascript"></script>
</head>
<body>
<div id="app">
<my-com></my-com>
</div>
<script type="text/javascript">
Vue.component("myCom",{
//data必须是一个函数
data :function(){
return{
count:0
}
},
template:"<button v-on:click='count++'>点击了{{count}}次</button>"
})
var vm = new Vue({
el:"#app"
})
</script>
</body>
</html>
还有通过extend的几种方式来实现的
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script src="vue.js"></script>
</head>
<body>
<div id="app">
<my-com></my-com>
<mycom2></mycom2>
<mycom3></mycom3>
<mycom4></mycom4>
</div>
<template id="temp">
<div >
<h1>第四种组件的实现方式</h1>
<h2>这种写法的好处是能够提示信息</h2>
</div>
</template>
<script>
var com1 = Vue.extend({
template:'<h1>组件的第一种实现方式</h1>'
})
Vue.component('myCom',com1)
Vue.component('mycom2',Vue.extend({
template:'<h2>组件的第二种实现方式</h2>'
}))
Vue.component('mycom3',{
template:'<h3>组件的第三种实现方式</h3>'
})
Vue.component('mycom4',{
template:"#temp"
})
var vm = new Vue({
el:"#app"
})
</script>
</body>
</html>
组件是通过prop来进行数据传递的。
