集合框架
数组,集合都是对多个数据进行存储操作的,简称为容器。
PS:这里的存储指的是内存层面的存储,而不是持久化存储(.txt, .avi, .jpg)
数组的特点:
-
数组一旦指定了长度,那么长度就被确定了,不可以更改.
int[] arr = new int[6]; -
数组一旦声明了类型之后,数组只能存放这个类型的数据,数组中只能存放同一种类型地数据
int[] arr, String[] s, double[] d… -
数组地缺点:
(1) 数组一旦指定了长度就被确定了,不可以更改。
(2) 删除,增加元素,效率低。
(3) 数组中实际元素的数量是没有办法获取的,没有提供对应的方法或属性来获取。
(4) 数组存储:有序,可重复,对于无序的,不可重复的数组不能满足要求。
- 正因为上面的缺点,引入了一个·新的存储数据的结构 --》集合
ArrayList实现类和Vector实现类
联系:底层都是数组扩容
区别:
ArrayList底层扩容长度为原数组的1.5倍,线程不安全,效率高
Vector底层扩容长度为原数组地2倍 线程安全 效率低下 (淘汰)
泛型
- 在JDK1.5之后才存在地
- 泛型实际上就是一个<>引起来地参数类型,这个参数类型 具体在使用的时候才会确定具体的类型
- 使用范型以后,可以确定集合中存放的数据类型,在编译时期就可以检测出来
- 使用泛型以后,你可能觉的麻烦,实际使用泛型才会简单,后续的遍历等操作简单
- 泛型的数据类型都是引用数据类型,不是基本数据类型
- ArrayList al = new ArrayList() 在JDK1.7以后可以写为:ArrayList al = new ArrayList<>();
public class GemTest<E> {
int age;
String name;
E sex;
public void a(E n) {
}
public void b(E[] m) {
}
}
//不指定泛型
class SubGemTest extends GemTest<Integer>{
}
//指定泛型
class SubGemTest2<E> extends GemTest<E>{
}
class Demo2{
public static void main(String[] args) {
SubGemTest2<String> sgt2 = new SubGemTest2<>();
sgt2.a("abc");
sgt2.sex = "女";
}
}
class Demo{
public static void main(String[] args) {
SubGemTest sgt = new SubGemTest();
sgt.a(13);
}
}
class Test{
public static void main(String[] args) {
GemTest gt1 = new GemTest();
gt1.a(12);
gt1.a(3.4);
gt1.a("lou");
gt1.b(new String[]{"杂货","参数" ,"删除","上传"});
gt1.b(new Integer[]{1,3,54,65,67});
gt1.b(new Double[]{1.32,13.3,123.4,12324.566});
GemTest<String> gt2 = new GemTest<>();
gt2.sex = "Tom";
gt2.a("狸猫");
gt2.b(new String[]{"杂货","参数" ,"删除","上传"});
/*gt2.b(new Integer[]{1,3,54,65,67});
gt2.b(new Double[]{1.32,13.3,123.4,12324.566});*/
}
}
import java.util.ArrayList;
import java.util.List;
public class GemTest_03 {
/*public void a(List<Object> list){
}
public void a(List<String> list){
}
public void a(List<int> list){
}*/
public void a(List<?> list){
// 遍历使用Object,不适用?
// 遍历
for (Object o : list) {
System.out.println(o);
}
// list.add(112);不能随意的添加数据,处理null
list.add(null);
// 可以进行读取
list.get(3);
}
public static void main(String[] args) {
List<Object> ls1 = new ArrayList<>();
List<String> ls2 = new ArrayList<>();
List<Integer> ls3 = new ArrayList<>();
// 使用通配符? G<?>成为了G<Integer>,G<String>的父类
List<?> list = null;
list = ls1;
list = ls2;
list = ls3;
GemTest_03 t = new GemTest_03();
t.a(new ArrayList<Object>());
t.a(new ArrayList<String>());
t.a(new ArrayList<Integer>());
}
}
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<Object> a = new ArrayList<>();
List<Person> b = new ArrayList<>();
List<Student> c = new ArrayList<>();
/*
开始使用泛型的受限;泛型的上限,往下取
List<? extends Person>
就相当于
List<? extends Person>是List<Person>的父类,也是list<Person子类>的父类
*/
List<? extends Person> list1 = null;
/*list = a;*/
list1 = b;
list1 = c;
// 泛型的下限,往上取
/*
开始使用泛型的受限;泛型的上限,往下取
List<? super Person>
就相当于
List<? super Person>是List<Person>的父类,也是list<Person父类>的父类
*/
List<? super Person> list2 = null;
list2 = a;
list2 = b;
/*list2 = c;*/
}
}