集合框架1

最新推荐文章于 2024-06-19 15:09:37 发布

blake2

最新推荐文章于 2024-06-19 15:09:37 发布

阅读量175

点赞数

文章标签： java

本文链接：https://blog.csdn.net/blake2/article/details/111645881

版权

集合框架1

8.1.Java中集合框架的体系结构

集合框架---java做好的用来管理乱七八糟的一堆数据的java类库

集合----[乱七八糟的一堆]

框架---做好的javav

8.2.Collection接口与Map接口的区别

Collection接口	Map接口
处理单列数据的顶级接口【100 “hello”】	处理键值对数据的顶级接口【标题:页码】
可以使用Iterator迭代器接口遍历集合	没有Iterator迭代器接口

8.3.List接口与Set接口的区别

List接口	Set接口
有序	无序
可以有重复数据	不能有重复数据，指重复的数据算一个

8.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());
		}
	}
}

LinkedList类---public class LinkedList<E>

构造方法：

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() 从此列表中删除并返回最后一个元素。

为什么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());
		}
	}
}

8.5.ArrayList类与LinkedList类的区别

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

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

8.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.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());
		 }
	}
}

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

blake2

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
集合框架1

集合框架18.1.Java中集合框架的体系结构集合框架---java做好的用来管理乱七八糟的一堆数据的java类库集合----[乱七八糟的一堆] 框架---做好的javav8.2.Collection接口与Map接口的区别 Collection接口 Map接口处理单列数据的顶级接口【100 “hello”】处理键值对数据的顶级接口【标题:页码】 ...
复制链接

扫一扫