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

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

东方-教育技术博主

10285人浏览 · 2018-08-18 17:41:04

东方-教育技术博主 · 2018-08-18 17:41:04 发布

累计时间： 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转载抄袭几篇的文章。

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

个人看法，谢谢！

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...