韩奇峰高级讲师
多年实战工作经验曾参与制作宝马Usage Training项目、DMS项目,奥迪全
息投影项目,奔驰等多家汽车门户行业大型项目,负责UI设计、界面设计、3D模型制作、前端开发等职务。
从事设计行业多年,精通PhotoShop、UI设计、AfterEffects、Flash、
Actionscript、HTML、CSS、JavaScript、jQuery、资深动画设计师,设计作品曾获得全国动画设计三等奖。
课程讲解注重实战应用,对讲述知识点穿插案例制作,使课程内容更加接近
工作中实际的项目。授课风格注重实战经验分析,深受学生喜欢。
Java和Python哪个就业情况更好?
首先,在了解一个语言就业好不好之前,
得先明确语言的发展方向
(1)Python
Python:数据分析,人工智能,web开发,测试,运维,web安全。
(2)Java
Java:web开发,大数据开发,安卓开发,服务器开发, 桌面开发,游戏开
发。
Java作为全球占比**高的开发语言,有着她**的优势,但因竞争太大
,就业方面并不比Python好。
而基于目前国内python人才需求呈大规模上升,薪资水平也水涨船高。学
python的人大多非科班出身。很多大学并没有开始此专业,因此就出现了大量的人才缺口。
从图上可以清晰的判断未来python就业形势,是大幅度上升的,加上互联网
行业正在进入成长爆发期,所以现在开始学习python的小伙伴果然是明智滴。
就业发展
与此同时,目前的互联网行业在高速发展的过程中,对于人工智能,数据分
析在北京、上海、深圳各大互联网发达的一线城市越发的火热,招聘优秀的Python程序员的难度尤为突出,为此选择就业Python更易成功。
Python人气爆棚的秘密
Python之所以排名上的如此之快,和它本身的特点也有关系,他是一种简单
、易用但专业、严谨的通用组合语言,或者叫胶水语言,让普通人也能够很容易的入门,把各种基本程序元件拼装在一起,协调运作。比如任何一个人
,只要愿意学习,可以在几天的时间里学会Python基础部分,然后干很多很多事情,这种投入产出比可能是其他任何语言都无法相比的而且Python的应
用很广,很多行业都会应用。
面对面授课
限制人数
每班人数不超过80人,老师能保证照顾到每位学员!
面对面授课
面对面教学可及时了解学生学情,根据学员课堂反馈调整上课进度,拒绝盲
目赶进度!
主讲辅导
课后主讲老师亲自辅导补习,0问题离开教室
积累人脉
面授班同学之间可短时间内培育感情,毕业后,你会发现Java程序员的圈子
里到处都是你的人脉,让你在职场上更加如虎添翼。
互动课堂教学
课堂互动性强,在好的学习氛围中激励学生自己发现问题和解决问题!也便
于老师及对学生学习效果进行测评纠错!
Java集合系列(5)--List总结
>
前面,我们学习了List中**主要的ArrayList和LinkedList。下面做出一个总结,便于理解。
一、List基本描述
先回顾一下List的框架图
1>List是一个接口,它继承于Collection的接口。它代表着有序队列。
2>AbstractList是一个抽象类,它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。
3>AbstractSequentialList是一个抽象类,它继承于AbstractList。AbstractSequentialList 实现了“链表中,根据index索引值操作链表的全部函数”。
4>ArrayList、LinkedList、Vector、Stack是List的4个实现类。
ArrayList是一个数组队列,相当于动态数组。它由数组实现,随机访问效率高,随机插入、随机删除效率低。
LinkedList是一个双向链表。它可以被当做堆栈、队列或双端队列进行操作。LinkedList随机访问效率低,但随机插入、随机删除效率高。
Vector是矢量队列,和ArrayList一样,它也是一个动态数组,由数组实现,但是ArrayList是非线程安全的,Vector是线程安全的。
Stack是栈,它继承于Vector。它的特性是:先进后出。
二、List使用场合
先概括的说明一下各个List的使用场景,接下来再分析原因。
如果涉及到“栈”“队列”“链表”等操作,应该先考虑使用List,具体的选择哪个List,根据下面的标准来取舍。
1>对于需要快速插入、删除元素,应该使用LinkedList。
2>对于需要快速随机访问元素,应该使用ArrayList
3>对于“单线程环境”或者“多线程”环境,但List仅仅只会被单个线程操作,此时应该使用非同步的类(如ArrayList)。
对于线程环境,且List可能同时被多个线程操作,此时,应该使用同步的类。
通过下面的测试程序,我们来验证上面的1和2的结论。参考代码如下:
package Test;
import java.util.*;
/**
* Created by LKL on 2017/2/17.
*/
public class TestTime {
/*
* @desc 对比ArrayList和LinkedList的插入、随机读取效率、删除的效率
*
*/
PRivate static final int COUNT = 100000;
private static LinkedList linkedList = new LinkedList();
private static ArrayList arrayList = new ArrayList();
private static Vector vector = new Vector();
private static Stack stack = new Stack();
public static void main(String[] args) {
// 换行符
System.out.println();
// 插入
insertByPosition(stack) ;
insertByPosition(vector) ;
insertByPosition(linkedList) ;
insertByPosition(arrayList) ;
// 换行符
System.out.println();
// 随机读取
readByPosition(stack);
readByPosition(vector);
readByPosition(linkedList);
readByPosition(arrayList);
// 换行符
System.out.println();
// 删除
deleteByPosition(stack);
deleteByPosition(vector);
deleteByPosition(linkedList);
deleteByPosition(arrayList);
}
// 获取list的名称
private static String getListName(List list) {
if (list instanceof LinkedList) {
return "LinkedList";
} else if (list instanceof ArrayList) {
return "ArrayList";
} else if (list instanceof Stack) {
return "Stack";
} else if (list instanceof Vector) {
return "Vector";
} else {
return "List";
}
}
// 向list的指定位置插入COUNT个元素,并统计时间
private static void insertByPosition(List list) {
long startTime = System.currentTimeMillis();
// 向list的位置0插入COUNT个数
for (int i=0; i<COUNT; i )
list.add(0, i);
long endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println(getListName(list) " : insert " COUNT " elements into the 1st position use time:" interval " ms");
}
// 从list的指定位置删除COUNT个元素,并统计时间
private static void deleteByPosition(List list) {
long startTime = System.currentTimeMillis();
// 删除list**个位置元素
for (int i=0; i<COUNT; i )
list.remove(0);
long endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println(getListName(list) " : delete " COUNT " elements from the 1st position use time:" interval " ms");
}
// 根据position,不断从list中读取元素,并统计时间
private static void readByPosition(List list) {
long startTime = System.currentTimeMillis();
// 读取list元素
for (int i=0; i<COUNT; i )
list.get(i);
long endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println(getListName(list) " : read " COUNT " elements by position use time:" interval " ms");
}
}
运行结果如下:
Stack : insert 100000 elements into the 1st position use time:3279 ms
Vector : insert 100000 elements into the 1st position use time:1731 ms
LinkedList : insert 100000 elements into the 1st position use time:26 ms
ArrayList : insert 100000 elements into the 1st position use time:1719 ms
Stack : read 100000 elements by position use time:9 ms
Vector : read 100000 elements by position use time:6 ms
LinkedList : read 100000 elements by position use time:9296 ms
ArrayList : read 100000 elements by position use time:4 ms
Stack : delete 100000 elements from the 1st position use time:1680 ms
Vector : delete 100000 elements from the 1st position use time:1571 ms
LinkedList : delete 100000 elements from the 1st position use time:15 ms
ArrayList : delete 100000 elements from the 1st position use time:1614 ms
插入10万个元素,LinkedList所花时间**短:26 ms。
删除10万个元素,LinkedList所花时间**短:15ms。
遍历10万个元素,LinkedList所花时间**长:9296 ms ms;而ArrayList、Stack和Vector则相差不多,都只用了几秒。
结合Vector时支持同步的,而Stack又是继承于Vector的,因此,得到:
1>对于需要快速插入、删除元素,应该使用LinkedList。
2>对于需要快速随机访问女元素,应该使用ArrayList。
3>对于单线程环境或者多线程环境,但List仅仅只会被单个线程操作,此时应该使用非同步的类(ArrayList或者LinkedList)
三、LinkedList和ArrayList性能差异分析
下面我们看看为什么LinkedList好像总插入元素很快,而LinkedList中插入元素很慢!
LinkedList.java中向指定位置插入元素的代码如下
// 在index前添加节点,且节点的值为element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
// 获取双向链表中指定位置的节点
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " index
", Size: " size);
Entry<E> e = header;
// 获取index处的节点。
// 若index < 双向链表长度的1/2,则从前向后查找;
// 否则,从后向前查找。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i )
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
// 将节点(节点数据是e)添加到entry节点之前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建节点newEntry,将newEntry插入到节点e之前;并且设置newEntry的数据是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
// 插入newEntry到链表中
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size ;
modCount ;
return newEntry;
}
从上面我们可以知道:通过add(int index,E element)向LinkedList插入元素时,先是在双向链表中找到要插入节点的位置索引index,找到之后,再插入一个新节点。
双向链表查找index位置的节点时,有一个加速动作:若index<双向链表的1/2,则从前向后查找;否则,从后向前查找。
接着,我们看看ArrayList.java中向指定位置插入元素的代码。如下:
// 将e添加到ArrayList的指定位置
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " index ", Size: " size);
ensureCapacity(size 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index 1,
size - index);
elementData[index] = element;
size ;
}
ensureCapacity(size 1)的作用是“确认ArrayList的容量,若容量不够,则增加容量”
真正耗时的操作是 System.arraycopy(elementData, index, elementData, index 1, size - index);
Sun JDK包的java/lang/System.java中的arraycopy()声明如下:
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
实际上,我们只需了解System.arraycopy(elementData, index, elementData, index 1, size - index);会移动index之后所有元素即可。这就意味着,ArrayList的add(int index,E element)函数,会引起index之后所有元素的改变。
通过上面分析,我们就能理解为什么LinkedList中插入元素很快,而ArrayList中插入元素很慢。
删除元素与插入元素的原理类似,就不做说明。
接下来,我们看看 “为什么LinkedList中随机访问很慢,而ArrayList中随机访问很快”。
LinkedList随机访问的源码
// 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
}
// 获取双向链表中指定位置的节点
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " index
", Size: " size);
Entry<E> e = header;
// 获取index处的节点。
// 若index < 双向链表长度的1/2,则从前先后查找;
// 否则,从后向前查找。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i )
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
从中,我们可以看出:通过get(int index)获取LinkedList第index个元素时。先是向双向链表中找到index位置的元素;找到之后再返回。
双向链表查找index位置的节点时,有一个加速动作:若index<双向链表的1/2,则从前向后查找;否则,从后向前查找。
下面分析ArrayList随机访问的代码
// 获取index位置的元素值
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: " index ", Size: " size);
}
从中可以得到,通过get(int index)获取ArrayList第index个元素时。直接返回数组中index位置的元素,而不需要像LinkedList一样进行查找。
四、Vector和ArrayList比较
相同点:
1>他们都是实现List接口。继承于AbstractList
ArrayList和Vector的类定义如下:
// ArrayList的定义
public class ArrayList<E> extends AbstractList<E>
implements List<E>, Randomaccess, Cloneable, java.io.Serializable
// Vector的定义
public class Vector<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
2>它们都实现了RandomAccess和Cloneable接口
实现RandomAccess接口,意味着它们都支持快速随机访问;
实现了Cloneable接口,意味着它们能产生自己的副本。
3>它们都是通过数组实现的,本质上都是动态数组
ArrayList.java中定义数组elementData用于保存元素
// 保存ArrayList中数据的数组
private transient Object[] elementData;
Vector.java中也定义了数组elementData用于保存元素
// 保存Vector中数据的数组
protected Object[] elementData;
4>它们的默认数组容量是10
若创建ArrayList或Vector时,没指定容量大小;则使用默认容量大小10。
ArrayList的默认构造函数为:
// ArrayList构造函数。默认容量是10。
public ArrayList() {
this(10);
}
Vector的默认构造函数如下:
// Vector构造函数。默认容量是10。
public Vector() {
this(10);
}
5>它们都支持Iterator和listIterator遍历
它们都继承于AbstractList,而AbstractList中分别实现了“iterator()接口返回Iterator迭代器”和“listIterator()返回ListIterator迭代器”
不同点:
1>线程安全性不同
ArrayList是非线程安全;而Vector是线程安全的,它的函数都是synchronized的,即都是支持同步的。
ArrayList适用于单线程,Vector适用于多线程。
2>对序列化支持不同
ArrayList支持序列化,而Vector不支持;即ArrayList有实现Serializable接口,而Vector没有实现该接口。
3>构造函数个数不同
ArrayList有3个构造函数,而Vector有四个构造函数。Vector除了包括和ArrayList类似的3个构造函数之外,另外的一个构造函数可以指定容量增加系数。
ArrayList构造函数如下:
// 默认构造函数
ArrayList()
// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时,容量会添加上一次容量大小的一半。
ArrayList(int capacity)
// 创建一个包含collection的ArrayList
ArrayList(Collection<? extends E> collection)
Vector的构造函数如下:
// 默认构造函数
Vector()
// capacity是Vector的默认容量大小。当由于增加数据导致容量增加时,每次容量会增加一倍。
Vector(int capacity)
// 创建一个包含collection的Vector
Vector(Collection<? extends E> collection)
// capacity是Vector的默认容量大小,capacityIncrement是每次Vector容量增加时的增量值。
Vector(int capacity, int capacityIncrement)
4>容量增加方式不同
逐个添加元素时,若ArrayList容量不足时,新的容量=“原始容量*1.5 1”
而Vector的容量增长与增长系数有关,若指定了增长系数,且增长系数有效(即,大于0);那么,每次容量不足时,“新的容量=原始容量 增长系数”。若增长系数无效(<=0),则“新的容量=原始容量*2”
ArrayList中容量增长的函数如下:
public void ensureCapacity(int minCapacity) {
// 将“修改统计数” 1
modCount ;
int oldCapacity = elementData.length;
// 若当前容量不足以容纳当前的元素个数,设置 新的容量=“(原始容量x3)/2 1”
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
Vector中容量增长的主要函数如下:
private void ensureCapacityHelper(int minCapacity) {
int oldCapacity = elementData.length;
// 当Vector的容量不足以容纳当前的全部元素,增加容量大小。
// 若 容量增量系数>0(即capacityIncrement>0),则将容量增大当capacityIncrement
// 否则,将容量增大一倍。
if (minCapacity > oldCapacity) {
Object[] oldData = elementData;
int newCapacity = (capacityIncrement > 0) ?
(oldCapacity capacityIncrement) : (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
5>对Enumeration的支持不同。Vector支持通过Enumeration去遍历,而List不支持
Vector中实现Enumeration的代码如下:
public Enumeration<E> elements() {
// 通过匿名类实现Enumeration
return new Enumeration<E>() {
int count = 0;
// 是否存在下一个元素
public boolean hasMoreElements() {
return count < elementCount;
}
// 获取下一个元素
public E nextElement() {
synchronized (Vector.this) {
if (count < elementCount) {
return (E)elementData[count ];
}
}
throw new NoSuchElementException("Vector Enumeration");
}
};
}
参考:Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)
相关推荐:
苏州JAVA培训 苏州JAVA培训班 苏州JAVA培训机构