集合框架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.arraylisttest;

import java.util.ArrayList;

public class ArrayListTest1 {
	public  static  void  main(String args[]){
		//ArrayList--类--实现了List的接口
		//ArrayList类主要处理有序的单列数据集合类
		//构造方法
		//ArrayList() 构造一个初始容量为10的空列表。 
		ArrayList list1=new ArrayList();
		//ArrayList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
		ArrayList list2=new ArrayList(list1);
		//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
		ArrayList list3=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.arraylisttest;

import java.util.ArrayList;

public class ArrayListTest2 {
	public  static  void  main(String args[]){
		//ArrayList的常用实例方法
		ArrayList  list1=new ArrayList();
		//boolean	add(Object o) 将指定的元素追加到此列表的末尾。 
		list1.add("hello");
		list1.add(1234);
		list1.add(true);
		list1.add(12.5);
		list1.add("world");
		list1.add("hello");
		//int	size() 返回此列表中的元素数。 
		System.out.println("size=="+list1.size());//6
		//boolean	contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		String  contains=(list1.contains("helloworld"))?"存在":"不存在";
		System.out.println("contains=="+contains);
		//Object 	get(int index) 返回此列表中指定位置的元素。 
		System.out.println("get=="+list1.get(2));
		//int	indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("indexOf=="+list1.indexOf("helloworld"));
		//int	lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 
		System.out.println("lastIndexOf=="+list1.lastIndexOf("hello"));
		//Object 	remove(int index) 删除该列表中指定位置的元素。 
		list1.remove(3);
		System.out.println("size=="+list1.size());//5
		//boolean	remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
		list1.remove("hello");
		System.out.println("size=="+list1.size());//4
		System.out.println("get=="+list1.get(3));
		//Object 	set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。 
		list1.set(3,"zhangsan");
		System.out.println("get=="+list1.get(3));
		//boolean	isEmpty() 如果此列表不包含元素，则返回 true 。
		System.out.println("isEmpty=="+list1.isEmpty());
		//void	clear() 从列表中删除所有元素。
		list1.clear();
		System.out.println("isEmpty=="+list1.isEmpty());
		System.out.println("size=="+list1.size());
		/*
		Iterator<E>	iterator() 以正确的顺序返回该列表中的元素的迭代器。 
		*/
	}
}

遍历ArrayList

package com.wangxing.arraylisttest;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest3 {
	public  static  void  main(String args[]){
		//ArrayList的遍历方式
		ArrayList  list1=new ArrayList(); 
		list1.add("hello");
		list1.add(1234);
		list1.add(true);
		list1.add(12.5);
		list1.add("world");
		list1.add("hello");
		//普通的for循环遍历Arraylist
		for(int i=0;i<list1.size();i++){
			//利用get方法得到指定位置上的元素
			Object obj=list1.get(i);
			System.out.println("obj=="+obj);
		}
		System.out.println("---------");
		//增强的for循环遍历Arraylist
		for(Object  obj:list1){
			System.out.println("obj=="+obj);
		}
		System.out.println("---------");
		/*
		Iterator<E>	iterator() 以正确的顺序返回该列表中的元素的迭代器。 
		//hasNext()--判断迭代器是否存在下一个元素【如果存在返回值为true】
		//next()---从迭代器中得到下一个元素的值
		*/
		Iterator  iterator=list1.iterator();
		while(iterator.hasNext()){
			Object  obj=iterator.next();
			System.out.println("obj=="+obj);
		}
	}
}

LinkedList类---public class LinkedList<E>

构造方法

LinkedList() 构造一个空列表。

LinkedList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表

package com.wangxing.listtest1;

import java.util.ArrayList;
import java.util.LinkedList;

public class LinkedListTest1 {

	public static void main(String[] args) {
		//LinkedList类---实现了List接口
		//LinkedList类处理有序的单列数据集合类
		//构造方法
		//LinkedList() 构造一个空列表。 
		LinkedList  list1=new LinkedList();
		//LinkedList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表
		LinkedList  list2=new LinkedList(list1);
		ArrayList  arr1=new ArrayList();
		LinkedList  list3=new LinkedList(arr1);
	}

}

实例方法

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会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？

因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。

遍历LinkedList

package com.wangxing.listtest1;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest3 {

	public static void main(String[] args) {
		//LinkedList的遍历方式
		LinkedList list1 = new LinkedList();
		list1.add("hello");
		list1.add(1234);
		list1.add(true);
		list1.add(12.5);
		list1.add("world");
		list1.add("hello");
		// 普通的for循环遍历LinkedList
		for (int i = 0; i < list1.size(); i++) {
			// 利用get方法得到指定位置上的元素
			Object obj = list1.get(i);
			System.out.println("obj==" + obj);
		}
		System.out.println("---------");
		// 增强的for循环遍历LinkedList
		for (Object obj : list1) {
			System.out.println("obj==" + obj);
		}
		System.out.println("---------");
		/*
		 * Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
		 * //hasNext()--判断迭代器是否存在下一个元素【如果存在返回值为true】
		 * //next()---从迭代器中得到下一个元素的值
		 */
		Iterator iterator = list1.iterator();
		while (iterator.hasNext()) {
			Object obj = iterator.next();
			System.out.println("obj==" + obj);
		}
	}

}

5.ArrayList类与LinkedList类的区别

ArrayList类	LinkedList类
动态数组结构	双向链表结构
查询快，添加删除慢	添加删除快，查询慢
没有提供对第一个元素和最后一个的操作	提供对第一个元素和最后一个的操作
适合大量查询操作	适合大量添加删除操作
有初始容量为10	没有初始容量
每次扩容后的大小为之前的1.5倍。	没有扩容机制

ArrayList类	数组
保存元素的类型没有限制	保存元素的类型有限制
保存元素的存储空间会自动扩展	数组的元素存储空间是固定

6.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.hashset;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;

public class HashSetTest1 {

	public static void main(String[] args) {
		//HashSet类--public class HashSet  此类实现Set接口 [无序]
		//HashSet集合中的元素也是无序，没有重复元素，重复的元素算一个
		//构造方法
		//HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。 
		HashSet set1=new HashSet();
		//HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。 
		HashSet set2=new HashSet(set1);
		
		ArrayList list1=new ArrayList();
		HashSet set3=new HashSet(list1);
		
		LinkedList list2=new LinkedList();
		HashSet set4=new HashSet(list2);
		//HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。 
		HashSet  set5=new HashSet(30);
		//HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。 
		HashSet  set6=new HashSet(30,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.hashset;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;

public class HashSetTest2 {

	public static void main(String[] args) {
		//HashSet类常用的实例方法
		HashSet  set1=new HashSet();
		//boolean	add(Object e) 将指定的元素添加到此集合（如果尚未存在）。 
		set1.add("hello");
		set1.add(1234);
		set1.add(true);
		set1.add(12.5);
		set1.add("world");
		//int	size() 返回此集合中的元素数（其基数）。
		System.out.println("size=="+set1.size());
		//重复的元素算一个。
		set1.add("hello");
		System.out.println("size=="+set1.size());
		//boolean	contains(Object o) 如果此集合包含指定的元素，则返回 true 。 
		String contains=(set1.contains("helloworld"))?"存在":"不存在";
		System.out.println("contains=="+contains);
		//boolean	remove(Object o) 如果存在，则从该集合中删除指定的元素。 
		set1.remove("world");
		System.out.println("size=="+set1.size());
		//boolean	isEmpty() 如果此集合不包含元素，则返回 true 。
		System.out.println("isEmpty=="+set1.isEmpty());
		//void	clear() 从此集合中删除所有元素。 
		set1.clear();
		System.out.println("isEmpty=="+set1.isEmpty());
		/*
		Iterator	iterator() 返回此集合中元素的迭代器。 
		*/ 
	}

}

遍历HashSet

package com.wangxing.hashset;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest3 {

	public static void main(String[] args) {
		//HashSet集合的遍历
		HashSet  set1=new HashSet();
		//boolean	add(Object e) 将指定的元素添加到此集合（如果尚未存在）。 
		set1.add("hello");
		set1.add(1234);
		set1.add(true);
		set1.add(12.5);
		set1.add("world");
		set1.add("hello");
		//普通for循环无法直接遍历HashSet集合
		//通过ArrayList(Collection c)/LinkedList(Collection c)可以将HashSet集合
		//转换成ArrayList/LinkedList集合，从而使用普通for循环遍历
		ArrayList  list1=new ArrayList(set1);
		for(int i=0;i<list1.size();i++){
			Object obj=list1.get(i);
			System.out.println("obj=="+obj);
		}
		System.out.println("—————————————");
		//增强的for循环遍历HashSet集合
		for(Object obj:set1){
			System.out.println("obj=="+obj);
		}
		System.out.println("—————————————");
		/*
		Iterator	iterator() 返回此集合中元素的迭代器。 
		*/ 
		Iterator iterator=set1.iterator();
		while(iterator.hasNext()){
			Object  obj=iterator.next();
			System.out.println("obj=="+obj);
		}
	}
}

LinkedHashSet类

哈希表和链表实现了Set接口，具有可预测的迭代次序。这种实现不同于HashSet，它维持于所有条目的运行双向链表。

因为LinkedHashSet类是HashSet类的子类，因此会从父类继承集合数据的操作方法，所以只要我们会HashSet类使用，那么LinkedHashSet类不用学也会用。

LinkedHashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。

LinkedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。

LinkedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。

LinkedHashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。

实例方法

boolean	add(Object e) 将指定的元素添加到此集合（如果尚未存在）。
void	clear() 从此集合中删除所有元素。
boolean		contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean		isEmpty() 如果此集合不包含元素，则返回 true 。
Iterator		iterator() 返回此集合中元素的迭代器。
boolean		remove(Object o) 如果存在，则从该集合中删除指定的元素。
int		size() 返回此集合中的元素数（其基数）。

LinkedHashSet与HashSet区别是HashSet在遍历输出的时候无序，LinkedHashSet在在遍历输出的时候按照插入顺序输出。

java 集和框架1

集合框架1

猜你喜欢