List集合的子实现类的特点(ArrayList,Vector,LinkedList),JDK5以后提供的新特性
2017-11-15 18:27
477 查看
List集合的子实现类的特点:
ArrayList:
底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢从线程安全问题来看:线程不安全的,不同步,执行效率高
Vector:
底层数据结构是数组的形式,查询快,增删慢从线程角度看:线程安全的类,同步,执行效率低
LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快从线程角度看:线程不安全的一个类,不同步,执行效率高
如果实现多线程程序,一般要是安全的类:
StringBuffer,Vector<E>,hashtable<K,V>
synchronized(同步锁对象){
代码;
}
如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList
如果需求中要考虑线程安全,那么使用Vector集合!
笔试过程中,一些需求用到集合:就是用ArrayList
ArrayList:
底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢从线程安全问题来看:线程不安全的,不同步,执行效率高
由于ArrayList是List集合的自实现类,它元素可以重复,并且存储和取出一致
publicclass ArrayListDemo {
public static void main(String[] args){
//创建一个ArrayList集合对象
ArrayList array = newArrayList() ;
//添加元素
array.add("hello");
array.add("hello");
array.add("world");
array.add("world");
array.add("java") ;
array.add("java") ;
//遍历元素:
//1)获取迭代器对象
Iterator it =array.iterator() ;
while(it.hasNext()){
String s =(String)it.next() ;
System.out.println(s);
}
}
}
Vector:
底层数据结构是数组的形式,查询快,增删慢从线程角度看:线程安全的类,同步,执行效率低
特有功能:
publicvoid addElement(E obj)------->相当于:add(Object e)
publicEnumeration<E> elements()----->相当于:Iteratoriterator() ;
Enumeration<E>接口:向量的组件枚举有两个方法
booleanhasMoreElements():------>相当于:hasNext()
ObjectnextElement():----------->相当于:next();
源码:
synchronized:同步锁(多线程中讲):它就可以保证线程安全!
public synchronized void addElement(E obj) {//由同步代码块演变过来的同步方法
modCount++;
ensureCapacityHelper(elementCount+ 1);
elementData[elementCount++]= obj;
publicclass VectorDemo {
public static void main(String[] args){
//创建一个Vector集合对象
Vector v = new Vector() ;
//添加元素
//public void addElement(Eobj)
v.addElement("hello");
v.addElement("hello");
v.addElement("world");
v.addElement("Java");
//public Enumeration<E>elements()----->相当于:Iterator iterator() ;
Enumeration en = v.elements();
//遍历元素
/**
* boolean hasMoreElements():------>相当于:hasNext()
ObjectnextElement():----------->相当于:next();
*/
while(en.hasMoreElements()){
//获取元素
String s =(String)en.nextElement() ;
System.out.println(s);
}
}
}
LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快从线程角度看:线程不安全的一个类,不同步,执行效率高
特有功能:
添加功能:
publicvoid addFirst(E e)将指定元素插入此列表的开头。
publicvoid addLast(E e)将指定元素添加到此列表的结尾。
获取功能:
publicObject getFirst()返回此列表的第一个元素
publicObject getLast()返回此列表的最后一个元素。
删除功能:
publicObject removeFirst()移除并返回此列表的第一个元素。
publicObject removeLast()移除并返回此列表的最后一个元素。
publicclass LinkedListDemo {
public static void main(String[] args){
//创建LinkedList集合
LinkedList link = newLinkedList() ;
//添加元素
link.addFirst("hello");
link.addFirst("world");
link.addFirst("Java");
//public void addFirst(E e)将指定元素插入此列表的开头
f0ba
/*link.addFirst("android");
link.addLast("JavaWeb");*/
/**
* public Object getFirst()返回此列表的第一个元素
public ObjectgetLast()返回此列表的最后一个元素。
*/
/*
Object obj = link.getFirst();
System.out.println(obj);
Object obj2 = link.getLast();
System.out.println(obj2);*/
/**
* public Object removeFirst()移除并返回此列表的第一个元素。
public ObjectremoveLast()移除并返回此列表的最后一个元素。
*/
/*System.out.println("removeFirst:"+link.removeFirst());
System.out.println("removeLast:"+link.removeLast());*/
//输出集合
System.out.println("link:"+link);
}
}
JDK5以后提供了很多特性:
泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等等增强for循环
书写格式:for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){
输出变量名;
}
增强for循环的弊端:
遍历数组或者集合的时候,数组对象或者集合对象不能为null
如果对象为空,一般加上非空判断
增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素
publicclass ForDemo {
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {11,22,33,44,55};
//普通for循环的遍历
for(int x = 0 ; x <arr.length ; x ++){
System.out.println(arr[x]);
}
System.out.println("---------------------");
//使用增强for遍历
for(int i :arr){
System.out.println(i);
}
System.out.println("-------------------");
//定义一个字符串数组,并遍历
String[] strArray ={"hello","world","java"};
//直接使用增强for循环
for(String s : strArray){
System.out.println(s);
}
System.out.println("-------------------");
//创建ArrayList集合对象,添加并遍历元素
ArrayList<String> array= new ArrayList<String>() ;
//添加元素
array.add("hello");
array.add("world");
array.add("java") ;
//之前:迭代器遍历
/*Iterator<String> it =array.iterator() ;
while(it.hasNext()){
String s = it.next();
//判断当前集合中是否有"world",如果有就添加元素
//java.util.ConcurrentModificationException
if("world".equals(s)){
//使用集合添加元素
array.add("javaee");
}
}*/
//使用增强for遍历该集合
for(String s :array){
//获取到每一个元素
//java.util.ConcurrentModificationException
////判断当前集合中是否有"world",如果有就添加元素
if("world".equals(s)){
array.add("javaee");
}
}
System.out.println("-------------------");
/* array= null ;
//java.lang.NullPointerException:空指针异常
if(array!=null){
//增强for循环
for(String s:array){
System.out.println(s);
}
}*/
}
}
使用ArrayList集合存储自定义对象并遍历
几种方式:1)toArray()
2)Collection集合的迭代器:Iteratoriterator();
3)List集合的迭代器:ListIteratorlistiterator();
4)普通for循环:size()和get(intindex)相结合
5)增强for循环
publicclass ForDemo2 {
public static void main(String[] args){
// 创建ArrayList集合
ArrayList<Student>array = new ArrayList<Student>();
// 创建学生对象
Student s1 = newStudent("高圆圆", 27);
Student s2 = newStudent("高圆圆", 20);
Student s3 = newStudent("邓超", 29);
Student s4 = newStudent("邓超", 25);
// 给集合中添加元素
array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;
//普通for循环:size()和get(intindex)相结合
for(int x =0 ; x <array.size() ; x ++){
Student s =array.get(x) ;
System.out.println(s.getName()+"---"+s.getAge());
}
System.out.println("-----------------------");
//Collection集合的迭代器:Iteratoriterator();
Iterator<Student> it =array.iterator() ;
while(it.hasNext()){
Student s =it.next() ;
System.out.println(s.getName()+"----"+s.getAge());
}
System.out.println("-----------------------");
//增强for遍历
for(Student s : array){
System.out.println(s.getName()+"----"+s.getAge());
}
}
}
使用ArrayList存储元素
给ArrayList集合存储了一些元素,String类型的元素,Integer类型的元素但是通过迭代器遍历元素,由于,系统不知道集合中存储了哪些元素,所有使用String类型接收,就会出现ClassCastException:类转换异常
这样设计不够好!
定义一个数组:字符串数组
String[]str = new String[3] ;
str[0]= "hello" ;
str[1]= "world" ;
str[2]= 100 ;
数组设计这样好处:提前告诉了开发者,这里只能装String类型的元素,Java根据数组特点---->引出:泛型
泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递格式:
<引用类型>:泛型只能放引用类型
泛型好处:
1)将运行时期异常提前到了编译时期
2)解决了黄色警告线问题
3)获取数据的时候,不用强制类型转换了
泛型的应用:
一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!
public classGenericDemo2 {
public static void main(String[] args){
//创建一个ArrayList集合对象
ArrayList<String> array= new ArrayList<String>() ;//jdk7特性:泛型推断!:建议:后面永远给出类型
//给集合中添加元素
array.add("hello");
array.add("world");
array.add("java") ;
// array.add(10) ;
//获取迭代器对象并遍历
Iterator<String> it =array.iterator() ;
//遍历
while(it.hasNext()){
//不用强制类型转换了
String s = it.next();
System.out.println(s);
}
}
}
泛型可以提供程序的安全性!
早期的时候,用Object类型代表任意的类型向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误!
JDK5以后,提供了泛型可以解决程序的安全性
publicclass ObjectToolDemo {
public static void main(String[] args){
//创建ObjectTool对象
ObjectTool ot = newObjectTool() ;
//设置数据
ot.setObj(27) ;//Object obj =new Integer(27):向上转型
//获取
Integer i = (Integer)ot.getObj() ;//向下转型
System.out.println("年龄是:"+i);
ObjectTool ot2 = newObjectTool() ;
//设置
ot2.setObj("高圆圆");//Object obj = new String("高圆圆") ;
//获取
String str = (String)ot2.getObj() ;//类型转换了:向下转型:隐藏了类型转换
System.out.println("姓名是:"+str);
System.out.println("-------------------------------");
ObjectTool ot3 = newObjectTool() ;
ot3.setObj("邓超") ;
//java.lang.ClassCastException
Integer ii = (Integer)ot3.getObj() ;//强制类型转换的接收类型不匹配:程序不安全
System.out.println("姓名是:"+ii);
}
}
publicclass ObjectTool {
private Object obj ;
//获取
public Object getObj(){
return obj ;
}
//设置
public void setObj(Object obj){//Objectobj = new Integer(27) ; //向上转型
this.obj = obj ;
}
}
泛型的高级:通配符
<?> :可以是任意类型,包括Object类型以及任意的Java类<? extends E>:向下限定,E类型以及E类型的子类
<? super E>:向上限定,E类型以及E类型的父类
publicclass GenericDemo {
public static void main(String[] args){
//创建Collection集合的对象
//最起码:前后的数据类型保持一致
// Collection<Object> c1 = newArrayList<Animal>() ;
// Collection<Object> c2 = newArrayList<Cat>() ;
// Collection<Object> c3 = newArrayList<Dog>() ;
Collection<Object> c3 =new ArrayList<Object>() ;
// <?> :可以是任意类型,包括Object类型以及任意的Java类
Collection<?> c4 = newArrayList<Object>() ;
Collection<?> c5 = newArrayList<Animal>() ;
Collection<?> c6 = newArrayList<Cat>() ;
Collection<?> c7 = newArrayList<Dog>() ;
//<? extends E>:向下限定,E类型以及E类型的子类
Collection<? extendsObject> c8 = new ArrayList<Object>() ;
Collection<? extendsAnimal> c9 = new ArrayList<Animal>() ;
// Collection<? extendsAnimal> c10 = new ArrayList<Object>() ;
Collection<? extendsObject> c11 = new ArrayList<Cat>() ;
//<? super E>:向上限定,E类型以及E类型的父类
Collection<? superAnimal> c12 = new ArrayList<Object>() ;
Collection<? superAnimal> c13 = new ArrayList<Animal>() ;
// Collection<? super Animal>c14 = new ArrayList<Dog>() ;
}
}
//自定义两个类
classAnimal{
}
class Catextends Animal{
}
class Dogextends Animal{
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 2017 - 10 -22 集合框架 ArrayList Vector LinkedList 泛型 jdk5新特性
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- Java 集合 1：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- (9) java ---- 集合框架图 ArrayList,LinkedList,Vector各自的性能特点及区别
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- 集合中的List以及其三个实现类ArrayList,LinkedList,Vector
- 黑马程序员——List集合中ArrayList、linkedList、Vector的数据结构及特点
- 黑马程序员面试题集合1(ArrayList,LinkedList,Vector,Iterator,ListIterator，HashSet,TreeSet,JDK1.5新特性泛型)
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- 黑马程序员----List集合中的另外两个小弟，Vector LinkedList(实现结构，本身特点，自己的独有方法). 泛型技术：
- Java基础之集合List-ArrayList、LinkedList、Vector的底层实现和区别
- Java 集合：Collection，List，ArrayList，Vector，LinkedList（实现方式，对比）
- 16 API-集合(List的子类(ArrayList_Vector_LinkedList,集合嵌套遍历),JDK5新特性(泛型,增强for循环,静态导入,可变参数)
- 黑马程序员--07.集合框架--04.List实现子类【ArrayList】【LinkedList】【Vector】
- 16. 集合类 （List的子类ArrayList、Vector、LinkedList与JDK 5新特性）
- List接口实现类－ArrayList、Vector、LinkedList集合深入学习以及源码解析
- List接口实现类－ArrayList、Vector、LinkedList集合深入学习以及源代码解析
- Java集合--深度剖析Vector、Stack、ArrayList、LinkedList（二）