java中的集合(新手进)

一、java集合

1.为什么要有java集合?有数组能存多个不是足够了吗?

答:

面向对象语言中,需要经常一起操作多个对象,虽然数组也可以存储对象,但数组长度是固定的,不可变。而集合的长度是可变的。而且数组只能存储一类对象,而集合可以将多种对象存储到一起。

2.集合的特点?

答:

1.只能存储对象。(如果存储int i = 1;存进去会自动装箱成Integer类)

2.集合长度是可变的。(在初始化时不需要设定长度)

3.可以存储多种类型的对象

java中的集合(新手进)_第1张图片

二、以下是针对上图,对每一个集合做简单的赘述。

首先要知道,java集合总共有两种,单列集合和双列集合。单列集合(collection)存储对象,双列集合(Map)存储键值对。

附上简单版集合框架图

java中的集合(新手进)_第2张图片

 

 

1.collection接口:

1.1.特点:单列集合的根接口,

1.2.所有collection的子孙类,都能使用collection的方法。

java中的集合(新手进)_第3张图片java中的集合(新手进)_第4张图片

Collection s = new ArrayList();//(接口只能实例化它的子类)
Object o=new Object();
		
s.add(o);//添加一个元素,添加成功返回true,失败返回false
		
s.remove(o);//移除一个或多个元素,成功true,失败false
		
s.clear();//清空集合,无返回值
		
s.contains(o);//检查是否包含元素,boolean
		
s.isEmpty();//检查集合是否为空,boolean
		
int a = s.size();//返回集合中元素的个数
		
Collection t = new ArrayList();
s.addAll(t);//将另一个单列集合t的内容全部添加到当前集合s中,booelan
		
s.removeAll(t);//移除s集合中也在t集合中的全部元素,boolean
		
s.containsAll(t);//检查s是否包含t的全部元素,boolean
		
s.retainAll(t);//将s与t的交集保存回s中,将s的其它元素移除

1.3集合的遍历(所有单列集合均能如此遍历)

Collection s = new ArrayList();//(接口只能实例化它的子类)
s.add(1);
s.add(2);
		
//1.将集合转成数组
Object[] array = s.toArray();
for(int i=0;i

 

 

2.List接口

2.1.特点:

    List里的元素都是有序的(先存的在List里的位置也靠前),

    List里的元素是可以重复的,你可以添加两个一模一样的元素进去

2.2.独有方法(只要是List均可使用)

    java中的集合(新手进)_第5张图片

List s = new ArrayList();
s.add(0,10);//在第0个位置添加一个Integer对象10
s.add(1,20);//在第1个位置添加一个Integer对象20		
//s.add(3,30);//跨数添加,报错
s.add(1,30);//在已有元素的位置上添加新元素,会把原来及往后的元素挤到后面,此时[10,30,20]
		
s.remove(1);//移除位置1上的元素,后面的元素会往前,返回被移除的元素
		
s.get(1);//得到在指定位置的元素并返回
		
s.set(0, 100);//将第0个元素设为100,返回以前在此位置的元素

2.3独有遍历机制(只要是list均可这样遍历)

//1.特有迭代器
ListIterator listIterator = s.listIterator();
while(listIterator.hasNext()) {//从前往后打印
	System.out.println(listIterator.next());
}
		
while(listIterator.hasPrevious()) {//从后往前打印
//注意:必须先让指针从前往后遍历完,再从后往前,否则打印为空
	System.out.println(listIterator.previous());
}
	
//2.for循环
for(int i=0;i

2.4数组转list

                Integer a[] = {1,2,3,4,5};
		List asList = Arrays.asList(a);
		
		for(Integer s:asList) {
			System.out.println(s);
		}
		
		//注意:使用aslist得到的list,是不能进行add和remove的(仅可读的集合)
		//asList.add(10); //java.lang.UnsupportedOperationException
		
		//如果想要操作此集合,请作为参数传入到新建的ArrayList中
		ArrayList as = new ArrayList(asList);
		as.add(6);//成功添加

 

3.set接口

3.1.特点:set里面不能存放相同的元素(利用这一点,我们可以实现对集合的去重),里面存放的元素也是无序的。

3.2.没有什么独有的方法

3.3没有什么独有的遍历方式

 

 

4.Queue接口

4.1.特点:队列是一种特殊的线性表,它只允许在表的前端进行删除操作,而在表的后端进行插入操作。通常以 FIFO(先进先出)的方式排序各个元素。

4.2.独有的方法

java中的集合(新手进)_第6张图片

Queue s = new LinkedList<>();
		
//不推荐使用Queue提供的add()方法添加,因为可能会抛出异常
s.offer(1);//将元素插入到队列末端
s.offer(2);
s.offer(3);
		
//此时:  头[1,2,3]尾
s.peek();//获取队列头部元素1
		
s.element();//获取队列头部元素1
		
//不推荐使用Queue提供的remove()方法添加,因为可能会抛出异常
s.poll();//获取并移除队列头部元素1
//此时:	头[2,3]尾

 

 

5.ArrayList(线程不安全,能存且可存多个null)

5.1.特点: 没什么特点,有list的基本功能。底层是用数组实现的,增删慢,查询快

5.2.比较重要的独有方法

//构造方法ArrayList(Collection c) 
//构造一个包含指定 collection 的元素的列表,其实相当于s2.addAll(s);
List s2 = new ArrayList(s);

5.3.没什么独有的遍历方式

5.4所有集合实现线程安全,均可使用以下方法创建

List list = Collections.synchronizedList(new ArrayList()); 

 

 

 

6.LinkedList(线程不安全,能存且能存多个null)

5.1.特点,除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。专门用于操作表头和表尾元素,可以当作堆栈、队列和双向队列使用。底层是用链表实现的,增删快,查询慢。

5.2.独有方法

java中的集合(新手进)_第7张图片

5.3.独有遍历方式

Iterator des = s.descendingIterator();//获取逆序迭代器
while(des.hasNext()) {
	System.out.println(des.next());//逆序打印
}

 

 

 

7.Vector(线程安全,能存且能存多个null)

7.1.特点:Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够写Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,因此,访问它比访问ArrayList慢。如果集合中的元素的数目大于目前集合数组的长度时,vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度
的50%.如过在集合中使用数据量比较大的数据,用vector有一定的优势。

7.2.比较重要的方法

Vector vector = new Vector<>(10);
vector.add(1);
		
System.out.println(vector.capacity());//10
System.out.println(vector.size());//1
		
for(int i=0;i<10;i++) {//再添加10个,使集合中的元素的数目大于目前集合数组的长度
	vector.add(i);
}
		
System.out.println(vector.capacity());//20,容量增长100%
System.out.println(vector.size());//11

 

8.Stack(线程安全,能存且能存多个null)

8.1.特点: Stack 类表示后进先出(LIFO)的对象堆栈。它通过五个操作对类 Vector 进行了扩展

8.2.重要方法

java中的集合(新手进)_第8张图片

Stack s = new Stack();
s.push(2);
s.push(4);
s.push(6);

//底[2,4,6] 顶 ,顶的位置为1,底的位置为3

System.out.println(s.peek());//栈顶元素是6
System.out.println(s.search(2));//2在栈底,位置是3
		
while(!s.empty()) {//全部出栈 6,2,4
	System.out.println(s.pop());
}
	
System.out.println(s.isEmpty());//true  empty()与collection的isEmpty()方法是一样的

 

9.HashSet(线程不安全,能存但最多只有一个null)

9.1.特点:

①拥有基本的set特性,不允许存放相同的对象(通过hashCode()和equals()方法判定是否为同一对象),存放的对象也是无序的,没有索引,也无法保证存入和取出的顺序一致。

②通过hash值存储对象到散列单元。所以,查询快。hash值是由对象导出的一个整数值。在Object中有一个hashCode方法来得到hashCode。基本上,每一个对象都有一个默认的hashCode,其值就是对象的地址值。但也有一些类重写了hashCode()方法,比如String对象是通过对内容计算得到(所以内容相同hashCode就相同)。

Hash值可能与HashCode相等(HashTable就使用Key的hashCode直接作为Hash值),也可能不相等(HashMap使用Key的hashCode,高16位不变,高16位与低16位做异或运算作为Hash值,这个称为Hash算法,Hash算法将元素尽可能均匀地平铺在数组上)

③HashMap实现机制,底层是数组+链表。而HashSet底层,就是HashMap。

举例:

Java默认的散列单元大小全部都是2的幂,初始值为16(2的4次幂)。则开辟一个容量为16的数组(1~16),

存放一个hash值为24342的对象时,通过计算index,就把它放到第数组的第6个位置,(计算index方法:index = hash值 & (map.length – 1))。

[这里解释一下,有些人说通过取余来确定位置,其实通过取余来确定位置的并不是HashMap,而是HashTable(计算index的方法:index = (hash值 & 0x7FFFFFFF) % table.length))

因为扩容的时候是2的n次方进行扩容,Hash值在2的n次方进行求余运算的结果都一样,但是&运算要快得多,而且因为扩容倍数的特殊性,导致扩容后不需要重新计算元素在数组中的位置,只需要判断Key的hash值多出来的那一位是0还是1,如果是0,新表中元素的位置和旧表一样,如果是1,新表中键值对的位置等于旧表的位置+旧表的长度]

如果,再存放一个hash值为24358的对象,再通过计算index,发现同样要落在数组第6个位置(即发生了hash碰撞),则在数组的第6个位置生成一个链表,将hash值为24358的对象放到链表头,指向刚才的hash值为24342的对象。(至于为什么要把新的放到链表头,可能设计师觉得,你新加进来的,被使用的可能性大)

如果,再存放一个一模一样的对象,在数组的第6个位置的链表中发现有一个老数据与新数据equals()=true的话,这个新数据将被视为已经加入,而不再重复丢入链表。

如果,16条链表中的75%链接有数据的时候(加载因子默认为0.75),HahSet则开始重新散列,也就是将原来的散列结构全部抛弃,重新开辟一个散列单元大小为32(2的5次幂)的散列结果,并重新计算各个数据的存储位置。因为空间越大,取余数相同的情况就越小,也减少了hash碰撞。

java中的集合(新手进)_第9张图片

④优点:

查找和增删都很快,知道了HashSet的添加对象的机制后,查找的道理一样。直接根据数据的hash码(散列码)和计算规则后,就得到了所在数组的位置,然后再查找链表中是否有这个数据即可(每个链表存储的数据很少,所以迭代起来也很快)。

⑤缺点:

但是hashSet增删的高效率是通过花费大量的空间换来的:HashSet这种算法会建立许多无用的空间。

9.2独有方法

Set a = new HashSet();
for(int i=1;i<16;i++) {//按顺序存入1~15的字符串形式
	a.add(i+" ");
}
Iterator iterator = a.iterator();
//不一定按存入顺序打出
while(iterator.hasNext()) {//11 10 9 8 7 6 5 4 3 2 1 15 14 13 12
	System.out.println(iterator.next());
}

 

 

 

10.LinkedHashSet(线程不安全,能存但最多只有一个null)

10.1.特点:LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置,但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺序保存的,也就是说,当遍历该集合时候,LinkedHashSet将会以元素的添加顺序访问集合的元素。

Set a = new LinkedHashSet();
for(int i=0;i<16;i++) {
	a.add(i+" ");
}
		
//按顺序打印
for(Object o:a) {//0 1 2 3 4 ...
	System.out.println(o);
}

 

 

 

10.TreeSet(线程不安全,存null将会抛异常)

10.1.特点:一个能够对元素进行自动排序的set集合

Set a = new TreeSet();
Random random = new Random();
for(int i=0;i<16;i++) {//添加16次随机数(1~20),但不一定添加16个(有可能随机数重复)
	a.add(random.nextInt(20));
}
	
//打印
for(Object o:a) {//1 4 6 10 11 12 13 14 15 17
	System.out.println(o+" ");
}

10.2.独有方法(自定义排序规则)

 

 

 

11.Map接口

11.1特点: 双列集合的根接口,存储键值对(key-value),key不可重复,但可以为null(最多一个null),value可以重复

11.2独有方法(只要是Map均可使用)

java中的集合(新手进)_第10张图片

Map s = new HashMap();
		
//注意,Map接口(双列集合))没有add()方法
s.put("1", 16);
s.put("2",98);
System.out.println(s.get("2"));//98

11.3独有遍历方式

                //1.keySet	获取所有key值
                Set keySet = map.keySet();
		//可以使用3种对set的遍历方式遍历
		//1.1转数组
		Object[] array = keySet.toArray();
		for(int i=0;i12.1.特点:没什么特点,拥有Map的全部功能。值得一提的是,HashSet的底层就是通过HashMap来实现的。即HashSet存值,实际上是新建了一个HashMap,将值存到key中。存入数据的时候,并不能保证存储的顺序。

                Map map = new HashMap();
		
		for(int i=0;i<20;i++) {//添加20个键值对,键为0~19,值为键的平方,均为字符串形式
			map.put(i+" ", " "+i*i);
		}
		
		Set keySet = map.keySet();//并不按顺序输出 
		Object[] array = keySet.toArray();
		for(int i=0;i没错,加了Linked,就是表示它底层是链表,它通过维护一个运行于所有条目的双向链表,LinkedHashMap保证了元素迭代的顺序。该迭代顺序可以是插入顺序或者是访问顺序。

LinkedHashMap可以认为是HashMap+LinkedList,即它既使用HashMap操作数据结构,又使用LinkedList维护插入元素的先后顺序

 

 

14.TreeMap(线程不安全,key不能为null,值可以为null)

没错,TreeMap能够对元素自动排序,实现顺序输出。

如果key是数字,默认按key值的升序输出。如果key是字符串,则按照A>...>Z>a>...>z的Ascll值输出。

		Map map = new HashMap();
		Random random = new Random();
		for(int i=0;i<20;i++) {
			map.put(random.nextInt(20), i*i);
		}
		
		Set keySet = map.keySet();//按key的顺序升序输出
		Object[] array = keySet.toArray();
		for(int i=0;i如果key是其他类型,则需要定义好排序规则,否则会报错。

 

 

15.HashTable(线程安全,值和key都不能为null)

HashMap和HashTable基本上是等价的,至于为什么还是要单独拿出来讲,因为面试实在问太多关于这两个类了。以下是转载的大佬的总结。

HashMap和Hashtable的区别

 

你可能感兴趣的:(你模糊的java基础)