javaSE---集合框架1

集合框架-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在在遍历输出的时候按照插入顺序输出。