1.jxl：对excle的操作

读取excle：

https://www.jb51.net/article/126282.htm
增删改查excle（对excle操作时）：

需要加一个,不然会报文件格式不正确的错误。
WritableWorkbook book=null;
//对excle的操作
..........
book.write();

https://blog.csdn.net/pyd950812/article/details/78491344

2.poi：

从工作簿(Excel)文件读取信息（适合初学者）

https://www.jianshu.com/p/4f08c27ca0c4

Java POI 操作Excel(读取/写入)（案例）

https://www.cnblogs.com/dzpykj/p/8417738.html

看了不少回答，发现大家都在说一些非著名的轮子，我来说一个最著名的轮子——java最好用的轮子，其实是JDK本身，经过25年的迭代，这轮子越来越大，越来越好用了。
然后吧，你经常使用的Spring mybatis 这类框架性质的东西，也是巨大而好用的轮子，都是属于久经沙场的轮子，不光好用，你还要掌握其中的原理和设计方式。
java好用的轮子不要太多，给你一些轮子及其适用范围，方便你随时使用。
1.最广泛而容易被忽略的轮子——jdk
2.广泛使用的框架性轮子——SpringMVC Spring Mybatis Spring boot Spring cloud.
3.代码编写工具类小轮子——apache commons
4.网络编程轮子——mina netty Grizzly
5.excel、pdf、word文件处理轮子——POI
6.条形码处理轮子——barcode
7.序列化轮子——hessian msgpack protobuf etc...
8.搜索轮子——为了方便你适用推荐个简单点的ElasticSearch
暂时先就这些，看看反应再决定更不更新。

前言：之前也看过一些JDK源码，不过没有留下痕迹，经久年月就淡忘了，现在的时机也差不多了，想再看一次，并且记录下来自己的感想，于是从自己使用最多最熟悉的地方开始！并且看的过程中，我希望自己思考一下如下的问题：
1：如果让我设计，我怎么玩？
2：原作者为什么这样设计？
3：它的底层实现是什么玩意？有什么特点？
4：平时使用的时候，需要注意些什么东西？
5：原设计有什么特别好玩的点？
注：玩的是JDK1.7版本
一：先上类的继承结构图
细细看上图，其实就能透露出一些关键的信息，比如：
1：实现Serializable接口，表示ArrayList是可序列化的
2：实现RandomAccess接口，表示ArrayList是可快速随机访问的
3：实现Cloneable接口，表示ArrayList是可以调用Object.clone方法的
4：实现Iterable接口，表示允许ArrayList使用迭代遍历的方式循环
二：再看一下他的底层实现数据结构
三：然后从源码中找点好玩的东西
从源码中可以看出ArrayList的底层数据结构是一个数组，所以，它所有的操作都是围绕着数组来玩的。
1)观察如下代码，我们可以了解到如下信息
private 表示不能被类外操作
transient 表示通过实现Serializable接口的方式来序列化时，被其标识的类变量可以不被序列化
Object[] 表示ArrayList的通用性
/*** The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
* DEFAULT_CAPACITY when the first element is added.*/
private transient Object[] elementData;
2)size表示数组中元素的个数，对于数组数据结构而言，数据长度相当重要
/*** The size of the ArrayList (the number of elements it contains).
*
*@serial
*/
private int size;
3)观察如下源码，我们可以看到如下信息
ArrayList的无参构造函数，初始化的数组对象是一个空数组
ArrayList的有参构造函数，初始化的对象是根据指定的空间大小来分配数组的空间的
ArrayList是一个动态扩展的数据集合从 grow 方法中可见一二，并且当它的空间不够的时候会扩展为(大概是这样他还有一些最大最小长度的判断逻辑)： 原总长度+原总长度的一半
当然ArrayList的元素的值也是有限的最大是 Integer.MAX_VALUE
/*** Shared empty array instance used for empty instances.*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/*** Constructs an empty list with an initial capacity of ten.*/
publicArrayList() {super();this.elementData =EMPTY_ELEMENTDATA;
}
/*** Constructs an empty list with the specified initial capacity.
*
*@paraminitialCapacity  the initial capacity of the list
*@throwsIllegalArgumentException if the specified initial capacity
*         is negative*/
public ArrayList(intinitialCapacity) {super();if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);this.elementData = newObject[initialCapacity];
}
/*** Appends the specified element to the end of this list.
*
*@parame element to be appended to this list
*@returntrue (as specified by {@linkCollection#add})*/
public booleanadd(E e) {
ensureCapacityInternal(size+ 1);  //Increments modCount!!
elementData[size++] =e;return true;
}
private void ensureCapacityInternal(intminCapacity) {if (elementData ==EMPTY_ELEMENTDATA) {
minCapacity=Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(intminCapacity) {
modCount++;//overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/*** Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
*@paramminCapacity the desired minimum capacity*/
private void grow(intminCapacity) {//overflow-conscious code
int oldCapacity =elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1);if (newCapacity - minCapacity < 0)
newCapacity=minCapacity;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 int hugeCapacity(intminCapacity) {if (minCapacity < 0) //overflow
throw newOutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/*** The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
4)观察如下源代码，可以看到ArrayList是可以放null的，并且删除元素涉及到数据的移位复制操作是比较耗费性能的
/*** Removes the first occurrence of the specified element from this list,
* if it is present.  If the list does not contain the element, it is
* unchanged.  More formally, removes the element with the lowest index
* i such that
* (o==null ? get(i)==null : o.equals(get(i)))
* (if such an element exists).  Returns true if this list
* contained the specified element (or equivalently, if this list
* changed as a result of the call).
*
*@paramo element to be removed from this list, if present
*@returntrue if this list contained the specified element*/
public booleanremove(Object o) {if (o == null) {for (int index = 0; index < size; index++)if (elementData[index] == null) {
fastRemove(index);return true;
}
}else{for (int index = 0; index < size; index++)if(o.equals(elementData[index])) {
fastRemove(index);return true;
}
}return false;
}
/** Private remove method that skips bounds checking and does not
* return the value removed.*/
private void fastRemove(intindex) {
modCount++;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
}
四：小结
通过观察ArrayList的源码，发现如下一些特点：
1：ArrayList的底层数据结构是数组，所有，数组这种数据结构的特点ArrayList应该也是具有的，这是他的本质
2：数组或者ArrayList这种数据结构的特点是，随机访问、循环遍历等性能好，指定位置插入或删除元素会涉及数组元素的复制，性能较差
3：ArrayList的底层数据是Object[]，所以，具有很好的通用性，null也是可以存入ArrayList中的
4：ArrayList在添加元素的时候，首先会进行容量检测，如果不够会进行动态扩容
5：ArrayList使用的非常之多，使用起来也非常简单，不过看源码并不复杂，但是有些东西如果完全弄清楚也非易事，下面我会补充一些内容以供扫除阅读源码产生的一些障碍

展开全部
java造车轮是写程序的意思
java里的new的英文意思就是"新的"的意思。在JAVA里就是创建一个新e69da5e6ba9062616964757a686964616f31333431373233的实例,或者说一个新的对象,
一个普通类在没有实例化之前,就是new之前,它的属性,方法等等在内存中都是不存在的。只有使用new了以后,这个类的一些东西在内存中才会真的存在,也就是说只有new了之后,这个类才能用。
举例说明：
Java中使用 new关键字 加上 构造方法，来创建一个对象，下面是一个名为Cat的类,public class Cat { public Cat() { System.out.println("这是构造方法"); }}使用new + 构造方法 来创建一个对象。
那么也就是Cat c = new Cat();前半部分，Cat c 的意思是，在内存中分配一个变量，名字叫c，这个变量是Cat类型的;后半部分，new Cat(); 这就是new关键字和构造方法来创建一个对象，Cat()是构造方法的名字。
想造出一个对象来，需要运用;new Cat(); 说明 new这个Cat类的一个对象，程序运行的时候，会调用构造方法Cat()，等这个构造方法执行完了，这个Cat类型的对象也就造出来了，真正的出现在内存当中了。
使用new关键字造出来的对象，被分配在内存的堆区(heap)，而且等这个对象真正出来之后，还会做一件重要的事情:new关键字创建出一个对象之后，会把这个对象在内存中的地址返回，通过这个地址就可以找到这个对象。
那么上面的写法,Cat c = new Cat();意思就是说，把这个对象在内存中的地址 赋值 给变量c，这就是Java中引用概念，c就叫做引用，或者叫引用变量，或者直接叫变量，没问题，都是它;c的值就是一个内存地址，或者叫引用地址。
通过这个地址，就可以准确的找到刚才创建出来的对象，以后我们要使用这个对象做一些事情，调用此对象的方法什么的，都用过这个引用。
扩展资料：
JAVA其他关键字：
①abstract：
abstract关键字可以修饰类或方法。abstract类可以扩展(增加子类)，但不能直接实例化。abstract方法不在声明它的类中实现，但必须在某个子类中重写。
示例：
public abstract class MyClass{}
public abstract String myMethod();
注释：
采用abstract方法的类本来就是抽象类，并且必须声明为abstract。abstract类不能实例化。仅当abstract类的子类实现其超类的所有abstract方法时，才能实例化abstract类的子类。这种类称为具体类，以区别于abstract类。
如果abstract类的子类没有实现其超类的所有abstract方法，该子类也是abstract类。abstract关键字不能应用于static、private或final方法，因为这些方法不能被重写，因此，不能在子类中实现。final类的方法都不能是abstract，因为final类不能有子类。
②boolean
boolean变量的值可以是true或false。
示例：
boolean valid=true;
if(valid){
}
注释：
boolean变量只能以true或false作为值。boolean不能与数字类型相互转换。包含boolean操作数的表达式只能包含boolean操作数。Boolean类是boolean原始类型的包装对象类。
③break
用于提前退出for、while或do循环，或者在switch语句中用来结束case块。
示例：
for(i=0;i
if(){
break;}}
inttype=;
switch(type){
case1:
break;
case2:
break;
default:
}
注释：
break总是退出最深层的while、for、do或switch语句。
byte是Java原始类型。byte可存储在[-128,127]范围以内的整数值。
示例：
byteb=124;
注释：Byte类是byte原始类型的包装对象类。它定义代表此类型的值的范围的MIN_VALUE和MAX_VALUE常量。Java中的所有整数值都是32位的int值，除非值后面有l或L(如235L)，这表示该值应解释为long。
参考资料：百度百科-Java(计算机编程语言)