集合框架-1
1.Java中集合框架的体系结构
集合框架—java做好的用来管理乱七八糟的一堆数据的java类库
集合----[乱七八糟的一堆]
框架—做好的java类库
2.Collection接口与Map接口的区别
Collection接口 | Map接口 |
---|---|
处理单列数据的顶级接口【100 “hello”】 | 处理键值对数据的顶级接口【标题:页码】 |
可以使用Iterator迭代器接口遍历集合 | 没有Iterator迭代器接口 |
3.List接口与Set接口的区别
List接口 | Set接口 |
---|---|
有序 | 无序 |
可以有重复数据 | 不能有重复数据,指重复的数据算一个 |
4.ArrayList类和LinkedList类的用法
ArrayList类–public class ArrayList
构造方法:
- ArrayList() 构造一个初始容量为10的空列表。
- ArrayList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
- ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
package com.wangxing.listdemo;
import java.util.ArrayList;
public class TestArrayList1 {
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表。
ArrayList arraylist1=new ArrayList();
//ArrayList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
ArrayList arraylist2=new ArrayList(arraylist1);
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。 TODO Auto-generated method stub
ArrayList arraylist3=new ArrayList(30);
}
}
实例方法:
boolean add(Object o) 将指定的元素追加到此列表的末尾。
boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
Object get(int index) 返回此列表中指定位置的元素。
int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
Object remove(int index) 删除该列表中指定位置的元素。
boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
int size() 返回此列表中的元素数。
boolean isEmpty() 如果此列表不包含元素,则返回 true 。
void clear() 从列表中删除所有元素。
Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
package com.wangxing.listdemo;
import java.util.ArrayList;
public class TestArrayList2 {
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表。
ArrayList arraylist1=new ArrayList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
arraylist1.add("hello");
arraylist1.add(1234);
arraylist1.add(false);
arraylist1.add(12.5);
arraylist1.add("hello");
//boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
System.out.println("contains=="+arraylist1.contains("world"));
//Object get(int index) 返回此列表中指定位置的元素。
System.out.println("get=="+arraylist1.get(2));
//int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
System.out.println("indexOf=="+arraylist1.indexOf("world"));
//int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
System.out.println("lastIndexOf=="+arraylist1.lastIndexOf("hello"));
/*
//int size() 返回此列表中的元素数。
System.out.println("没有remove之前的size=="+arraylist1.size());
//Object remove(int index) 删除该列表中指定位置的元素。
arraylist1.remove(1);
//boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
arraylist1.remove("hello");
System.out.println("remove之后的size=="+arraylist1.size());
System.out.println("lastIndexOf=="+arraylist1.lastIndexOf("hello"));
*/
//Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
arraylist1.set(arraylist1.indexOf(false), true);
System.out.println(arraylist1.get(arraylist1.indexOf(true)));
//boolean isEmpty() 如果此列表不包含元素,则返回 true 。
System.out.println("isEmpty=="+arraylist1.isEmpty());
//void clear() 从列表中删除所有元素。
arraylist1.clear();
System.out.println("isEmpty=="+arraylist1.isEmpty());
}
}
遍历ArrayList
package com.wangxing.listdemo;
import java.util.ArrayList;
import java.util.Iterator;
public class TestArrayList3 {
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表。
ArrayList arraylist1=new ArrayList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
arraylist1.add("hello");
arraylist1.add(1234);
arraylist1.add(false);
arraylist1.add(12.5);
arraylist1.add("hello");
//普通的for循环
for(int i=0;i<arraylist1.size();i++) {
System.out.println(arraylist1.get(i));
}
System.out.println("________________________");
//增强的for循环
for(Object o:arraylist1) {
System.out.println(o);
}
System.out.println("________________________");
//迭代器
Iterator it=arraylist1.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
5.LinkedList类—public class LinkedList
构造方法:
- LinkedList() 构造一个空列表。
- LinkedList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
package com.wangxing.listdemo2;
import java.util.ArrayList;
import java.util.LinkedList;
public class TestLinkedList1 {
public static void main(String[] args) {
//LinkedList() 构造一个空列表。
LinkedList linkedList1=new LinkedList();
//LinkedList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
LinkedList linkedList2=new LinkedList(linkedList1);
ArrayList arrayList=new ArrayList();
LinkedList linkedList3=new LinkedList(arrayList);
//总结:代用Collection参数的构造方法可以用来进行集合类之间的转换
}
}
实例方法:
boolean add(Object o) 将指定的元素追加到此列表的末尾。
boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
Object get(int index) 返回此列表中指定位置的元素。
int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
Object remove(int index) 删除该列表中指定位置的元素。
boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
int size() 返回此列表中的元素数。
boolean isEmpty() 如果此列表不包含元素,则返回 true 。
void clear() 从列表中删除所有元素。
Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
一组对第一个元素和最后一个元素的操作方法
void addFirst(Object e) 在该列表开头插入指定的元素。
void addLast(Object e) 将指定的元素追加到此列表的末尾。
Object getFirst() 返回此列表中的第一个元素。
Object getLast() 返回此列表中的最后一个元素。
Object removeFirst() 从此列表中删除并返回第一个元素。
Object removeLast() 从此列表中删除并返回最后一个元素。
package com.wangxing.test2;
import java.util.LinkedList;
public class TestLinkedList2 {
public static void main(String[] args) {
//LinkedList的实力方法
/*
* boolean add(Object o) 将指定的元素追加到此列表的末尾。
* boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
* Object get(int index) 返回此列表中指定位置的元素。
* int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
* int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
* Object remove(int index) 删除该列表中指定位置的元素。
* boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
* Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
* int size() 返回此列表中的元素数。
* boolean isEmpty() 如果此列表不包含元素,则返回 true 。
* void clear() 从列表中删除所有元素。
* Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
*/
/*
* 一组对第一个元素和最后一个元素的操作方法
* void addFirst(Object e) 在该列表开头插入指定的元素。
* void addLast(Object e) 将指定的元素追加到此列表的末尾。
* Object getFirst() 返回此列表中的第一个元素。
* Object getLast() 返回此列表中的最后一个元素。
* Object removeFirst() 从此列表中删除并返回第一个元素。
* Object removeLast() 从此列表中删除并返回最后一个元素。
*/
//创建构造函数
LinkedList linkedlist1=new LinkedList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
linkedlist1.add("hello");
linkedlist1.add("123");
linkedlist1.add("world");
linkedlist1.add("456");
linkedlist1.add("hello");
//boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
boolean boo1=linkedlist1.contains("123");
System.out.println("有123?"+boo1);
//Object get(int index) 返回此列表中指定位置的元素。
System.out.println("返回第二个元素"+linkedlist1.get(2));
//int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
System.out.println("返回hello第一次出现位置"+linkedlist1.indexOf("hello"));
System.out.println("返回一个不存在的元素=="+linkedlist1.indexOf("689"));
//int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
System.out.println("返回hello最后一次出现位置"+linkedlist1.lastIndexOf("hello"));
System.out.println("返回一个不存在的元素=="+linkedlist1.lastIndexOf("689"));
//Object remove(int index) 删除该列表中指定位置的元素
linkedlist1.remove(1);//删除第1个元素
//boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
linkedlist1.remove("hello");//删除第一次出现的hello
//Object set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
linkedlist1.set(0, "hello");
//int size() 返回此列表中的元素数。
System.out.println("列表数:"+linkedlist1.size());
//boolean isEmpty() 如果此列表不包含元素,则返回 true 。
//查看是否为空列表
System.out.println("是否是空列表:"+linkedlist1.isEmpty());
// void clear() 从列表中删除所有元素。
// linkedlist1.clear();
//Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器
System.out.println("isEmpty=="+linkedlist1.isEmpty());
//void addFirst(Object e) 在该列表开头插入指定的元素。
linkedlist1.addFirst("xxx");
//void addLast(Object e) 将指定的元素追加到此列表的末尾。
linkedlist1.addLast("www");
//Object getFirst() 返回此列表中的第一个元素。
Object ob1=linkedlist1.getFirst();
System.out.println("第一个元素=="+ob1);
//Object getLast() 返回此列表中的最后一个元素。
Object ob2=linkedlist1.getLast();
System.out.println("最后一个元素=="+ob2);
// Object removeFirst() 从此列表中删除并返回第一个元素。
Object ob3=linkedlist1.removeFirstOccurrence("hello");
System.out.println("删除并返回第一个元素"+ob3);
//Object removeLast() 从此列表中删除并返回最后一个元素。
Object ob4=linkedlist1.removeFirstOccurrence("world");
System.out.println("删除并返回最一个元素"+ob4);
}
}
循环遍历:
package com.wangxing.test2;
import java.util.Iterator;
import java.util.LinkedList;
public class TestLinkedList3 {
public static void main(String[] args) {
//遍历LinkedList
//创建对象
LinkedList linkedlist1=new LinkedList();
//加入元素
linkedlist1.add("xxx");
linkedlist1.add("hello");
linkedlist1.add("123");
linkedlist1.add("world");
linkedlist1.add("456");
linkedlist1.add("www");
//for循环遍历
for(int i=0;i<linkedlist1.size();i++){
System.out.println(linkedlist1.get(i));
}
System.out.println("--------------");
//增强for循环遍历
for(Object o:linkedlist1){
System.out.println(o);
}
System.out.println("---------------");
//迭代器遍历
Iterator it=linkedlist1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
6.为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法?
因为ArrayList是动态数组结构,他在查找第一个元素和最后一个元素的时很麻烦,而LinkedList采用的是双向链表结构,这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过,我们可能不知道这列火车由几节车厢组成,但是我们一定会在第一时间看清第一节与最后一节车厢位置。
遍历LinkedList
package com.wangxing.listdemo2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
public class TestLinkedList3 {
public static void main(String[] args) {
//LinkedList() 构造一个的空列表。
LinkedList linkedList=new LinkedList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
linkedList.add("hello");
linkedList.add(1234);
linkedList.add(false);
linkedList.add(12.5);
linkedList.add("hello");
//普通的for循环
for(int i=0;i<linkedList.size();i++) {
System.out.println(linkedList.get(i));
}
System.out.println("________________________");
//增强的for循环
for(Object o:linkedList) {
System.out.println(o);
}
System.out.println("________________________");
//迭代器
Iterator it=linkedList.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
7.ArrayList类与LinkedList类的区别
ArrayList类 | LinkedList类 |
---|---|
动态数组结构 | 双向链表结构 |
查询快,添加删除慢 | 添加删除快,查询慢 |
没有提供对第一个元素和最后一个的操作 | 提供对第一个元素和最后一个的操作 |
适合大量查询操作 | 适合大量添加删除操作 |
有初始容量为10 | 没有初始容量 |
每次扩容后的大小为之前的1.5倍。 | 没有扩容机制 |
ArrayList类 | 数组 |
---|---|
保存元素的类型没有限制 | 保存元素的类型有限制 |
保存元素的存储空间会自动扩展 | 数组的元素存储空间是固定 |
8.HashSet类和LinkedHashSet类的用法
HashSet类–public class HashSet 此类实现Set接口 由哈希表支持
HashSet中保存的元素是没有顺序,重复的元素算一个。
构造方法:
HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。
package com.wangxing.set1;
import java.util.ArrayList;
import java.util.HashSet;
public class TestHashSet {
public static void main(String[] args) {
//HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
HashSet set1=new HashSet();
//HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
HashSet set2=new HashSet(set1);
ArrayList arraylist=new ArrayList();
HashSet set3=new HashSet(arraylist);
//HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
HashSet set4=new HashSet(20);
//HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。
HashSet set5=new HashSet(20,0.5f);
}
}
实例方法:
boolean add(Object e) 将指定的元素添加到此集合(如果尚未存在)。
void clear() 从此集合中删除所有元素。
boolean contains(Object o) 如果此集合包含指定的元素,则返回 true 。
boolean isEmpty() 如果此集合不包含元素,则返回 true 。
Iterator iterator() 返回此集合中元素的迭代器。
boolean remove(Object o) 如果存在,则从该集合中删除指定的元素。
int size() 返回此集合中的元素数(其基数)。
package com.wangxing.set1;
import java.util.ArrayList;
import java.util.HashSet;
public class TestHashSet2 {
public static void main(String[] args) {
//HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
HashSet set1=new HashSet();
//boolean add(Object e) 将指定的元素添加到此集合(如果尚未存在)。
set1.add("hello");
set1.add(1234);
set1.add(false);
set1.add("hello");
//int size() 返回此集合中的元素数(其基数)。
System.out.println("size=="+set1.size());
//boolean contains(Object o) 如果此集合包含指定的元素,则返回 true 。
System.out.println("contains=="+set1.contains("hello"));
//boolean isEmpty() 如果此集合不包含元素,则返回 true 。
System.out.println("isEmpty=="+set1.isEmpty());
//boolean remove(Object o) 如果存在,则从该集合中删除指定的元素。
System.out.println("remove=="+set1.remove("hello"));
System.out.println("size=="+set1.size());
//void clear() 从此集合中删除所有元素。
set1.clear();
System.out.println("size=="+set1.size());
}
}
遍历HashSet:
package com.wangxing.set1;
import java.util.HashSet;
import java.util.Iterator;
public class TestHashSet3 {
public static void main(String[] args) {
//HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
HashSet set1=new HashSet();
//boolean add(Object e) 将指定的元素添加到此集合(如果尚未存在)。
set1.add("hello");
set1.add(1234);
set1.add(false);
set1.add("hello");
/*
for(int i=0;i<set1.size();i++) {
System.out.println(set1.get(i));
}
*/
for(Object o:set1) {
System.out.println(o);
}
System.out.println("_______________");
Iterator it=set1.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
9.LinkedHashSet类
哈希表和链表实现了Set接口,具有可预测的迭代次序。 这种实现不同于HashSet,它维持于所有条目的运行双向链表。
因为LinkedHashSet类是HashSet类的子类,因此会从父类继承集合数据的操作方法,所以只要我们会HashSet类使用,那么LinkedHashSet类不用学也会用。
构造方法:
LinkedHashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
LinkedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
LinkedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
LinkedHashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。
package com.wangxing.test4;
import java.util.LinkedHashSet;
public class TestLinkedHashSet1 {
public static void main(String[] args) {
//构造方法:
/*
HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。
*/
LinkedHashSet hs1=new LinkedHashSet<>();
LinkedHashSet hs2=new LinkedHashSet<>(hs1);
LinkedHashSet hs3=new LinkedHashSet<>(30);
LinkedHashSet hs4=new LinkedHashSet<>(30,1.5f);
}
}
实例方法
boolean add(Object e) 将指定的元素添加到此集合(如果尚未存在)。
void clear() 从此集合中删除所有元素。
boolean contains(Object o) 如果此集合包含指定的元素,则返回 true 。
boolean isEmpty() 如果此集合不包含元素,则返回 true 。
Iterator
iterator() 返回此集合中元素的迭代器。
boolean remove(Object o) 如果存在,则从该集合中删除指定的元素。
int size() 返回此集合中的元素数(其基数)。
package com.wangxing.test4;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class TestLinkedHashSet2 {
public static void main(String[] args) {
//实例方法
/*
boolean add(Object e) 将指定的元素添加到此集合(如果尚未存在)。
void clear() 从此集合中删除所有元素。
boolean contains(Object o) 如果此集合包含指定的元素,则返回 true 。
boolean isEmpty() 如果此集合不包含元素,则返回 true 。
Iterator iterator() 返回此集合中元素的迭代器。
boolean remove(Object o) 如果存在,则从该集合中删除指定的元素。
int size() 返回此集合中的元素数(其基数)。
*/
//创建对象
LinkedHashSet hs1=new LinkedHashSet<>();
//添加元素
hs1.add("hello");
hs1.add("123");
hs1.add("world");
hs1.add("456");
//void clear() 从此集合中删除所有元素。
// hs1.clear();
//boolean contains(Object o) 如果此集合包含指定的元素,则返回 true
boolean bo1=hs1.contains("hello");
System.out.println("是否有hello"+bo1);
//boolean isEmpty() 如果此集合不包含元素,则返回 true 。
boolean bo2=hs1.isEmpty();
System.out.println("是否为空集合?"+bo2);
//Iterator iterator() 返回此集合中元素的迭代器。
Iterator it=hs1.iterator();
//boolean remove(Object o) 如果存在,则从该集合中删除指定的元素
System.out.println("remove=="+hs1.remove("hello"));
//int size() 返回此集合中的元素数(其基数)
System.out.println("返回元素个数"+hs1.size());
}
}
遍历循环:
package com.wangxing.test4;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class TestLinkedHashSet3 {
public static void main(String[] args) {
//循环遍历LinkedHashSet
//创建对象
LinkedHashSet hs1=new LinkedHashSet<>();
//添加元素
hs1.add("hello");
hs1.add("123");
hs1.add("world");
hs1.add("456");
//for遍历
/*
for(int i=0; i<hs1.size();i++){
System.out.println(hs1.get(i));
}
*/
//增强for循环
for(Object o:hs1){
System.out.println(o);
}
System.out.println("------------------");
//迭代器
Iterator it=hs1.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
LinkedHashSet与HashSet区别是HashSet在遍历输出的时候无序,LinkedHashSet在在遍历输出的时候按照插入顺序输出。