Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
怎么理解这句话呢?我们举个例子:
创建一个通用顺序表:
class MyArrayList{
private int[]elem;
private int usedSize;
public MyArrayList(){
this.elem=new int[10];
}
public void add(int val){
this.elem[usedSize]=val;
usedSize++;
}
public int get(int pos){
return this.elem[pos];
}
}
上面的顺序表看起来好像没什么问题,但细究,我们会发现这个顺序表存在以下问题
有同学说,我们可以添加一个Object,Object不是所有类 的父类吗?
class MyArrayList{
private Object[]elem;
private int usedSize;
public MyArrayList(){
this.elem=new Object[10];
}
public void add(Object val){
this.elem[usedSize]=val;
usedSize++;
}
public Object get(int pos){
return this.elem[pos];
}
}
这个顺序表貌似各种元素都能存放,但是也存在以下问题:
很简单,使用泛型。
class MyArrayList<E>{
在顺序表上添加<E>,这代表当前类是一个泛型类,而这个E本质上仅仅是一个占位符
}
那么当我引用的时候,就变成了这样,可以把类型作为参数传递:
public static void main(String[] args) {
MyArrayList<String> myArrayList1=new MyArrayList<>();
MyArrayList<Integer> myArrayList2=new MyArrayList<>();
}
那么我们使用泛型之后,一开始的代码就需要更改了:
class MyArrayList<E>{
private E[]elem;
private int usedSize;
public MyArrayList(){
//this.elem=new E[10];//泛型不能实例化对象
}
public void add(E val){
this.elem[usedSize]=val;
usedSize++;
}
public E get(int pos){
return this.elem[pos];
}
}
【注意】上面注释,泛型不能实例化
Java 语言中的泛型,它只在程序源码中存在,在编译后的字节码文件中,就已经替换为原来的原生类型(RawType,也称为裸类 型)了,并且在相应的地方插入了强制转型代码,因此,对于运行期的 Java 语言来说,ArrayList<int>与 ArrayList<String>就是同一 个类
将一段 Java 代码编译成 Class 文件,然后再用字节码反编译工具进行反编译后,将会发现泛型都不见了,程序又变回了 Java 泛型 出现之前的写法,因为泛型类型都变回了原生类型
—————————————————————————————
我们知道,Object 引用可以指向任意类型的对象,但有例外出现了,8 种基本数据类型不是对象,那岂不是刚才的泛型机制要失效了?
实际上也确实如此,为了解决这个问题,java 引入了一类特殊的类,即这 8 种基本数据类型的包装类,在使用过程中,会将类似 int 这样的值包装到一个对象中去。
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
boolean | Boolean |
short | Short |
char | Character |
int | Integer |
long | Long |
float | Float |
double | Double |
常用的包装类可以分为三类:Character、Number、Boolean,继承结构图如下:
装箱:
基本类型向对应的包装类转换称为装箱,例如把 char包装成 Character类的对象。
Character i = Character.valueOf(1); //手动装箱
Character j = 1; //自动装箱
拆箱:
包装类向对应的基本类型转换称为拆箱,例如把 Integer 类的对象重新简化为 int。
Integer a= new Integer(1);
int a1= a; //自动拆箱
int a2= a.intValue(); //手动拆箱
equals方法比较的是真正的值,基本数据类型和包装类比较时,会先把基本数据类型包装成对应的包装类型,再进行比较。
double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(a.equals(b)); //true 2个包装类比较,比较的是包装的基本数据类型的值
System.out.println(b.equals(a)); //true 基本数据类型和包装类型比较时,会先把基本数据类型包装后再比较
==(双等号)
对于基本数据类型,(双等号)比较的是值,而对于包装类型,(双等号)比较的则是2个对象的内存地址。
double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(b== c); //false ,new出来的都是新的对象
System.out.println(b== a); //true ,基本数据类型和包装类比较,会先把包装类拆箱
new出来的都是新的对象。2个新的对象内存地址不同,那么==号比较的结果肯定是false。
基本数据类型和包装类型比较时,会先把包装类拆箱再进行值比较(和equals是反的)
3:
Double a= Double.valueOf(0.1);
Double b= Double.valueOf(0.1);
System.out.println(a== b); //false valueOf方法内部实际上也是new
valueOf内部也是用的new方法来构造对象的。2个new出来的对象,内存地址肯定是不一样的。
接着来看下一个陷阱:
public static void main(String[] args) {
System.out.println(Integer.valueOf(1) ==Integer.valueOf(1)); //true
System.out.println(Integer.valueOf(999) ==Integer.valueOf(999)); //false
}
看到结果,你可能很疑惑,我们看看源码:
1.查看Integer.valueOf方法的源码
可以看到,当i的值在low和high范围内是,返回的是一个cache里的Integer对象。
2.追踪IntegerCache.cache的源码:
可以看到从-128到到127之间的值都被缓存到cache里了。这个叫做包装类的缓存。
Java对部分经常使用的数据采用缓存技术,在类第一次被加载时换创建缓存和数据。当使用等值对象时直接从缓存中获取,从而提高了程序执行性能。(通常只对常用数据进行缓存)
Integer默认缓存是-128到127之间的对象,上限127可以通过修改JVM参数来更改。
回到我们的示例代码中,可以看到Integer.valueOf(1)是会直接从缓存中去取被缓存的同一个对象,所以比较的值是true。而Integer.valueOf(999)是缓存范围外的值,那么就会new一个新的对象出来,所以比较的结果是false。
实际上,包装类中整数型的类型基本上都有缓存数据。可以通过阅读源码了解。不过只有Integer类可以通过修改JVM参数来更改缓存上限。
其他类型的缓存范围为:
尤其需要特别注意的是,只有valueOf方法构造对象时会用到缓存,new方法等不会使用缓存!
这部分更详细的内容可以参考借鉴参考的文章:深入浅出JAVA包装类及面试题陷阱
在集合框架中,ArrayList是一个普通的类,实现了List接口,具体框架图如下:
我们通过IDEA点击进去ArrayList可以发现其有三种方法:
public static void main(String[] args) {
// ArrayList创建,推荐写法
// 构造一个空的列表
List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
List<Integer> list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
// list2.add("hello"); // 编译失败,List已经限定了,list2中只能存储整形元素
// list3构造好之后,与list中的元素一致
ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型,否则:任意类型的元素都可以存放,使用时将是一场灾难
List list4 = new ArrayList();
list4.add("111"); list4.add(100);
}
ArrayList虽然提供的方法比较多,但是常用方法如下所示,需要用到其他方法时,同学们自行查看ArrayList的帮助文档。
方法 | 解释 |
---|---|
boolean add(E e) | 尾插 e |
void add(int index, E element) | 将 e 插入到 index 位置 |
boolean addAll(Collection c) | 尾插 c 中的元素 |
E remove(int index) | 删除 index 位置元素 |
boolean remove(Object o) | 删除遇到的第一个 o |
E get(int index) | 获取下标 index 位置元素 |
E set(int index, E element) | 将下标 index 位置元素设置为 element |
void clear() | 清空 |
boolean contains(Object o) | 判断 o 是否在线性表中 |
int indexOf(Object o) | 返回第一个 o 所在下标 |
int lastIndexOf(Object o) | 返回最后一个o的下标 |
List subList(int fromIndex, int toIndex) | 截取部分list |
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("JavaSE");
list.add("JavaWeb");
list.add("JavaEE");
list.add("JVM");
list.add("测试课程");
System.out.println(list);
// 获取list中有效元素个数
System.out.println(list.size());
// 获取和设置index位置上的元素,注意index必须介于[0, size)间
System.out.println(list.get(1));
list.set(1, "JavaWEB");
System.out.println(list.get(1));
// 在list的index位置插入指定元素,index及后续的元素统一往后搬移一个位置
list.add(1, "Java数据结构");
System.out.println(list);
// 删除指定元素,找到了就删除,该元素之后的元素统一往前搬移一个位置
list.remove("JVM"); System.out.println(list);
// 删除list中index位置上的元素,注意index不要超过list中有效元素个数,否则会抛出下标越界异常
list.remove(list.size()-1);
System.out.println(list);
// 检测list中是否包含指定元素,包含返回true,否则返回false
if(list.contains("测试课程")){
list.add("测试课程");
}
// 查找指定元素第一次出现的位置:indexOf从前往后找,lastIndexOf从后往前找
list.add("JavaSE");
System.out.println(list.indexOf("JavaSE")); System.out.println(list.lastIndexOf("JavaSE"));
// 使用list中[0, 4)之间的元素构成一个新的ArrayList返回
List<String> ret = list.subList(0, 4);
System.out.println(ret);
list.clear();
System.out.println(list.size());
}
public static void main(String[] args) {
ArrayList<String> list2 = new ArrayList<>();
list2.add("我");
list2.add("无敌");
list2.add("存在");
System.out.println(list2);
System.out.println("================");
// 使用下标+for遍历
for (int i = 0; i < list2.size(); i++) {
System.out.print(list2.get(i) + " ");
}
System.out.println();
System.out.println("==================");
// 借助foreach遍历
for (String s : list2) {
System.out.print(s + " ");
}
//迭代器打印
System.out.println();
System.out.println("========迭代器打印==========");
Iterator<String> it = list2.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
//迭代器List相关打印
System.out.println();
System.out.println("========迭代器List相关打印==========");
ListIterator<String> it2 = list2.listIterator();
while (it2.hasNext()) {
System.out.print(it2.next() + " ");
}
}
有同学看到上面可能有疑问,Iterator与ListIterator都可以迭代输出,那么二者有什么区别呢?
Iterator和ListIterator主要区别在以下方面:
ListIterator有add()方法,可以向List中添加对象,而Iterator不能
ListIterator和Iterator都有hasNext()和next()方法,可以实现顺序向后遍历,但是ListIterator有hasPrevious()和previous()方法,可以实现逆向(顺序向前)遍历。Iterator就不可以。
ListIterator可以定位当前的索引位置,nextIndex()和previousIndex()可以实现。Iterator没有此功能。
都可实现删除对象,但是ListIterator可以实现对象的修改,set()方法可以实现。Iierator仅能遍历,不能修改。
因为ListIterator的这些功能,可以实现对LinkedList等List数据结构的操作。其实,数组对象也可以用迭代器来实现。
更详细内容可以参考这篇文章:Iterator和ListIterator区别
这里还有一个点需要注意:
我们在用迭代删除(Iterator.remove())时,可能会因为没有“it.next();”这一行, 抛出java.lang.IllegalStateException异常,原因是通过Iterator来删除集合中某一个不满足条件的元素时,
首先需要使用next方法迭代出集合中的元素 ,然后才能调用remove方法,否则集合可能会因为对同一个Iterator remove了多次而抛出java .lang.IllegalStateException异常。
public static void main(String[] args) {
ArrayList<String> list2 = new ArrayList<>();
list2.add("我");
list2.add("无敌");
list2.add("存在");
System.out.println();
System.out.println("========迭代器List相关打印==========");
ListIterator<String> it2 = list2.listIterator();
while (it2.hasNext()) {
String ret = it2.next();
if(ret.equals("hello")) {
it2.remove();//首先需要使用next方法迭代出集合中的元素 ,然后才能调用remove方法
}else {
System.out.print(ret + " ");
}
}
}
ArrayList是List接口的实现类,它是支持根据需要而动态增长的数组。java中标准数组是定长的,在数组被创建之后,它们不能被加长或缩短。这就意味着在创建数组时需要知道数组的所需长度,但有时我们需要动态程序中获取数组长度。ArrayList就是为此而生的。
详细内容参照:ArrayList的扩容机制
因此,了解它的扩容机制对使用它尤为重要。
ArrayList扩容发生在add()方法调用的时候,下面是add()方法的源码:
点进去add()方法的源码:
根据意思可以看出ensureCapacityInternal()是用来扩容的,形参为最小扩容量,进入此方法后:
通过方法calculateCapacity(elementData, minCapacity)获取:
如果传入的是个空数组则最小容量取默认容量与minCapacity之间的最大值
ensureExplicitCapacity方法可以判断是否需要扩容:
如果最小需要空间比elementData的内存空间要大,则需要扩容
接下来重点来了,ArrayList扩容的关键方法grow():
从此方法中我们可以清晰的看出其实ArrayList扩容的本质就是计算出新的扩容数组的size后实例化,并将原有数组内容复制到新数组中去。
到此扩容就基本完成了。
害,不知该怎么办,人生最难的就是选择,还有坚持!不管怎么说,先一步一步做好该做好的事情。