集合框架简介

最新推荐文章于 2022-04-21 15:26:56 发布

qq_45177371

最新推荐文章于 2022-04-21 15:26:56 发布

阅读量236

点赞数

本文链接：https://blog.csdn.net/qq_45177371/article/details/90911952

版权

1、集合框架（简介、Collection方法、迭代器）
在这里插入图片描述

集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器

数据结构

集合框架的由来：数据多了用对象进行存储，对象多了用集合来进行存储。

而存储数据的方式（数据结构）各有不同，所以存储的容器也就有多种，从而形成了集合框架这一体系。

l
l

Collection方法

    通过Collection的子类ArrayList来实现
	**迭代器**
	public class a {
	public static void main(String[] args) {
		  ArrayList ai=new ArrayList<>();
		  ai.add(1);
		  ai.add(2);
		  ai.add(3);
		  ai.add(4);
		  ai.add(5);		
		  ai.add(6);
		  ai.add(8);  
           
          集合List的三种遍历方式
         Iterator it = ai.iterator();
		  while(it.hasNext()){//hasNext表示是否有下一个
			  System.out.println(it.next());
		  }
		  
		  //使用foreach遍历出来
		  for (Object obj : ai) {
			System.out.println(obj);
		}
		//也可以通过下标输出
		  for (int i=0; i < ai.size(); i++) {
			  System.out.println(ai.get(i));
			
		}
		
	 //先删除在遍历，移除所有
	  while(it.hasNext()){	  
//			  ai.remove(it);
//			  System.out.println(it.next());
//		  }

迭代器的一个走向
在这里插入图片描述

	  //输出偶数
	  while(it.hasNext()){
		  int obj =  (Integer)it.next();
		  if(obj%2==0){
			  //假如上一个数是偶数，就输出下一个
			  System.out.println(it.next());
			  //输出全部偶数
			  System.out.println(obj);
		  }
	  }
}

//再举一个形象的例子：
//	把夹娃娃机比作集合；那么夹娃娃的钩子就可以看成集合中的迭代器；夹娃娃必须通过娃娃机内部的钩子；
//而钩子的外挂、移动方式等等都不相同，所以只能定义一个规则，而这个规则就可以看成几何内部的一个//迭代器接口Iterator；
//有兴趣的可以看看jdk源码。

2、集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）集合框架就是了解容器的数据结构

1、list集合相对于collection集合所特有的方法

 有下标，可以删除指定下标元素，而collection没有下标
 * 2、Iterator.remove()与Collection.remove()的区别
 * 3、Iterator与ListIterator的区别
 *
 * Collection
 * List	有序	元素可以重复	因为该集合体系有索引（特点，删除后会下标会自动补上来，比如123，删除3，原来的4就变成了3，插入的时候一样，下标往下挤，删除和增加时所有的变量的下标都会有变化，所以慢）
 *

Arraylist 数组结构增删慢，查询快速有连续下标线程不同步增长因子为1.5 10

ArrayList和array的区别
array自己定义
ArrayList的底层是个数组，默认长度为10，增长因子为1.5，超过10的时候1.51.5在10==22.5，此时它的长度就变成了22，如果超过22，1.51.51.5*10=33.75，此时为的长度为33，以此类推

package com.hc;

import java.lang.reflect.Field;
import java.util.ArrayList;

/**


## 增 加Add(index,element)


public class ListDemo {
	public static void main(String[] args) {
	  ArrayList ai=new ArrayList<>();
	  ai.add(1);
	  ai.add(2);
	  ai.add(3);
	  ai.add(4);
	  ai.add(5);
	  ai.add(6);
	  ai.add(8);
	  //增加
	  ai.add(3,"a");
	  System.out.println(ai);

删除Remove(index)

public class ListDemo {
	public static void main(String[] args) {
	  ArrayList ai=new ArrayList<>();
	  ai.add(1);
	  ai.add(2);
	  ai.add(3);
	  ai.add(4);
	  ai.add(5);
	  ai.add(6);
	  ai.add(8);
      ai.remove(2);
	  System.out.println(ai);

//修改Set(index,element)

public class ListDemo {
	public static void main(String[] args) {
	  ArrayList ai=new ArrayList<>();
	  ai.add(1);
	  ai.add(2);
	  ai.add(3);
	  ai.add(4);
	  ai.add(5);
	  ai.add(6);
	  ai.add(8);
      ai.set(2,"aaaa");
	  System.out.println(ai);

查询Get(index)

public class ListDemo {
public static void main(String[] args) {
  ArrayList ai=new ArrayList<>();
  ai.add(1);
  ai.add(2);
  ai.add(3);
  ai.add(4);
  ai.add(5);
  ai.add(6);
  ai.add(8);
  ai.get(1);
  System.out.println(ai);

* 论证增长因子论证

 * @author Administrator
 *
 */
public class ArrayListDemo {
	public static void main(String[] args) throws Exception {
		ArrayList ai = new ArrayList<>();
		for (int i = 0; i < 60; i++) {
			ai.add(i);
			System.out.println(i+",");
			getLen(ai);
			
		}
		
	}
	
	public static void getLen(ArrayList ai) throws Exception{//异常
	 Field fieid=ai.getClass().getDeclaredField("elementData");
	 fieid.setAccessible(true);
	 Object obj = fieid.get(ai);
	 Object[] elementData = (Object[])obj;
	System.out.println("当前操作的list集合中底层存放数据的容器的长度"+elementData.length);
	 
	}

}

vector 数组结构增删改查都慢有连续下标线程同步增长因子2 10

（同步指有锁旗标，性能好，不同步线程则没有）
原数组的默认长度为10，一旦超过这种长度它的长度就会以原来的数组长度情况下乘以2，取整。
例如一开始默认为10,超过之后就会2*2*10=40；然后长度就变成了40，超过四十，就是2*2*2*10=80
list集合的调优
*  Linkedlist 链表结构 增删快，查询慢 没有连续下标
* Set	无序	元素不可以重复
 链表结构图

在这里插入图片描述
只能取到自己的左右两个变量，没有下标，查询慢，但是增删快

 * List：凡是可以操作角标的方法都是该体系所特有的方法
 * 增
 * Add(index,element)
 * Add(index,Collection)
 *
 * 删
 * Remove(index)
 *
 * 改
 * Set(index,element)
 *
 * 查
 * Get(index)
 * subList(from,to)
 * listIterator()
 * index(element)
 *
 * list集合所特有的迭代器，ListIterator是Iterator的子接口
 * 在迭代时，不可以通过集合对象的方法操作集合中的元素；
 * 因为会发生并发修改异常（ConcurrentModificationException）；
 * 所以，在迭代时，只能通过迭代器来操作元素，课时Iterator的方法是有限的，Iterator只提供了判断、
 * 取出、删除的操作；
 * 如果想要有其他的操作，如添加、修改等，就需要使用其子接口ListIterator，该接口只能list集合的listIterator方法来获取
 */

//List接口介绍

package com.hc;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ListDemo {
	public static void main(String[] args) {
	  ArrayList ai=new ArrayList<>();
	  ai.add(1);
	  ai.add(2);
	  ai.add(3);
	  ai.add(4);
	  ai.add(5);
	  ai.add(6);
	  ai.add(8);
	  //正常情况顺序遍历展示所有
	  ListIterator it = ai.listIterator();
	  while(it.hasNext()){
			  System.out.println(it.next());
		  }
	  //倒叙遍历集合
	  while(it.hasPrevious()){
		  System.out.println(it.previous());
	  }
		  
	  }

}

3、集合框架Vector

package com.hc;

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

public class VectorDemo {
	
	/**bb
	 * Vector
	 */
	
	public static void main(String[] args) {
		Vector v=new Vector<>();
		v.add("aa");
		v.add("bb");
		v.add("cc");
		Enumeration a=v.elements();
		//遍历输出
		while(a.hasMoreElements()) {
			System.out.println(a.nextElement());
		}
	}

}

了解一下枚举

4、集合框架LinkedList 链表的数据结构

由于是链表结构，当前节点能够记住上一个节点、以及下一个节点，所有有带First、last的方法存在。
模拟队列以及堆栈

堆栈：先进后出	子弹夹

队列：先进先出	水管

在这里插入图片描述

模拟队列以及堆栈

1.堆栈

堆栈的特点：每一次都将元素放在容器的顶部，如图所示,取元素的时候先从容器顶部取出
在这里插入图片描述

堆栈特点演示

package com.hc;
import java.util.Iterator;
import java.util.LinkedList;

/**
 * @author Administrator
 *堆栈的特点：每一次都将元素放在容器的顶部
 *取元素的时候先从容器顶部取出
 */
public class LinkedlistDemo {
	public static void main(String[] args) {
		duiz dz = new duiz();
		dz.push(1);
		dz.push(2);
		dz.push(3);
		dz.push(4);
		dz.push(6);
		dz.bianli();
	}
	

}

//编辑堆栈方法

class duiz{
	private LinkedList  lk = new LinkedList<>();
	//存放进容器
	public void push(Object obj){
		lk.addFirst(obj);
	}
	//取出元素
	public Object pop() {
		return lk.removeFirst();
	}
	
	//使用迭代器遍历方法
	public void bianli() {	
		Iterator it = lk.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

2.队列

在这里插入图片描述

队列特点演示

public class LinkedlistDemo {
	public static void main(String[] args) {
		duilie dz =new duilie();
		dz.push(1);
		dz.push(2);
		dz.push(3);
		dz.push(4);
		dz.push(6);
		dz.bianli();
	}
	}
	//编辑队列方法
	class duilie{
	private LinkedList  lk = new LinkedList<>();
	//存放进容器
	public void push(Object obj){
		lk.addLast(obj);
	}
	//取出元素
	public Object pop() {
		return lk.removeFirst();
	}
		//使用迭代器遍历方法
	public void bianli() {	
		Iterator it = lk.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

特有方法

    在当前的节点下面的前一个添加一个
	addFirst();
    在当前节点的后面添加一个
	addLast();
   当前列表第一个
	getFirst();            
    当前列表最后一个 
	getLast();
	   移除当前列表第一个
	removeFirst();
      移除当前列表最后一个
	removeLast();

5、集合框架ArrayList中的重复元素去重及其底层原理

ArrayList集合中去除对象重复

package com.hc;

import java.util.ArrayList;

public class ArrayListDemo2 {
public static void main(String[] args) {
		
		ArrayList al=new ArrayList<>();
		al.add(new person("zs","18"));
		al.add(new person("ls","14"));
		al.add(new person("ww","12"));
		al.add(new person("zs","18"));
		al.add(new person("xl","20"));
		
		
		ArrayList newAll=repeatList(al);
		//输出为5
		System.out.println(al.size());
		;//输出为4
		System.out.println(newAll.size())
		
	}

	private static ArrayList repeatList(ArrayList al) {
		ArrayList newAll=new ArrayList<>();
		for (Object object : al) {
			if (!newAll.contains(object)) {
				newAll.add(object);
			}
		}
		return newAll;
	}

}

class person{
	
	private String name;
	private String age;
	public person(String name, String age) {
		this.name = name;
		this.age = age;
	}
	public person() {
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age + "]";
	}
	
	//重写equals方法
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof person) {
			person p=(person) obj;
			System.out.println(this.getName() +"---equals---"+p.getName());

			return this.getName().equals(p.getName())
					&& this.getAge().equals(p.getAge());
		}
		return false;
	}

}

qq_45177371

关注

0
点赞
踩
1

收藏

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

1、集合框架（简介、Collection方法、迭代器）集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器数据结构集合框架的由来：数据多了用对象进行存储，对象多了用集合来进行存储。而存储数据的方式（数据结构）各有不同，所以存储的容器也就有多种，从而形成了集合框架这一体系。llCollection方法通过Collection的子类ArrayList来实现...
复制链接

扫一扫