java集合collection体系思维导图整理

最新推荐文章于 2024-08-05 23:39:18 发布

东方-教育技术博主

最新推荐文章于 2024-08-05 23:39:18 发布

阅读量1w

点赞数 19

分类专栏： java 文章标签： java集合 collection 思维导图自定义哈希比较规则存放

本文链接：https://blog.csdn.net/qq_41517071/article/details/81810619

版权

java 专栏收录该内容

68 篇文章 0 订阅

订阅专栏

累计时间： 2小时

知识点补充：

存放数据的容器：数组：
1：数组的长度固定：

Student stu[] = new Student[20];

new Student("lisi",21);

数组扩容：
（1）创建一个临时的数组：
（2）将数组的内容copy到临时数组。
（3）原来的数组扩容：
（4）把临时数组当中的内容copy回来：

2：集合：存放数据。
当存放的内容数量不固定，不确定，有限采用集合。

3：区别：
（1）数组的长度是固定。
数组存放的数据类型，必须相同或者是相兼容：
（2）集合自动扩容。
集合当中可以存放任意的数据类型：

一：集合：
1：在JDK1.0 时候，提供了集合：

线性表：
Vector
|
stack

映射结构：
Dictionary（目录）
|
Hashtable
|
Properties

在JDK1.2 新添加了集合类：形成了集合框架：

线性表结构：
Collection（接口）
|-------List：（接口）允许重复元素：
|------ArrayList： (重要)
|------Vector：
|------Stack：
|------LinkedList:
|-------Set：（接口）元素不能重复：
|------HashSet：
|------TreeSet：
|------LinkedHashSet：
|-------Queue：（接口）
|------LinkedList：

实现类：底层根据数据结构不同而区分：


映射结构;
Map
|----HashMap： (重点)
|----TreeMap:
|----Hashtable:
|----Properties: （重点）

学习：看顶层，用底层：

二：集合：位于java.util.*;

Collection :接口：

add(Object obj);
addAll(Collection c);

remove(Object);
removeAll(Collection c);

clear();
size();
contains();
containsAll();
isEmpty();
toArray();
retainAll();

iterator();


三：集合的细节：

* 1：存放在集合当中，存放对象的引用：
* 2: 往集合当中存放内容，元素失去了原有的类型，自动提升为Object类型：
* 3：集合当中不能存放基本数据类型，但是在JDK1.5后，有自动装箱功能：

四： List接口：
特点：存放的元素有序，可重复，支持下标访问。
List集合：围绕索引添加了一系列的方法：

增加：
add(index, obj);
addAll(int index, Collection<? extends E> c)

删除：
remove(int index) ;

改：
set(int index, E element)

查：
get(int index)

一：集合：
Collection集合：
|---List：元素可重复，有序，支持下标访问：
|----ArrayList: 底层是数组：查询块，增删相比稍慢，可以被接收。
该类的所有的方法都是异步：数据不安全，效率高。
|---- new ArrayList(); 初始容量大小为10. 加载因子： 0.5。 50%扩展：
|---- new ArrayList(Collection c);将Collection集合的实现类转换成一个ArrayList集合：
|---- new ArrayList(int num); 指定初始容量大小：（不建议使用：）

|----Vector类：底层数组：该类已经被ArrayList取代。
该类的实现：线程同步，数据安全，效率低。

|---- new Vector(); 创建一个空集合：初始容量大小为10，两倍扩展：底层数组：方法实现：同步，数据安全，

效率低
|----- new Vector(Collection<? extends E> c) 将一些其他的集合对象转换成Vector集合：

|------elements(); 获得一个枚举：元素的个数可以被列举：

|-----LinkedList ：类：底层是链表结构：主要是针对头元素和尾元素进行操作：

其他在思维导图中已经全部说明。





二：面试问题;
(1) Vector 和 ArrayList的区别：
共同点：
不同点：

(2) 给定一个ArrayList集合，使用枚举遍历;

(3) String StringBuilder StringBuffer 三者之间的异同点：
StringBuilder：线程异步，数据不安全，效率高。
StringBuffer：线程同步，数据安全，效率低：

(4) 面试问题：模拟队列： LinkedList：

// 模拟栈结构：

三： LinkedList：类：
API方法“：

添加头和尾：
addFirst(E e)
addLast(E e)
获得头和尾：
getFirst()
getLast();

移除头和尾部;
removeFirst()
removeLast()
如果集合当中没有操作的该元素，会抛出异常：

去除List 集合当中的重复元素：


====================
以下三组方法; 在JDK1.6时候存在：如果集合当中没有可操作的元素，返回null。
添加头和尾
offerFirst(E e)
offerLast(E e)
获得头和尾：
peekFirst()
peekLast()
移除头和尾部;
pollFirst()
pollLast()

push();


栈： Stack ：特点： FILO：先进后出：
队列： Queue ：特点： FIFO：先进先出：

图中没有提到map 作补充后面再补一张图：

List集合与Map集合的关系

从底层实现来看，Set集合和Map集合很类似；从用法的角度来看，List集合和Map集合也有很多类似的地方。

Map接口提供了get(K key)方法，允许Map对象根据key来取得对应的value。
List接口提供了get(int index)方法，允许List对象根据元素索引index来取得对应的value。

即可以说List相当于所有key都是int类型的Map，也可以说Map是相当于索引是任意类型的List。

2018年8月18日17:44:06于易动

不太完整待更ing。。

下面是代码例子：

List类

ArrayList：

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

public class ListDemo01 {
	public static void main(String[] args) {
	       /*
		        增加： 
		   add(index, obj);
		   addAll(int index, Collection<? extends E> c)
		    */
		
		 List list= new ArrayList(); 
		 
		 list.add(0,"你好吗？");
		 list.add(1,"你好吗？");
		 list.add(2,"一般");
		 
		 
		 System.out.println(list);
		
		
		
		
		   
		/*  删除： 
		  remove(int index) ;*/ 
//		 list.remove("")
		 list.remove(1);
		 System.out.println(list);
		  
	/*
	   	  改： 
		  set(int index, E element)
		   */
		 list.set(1, "今天周五");
		  
	/*	  查： 
		 get(int index) */
		 Object object = list.get(1);
		 System.out.println(object);
		 
		 
		 //List遍历方式： 
		 
		 System.out.println("==========================");
		 for(int i=0 ; i<list.size();i++){
			 System.out.println(list.get(i));
		 }
		 
		 System.out.println("==========================");
		 Iterator it = list.iterator();
		 while(it.hasNext()){
			 Object next = it.next();
			 System.out.println(next);
		 }
		 System.out.println("==========================");
		 //增强的for循环： 
		 for(Object obj: list){
			
			 System.out.println(obj);
		 }
		 
		 /*
		  * 传统的for循环：   当对某个元素的内容进行相关操作的时候，一般使用传统for循环： 
		  * 增强的for： 只用来遍历： 
		  */
		 
		 
	}
}

Vector类

实现添加元素和迭代遍历

package com.guangyu.copy;

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

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo01 {
	public static void main(String[] args) {
		Vector v= new Vector(); 
		
		v.add("a");
		v.add("b");
		v.add("c");
		v.add("d");
		
		//使用枚举迭代每一个元素
		Enumeration elements = v.elements();
		
		
		while(elements.hasMoreElements()){
			Object nextElement = elements.nextElement();
			System.out.println(nextElement);
		}
		
		
		
		/*
		 * Vector 类： 迭代的方式： 
		 *  （1）枚举： 
		 *  （2）迭代器： 
		 *  （3）反向迭代器： 
		 *  （4）传统for循环：  get(index )
		 *  （5）增强for循环： 
		 *  
		 */
//		v.iterator();
		
		
		
		System.out.println(v.capacity());
	}
}

LinkedList类

实现模拟堆栈结构存储

package com.guangyu.copy;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo01 {
	public static void main(String[] args) {
LinkedList list = new LinkedList();
		
		list.addFirst("a");
		list.addFirst("b");
		list.addFirst("c");
		list.addFirst("d");
		
		System.out.println(list);// list: [d, c, b, a]
		
		System.out.println(list.getFirst());// d
//		System.out.println(list.removeFirst());// d
//		System.out.println(list.removeFirst());// c
		System.out.println("==============");
		/*while(!list.isEmpty()){
			String str= (String)list.removeFirst();
			System.out.println(str);// dcba   模拟了栈结构： 
		}*/
		
		while(!list.isEmpty()){
			String str= (String)list.removeLast();
			System.out.println(str);// dcba   模拟了队列结构： 
		}
		
//		list.removeLast();   NoSuchElementException  
	}
}

Queue类

LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

所以说 queue 还是用链表结构实现的，学过数据结构的话，就知道用双向指针实现的。

下面程序模拟实现队列和调用方法：

import java.util.LinkedList;

/*
 * 使用LinkedList模拟队列： 
 *  队列的特点： FIFO
 */
public class Queue {

	 // LinkedList: 
	private LinkedList list; 
	public Queue(LinkedList list){
		this.list= list; 
	}
	
	// 模拟添加的方法; 
	public void myAdd(Object obj){
		list.offerFirst(obj);
	}
	
	//定义取元素的方法;
	public Object myGet(){
		Object obj = list.pollLast();
		return obj;
	}
	
	//判断是否为空： 
	public boolean MyIsEmpty(){
		return list.isEmpty();
	}
	
	
	 
}

public class QueueDemo01 {
	public static void main(String[] args) {
		//Queue 接口： LinkedList ： 
		
		Queue q = new LinkedList();  
	
		
		//队列的特点： 先进先出： FIFO
		
		// offer
		
		q.offer("abd");
		q.offer("dba");
		q.offer("java");
		q.offer("xiaoxuedi");
		
		// peek: 集合当中没有任何的元素 返回null。 不移除：  
		
		Object peek = q.peek();
		System.out.println(peek);
		System.out.println(peek);
		
		//poll 获得头，并且移除：
		
		Object poll = q.poll();
		Object poll2 = q.poll();
		
		 System.out.println(poll);
		 System.out.println(poll2);
		 
		 System.out.println("==========");
		 while(!q.isEmpty()){
			 
			 Object poll3 = q.poll();
			 System.out.println(poll3);
		 }
	}
}

Set类

Treeset：

1 存放元素按照默认的规则

import java.util.TreeSet;

public class TreeDemo01 {
	public static void main(String[] args) {
		//创建一个treeset对象： 
		TreeSet set = new TreeSet();// treeset集合当中存放的元素： 按照默认的规则存放： 
		
		set.add("cba");
		set.add("zba");
		set.add("nba");
		set.add("abc");
		
		
		// 底层原理： 二叉树：
		
		
		System.out.println(set);
	}
}

2 按照自定义比较规则存放（优先级高于默认的比较规则）

如果你没有指定规则的话，你的对象有多个类型无法比较时，会抛出类转换异常。所以自定义比较方法，如果指定泛型，在自定义的时候会自动出现你要比较的对象所在的类的类型。

public class TreeSetDemo03 {
	@SuppressWarnings("all")
	public static void main(String[] args) {
		/*
		 * 演示： 自定义比较规则，存放字符串： 
		 * 
		 * 需求： 字符串的默认的字典顺序，不能满足实际的需求： 需要
		 * 自定义比较规则：  根据字符串的长度进行降序排序：
		 */
		
        TreeSet set = new TreeSet(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				/*
				 * 长度的降序： 长度相同， name的升序：
				 */
				int num1= o2.length()- o1.length(); 
				return num1==0 ? o1.compareTo(o2):num1;
			}
		});// treeset集合当中存放的元素： 按照默认的规则存放： 
		
        set.add("nibiexxxx");
		set.add("a");
		set.add("b");
		set.add("zba");
		set.add("kknba");
		
		System.out.println(set);
		
		
		
	}
}

上面程序在创建对象的时候，指定泛型String。然后实现接口的方法

https://blog.csdn.net/u012250875/article/details/55126531

LinkedHashSet：

import java.util.LinkedHashSet;

public class LinkedHashSetDemo01 {
	public static void main(String[] args) {
		//创建一个对象： 
		/*
		 * 有序：按照存放的顺序：
		 * 唯一： 通过哈希码：和equals 保证元素的唯一： 
		 */
		LinkedHashSet ls = new LinkedHashSet();
		ls.add("java");
		ls.add("spring");
		ls.add("spring");
		ls.add("struts");
		ls.add("hibernate");
		ls.add("springboot");
		
		System.out.println(ls);
		
		
		
		
	}
}

存的时候默认的是字符串的比较方法。可以自定义一个类继承接口重写compare方法。

import java.util.Comparator;

/*
 * 自定义比较规则： 
 *  该规则被重复利用的时候，可以定在再外部，形成一个单独的类： 
 */

 public class myCompatorByLength implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		//指定了一个比较规则： 根据字符串的长度进行降序排序： 
		String str1= (String)o1;
		String str2= (String)o2;
		
		// 长度相同： 按照字符串的升序排序： 
		int num2= str1.compareTo(str2);
		int num1=  str2.length() - str1.length(); 
		return num1==0? num2:num1;
	}
	
}

EmumSet：

专门为枚举设计的集合，适合批量操作。

这个自己没啥心得转载一篇吧https://blog.csdn.net/chengqiuming/article/details/70139107

2018年8月22日11:03:50于易动

完善了一下集合，不想让自己写的东西是那种复制API转载抄袭几篇的文章。

要么不急着写，要么就等自己有所心得的时候再写，水平高不高无所谓，主要是自己的东西就好，

个人看法，谢谢！

东方-教育技术博主

关注

19
点赞
踩
53

收藏

觉得还不错? 一键收藏
打赏
10
评论
java集合collection体系思维导图整理

累计时间： 2小时知识点补充：存放数据的容器：数组： 1：数组的长度固定： Student stu[] = new Student[20]; new Student("lisi",21); 数组扩容：（1）创建一个临时的数组：（2）将数组的内容copy到临时数组。（3）原来的数组扩容：（4...
复制链接

扫一扫