List集合框架

最新推荐文章于 2022-04-15 22:16:09 发布

Sirm3998

最新推荐文章于 2022-04-15 22:16:09 发布

阅读量220

点赞数 1

文章标签： List集合框架

本文链接：https://blog.csdn.net/weixin_44222931/article/details/94659297

版权

集合框架（简介、Collection方法、迭代器）

在这里插入图片描述
http://tool.oschina.net/apidocs/apidoc?api=jdk-zh有兴趣的可以看看jdk源码。
集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器。
数据结构：数据多了用对象进行存储，对象多了用集合来进行存储。而存储数据的方式（数据结构）各有不同，所以存储的容器也就有多种，从而形成了集合框架这一体系。
把夹娃娃机比作集合；那么夹娃娃的钩子就可以看成集合中的迭代器；夹娃娃必须通过娃娃机内部的钩子；

而钩子的外挂、移动方式等等都不相同，所以只能定义一个规则，而这个规则就可以看成几何内部的一个迭代器接口Iterator；
有兴趣的可以看看jdk源码。Experience

迭代器 ▪Iterator iterator()
返回在此 collection 的元素上进行迭代的迭代器。关于元素返回的顺序没有任何保证（除非此 collection 是某个能提供保证顺序的类实例）。

1）迭代器

迭代器相当于看成一个娃娃器的容器，我们需要用夹子去夹娃娃
夹子可以比喻成一个类一个对象
夹子本身有行为有形状。容器里面描述出来一个内部类这就是迭代器
迭代器怎么去取里面的元素呢下面我们用代码来演示

下面展示一些 内联代码片。

//理解请看下面的示图;

/**
	 *
	 * 1、list集合相对于collection集合所特有的方法
	 * 2、Iterator.remove()与Collection.remove()的区别
	 * 3、Iterator与ListIterator的区别
	 *
	 * Collection
	 * List	有序	元素可以重复	因为该集合体系有索引
	 *      Arraylist 数组结构 增删慢，查询快 有连续下标    线程不同步   增长因子为1.5	10
	 *      vector    数组结构 增删改查都慢 有连续下标     线程同步    增长因子2		10
	 
		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方法来获取
	 */

我们来理解
下面展示一些 内联代码片。

/** 
 * 这个类是讲解collection接口中特别方法
 * Itertor迭代器
 * 
 * 集合的remove方法区别与迭代器的remove方法有什么区别？
 * 1.在迭代器或者foreach循环删除的时候容易出现什么常见的问题：it.next()
 * 2.在迭代器中执行collection.remove方法
 *     java.util.ConcurrentModificationException
 *     本质来说，这是一个并发问题
 * @author 96345
 *
 */

public static void main(String[] args) {
	Collection c=new ArrayList<>();
    c.add(22);
    c.add(23);
    c.add(26);
    c.add(28);
    c.add(55);
    //增加for循环i
//    for(Object obj : c) {
//    	System.out.println(obj);
//    }
    //迭代器是集合所特有的遍历方式
    Iterator it=c.iterator();
    while (it.hasNext()) {
//    	System.out.println(it.next());
    	//我想拿到集合中所有的偶数
		int num=(int) it.next();
		if (num % 2 == 0) {
			System.out.println(it.next());
//	        System.out.println(num);		
		}
	}
	}

下面是运算结果
在这里插入图片描述
这里的It.next指的是指针往下移,我们来看下图

从箭头1去除22迭代器就会把后面的元素往前移动

在这里插入图片描述
这时候如果我们要去除第五个空格的元素就会报角标越界异常

在这里插入图片描述

拿到集合中所以的偶数的话

Iterator it=c.iterator();
    while (it.hasNext()) {
//    	System.out.println(it.next());
    	//拿到集合中所有的偶数
		int num=(int) it.next();
		if (num % 2 == 0) {
//			System.out.println(it.next());
//	        System.out.println(num);		
			it.remove();
		}
	}
    System.out.println(c);
}

运算结果
在这里插入图片描述

如果两个人抢一个娃娃

Iterator it=c.iterator();
    while (it.hasNext()) {
//    	System.out.println(it.next());
    	//拿到集合中所有的偶数
		int num=(int) it.next();
		if (num % 2 == 0) {
//			System.out.println(it.next());
//	        System.out.println(num);		
			c.remove(num);
		}
	}
    System.out.println(c);
}

运算结果：

显而易见肯定会出现问题
在这里插入图片描述
显而易见肯定会出现问题

集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）

可以看到这类的容器是有下标，可以按照下标去取、删除…等等的方式去操作容器的元素

List c=new ArrayList();
    c.add(22);
    c.add(23);
    c.add(24);
    c.add(28);
    c.add(55);
    //这里调用的是子类的方法
    ListIterator it=c.listIterator();
    while (it.hasNext()) {
       System.out.println(it.next());

运算结果：
在这里插入图片描述
这里注意如果这样我们就是取不到元素

  ListIterator it=c.listIterator();
//    while (it.hasNext()) {
//       System.out.println(it.next());    	
//	}
    while (it.hasPrevious()) {
    	System.out.println(it.previous());
	}
    System.out.println("--------");

在这里插入图片描述
在这里面取的所有元素最初的指针在这里，它没有上一个。

只有当它挪到在最下面时，它一直往上走这是它取不到的根本

下面让我们来形容Arraylist是这样的

我们可以看出来LinkedList没有下标。元素与元素之间是有关系的，一环扣一环
在这里插入图片描述
就比如22和45是男孩子，25是女孩子。
你问女孩子它认识谁，它在22后面，所有说它肯定认识的是22.。
·查询修改

我要把25换成33，我用arraylist做告诉了我25的下标就很快能换了，而LinkedList你要一步步往找上就很慢
所有我们得出结论这种查询修改效率高

· 删除增加

在这里插入图片描述
假如有一万行一旦删除最后的元素，前面元素后移受影响的就是九千多行元素（增加同理）

这里我们用LinkerdList 在这里插入图片描述
删除其中一个元素只会影响两个元素

所有我们得出结论这种结构增加删除效率高

· 论证增长因子

/**
 * 区别
   * 面试题：
   * ArrayList与array的区别
   * 1.list的长度可变，数组长度固定
   * 2.list可以存放各类的元素对象，而数组一旦申明，只能存放对应的类型
   *  ArrayList如何进行性能调优？
   *     为啥list集合底层是数据结构，但是数组长度优势固定的，而list长度又可变呢？
   *     论证增长因子
 * @author 96345
 *
 */

public class listDemo2 {
 	  public static void main(String[] args) {
 		 ArrayList al=new ArrayList<>();
 		 for (int i = 1; i < 80; i++) {
 			 al.add(i);
 			 System.out.println(i+",");
 			 getLen(al);
		}
	  }
	  public static void getLen(ArrayList al) {
		  try {
		    Field f=	  al.getClass().getDeclaredField("elementData");
		    f.setAccessible(true);
		    Object obj=f.get(al);
		    Object [] elementData =(Object[]) obj;
		    System.out.println("当前al容器的底层数组的长度："+elementData.length);
		} catch (NoSuchFieldException e) {
          e.printStackTrace();
		}catch (IllegalAccessException e) {
	          e.printStackTrace();
	    }catch (IllegalArgumentException e) {
	          e.printStackTrace();
			}
		
		  
	  }
      }

运算结果

在这里插入图片描述
我们把它初始容器弄到50

这里可以看出来增长是1.5倍

Vetor被淘汰了这里就不过说了。
三. 集合框架Vector

三. 集合框架Vector

特有的遍历方法，拿一个举例

public class VectorDemo {
	public static void main(String[] args) {
		Vector v=new Vector<>();
		v.add(22);
		v.add(24);
		v.add(26);
		v.add(28);
		v.add(29);
		Enumeration el = v.elements();
		while(el.hasMoreElements()) {
			System.out.println(el.nextElement());
		}
	}
    }

四. 集合框架LinkedList

链表的数据结构
特有方法
addFirst();
addLast();

获取元素但是不删除元素,如果集合中没有元素，会出现
NoSuchElementException
getFirst();
getLast();

获取元素的同时会删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();

在jdk1.6出现了替代方法
offerFirst()
offerLast()

peekFirst();
peekLast();

获取元素的同时会删除元素，如果集合中没有元素，会返回null
pollFirst();
pollLast();

/**
 * 思考：
 * 1、先定义一个Listkedlist
 * 2、堆栈的存在特点，每一次都将元素放在容器的顶部
 * 堆栈的拿取特点，每一次都是取容器顶部的取出元素
 * @author admin
 */

堆栈
先进后出 First

public static void main(String[] args) {
      DuiZhan dz=new DuiZhan();   
      dz.push("a");
      dz.push("b");
      dz.push("c");
      dz.push("d");
      dz.push("e");
      dz.push("f");
      
      dz.bianli();
}
}

class DuiZhan{
	private LinkedList ll=new LinkedList<>();
	
	public void push(Object obj) {
		ll.addFirst(obj);
	}
	
	public Object pop() {
		return ll.removeFirst();
	}
	
	public void bianli() {
		Iterator it=ll.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
    }

队列
先进先出 Last

public static void main(String[] args) {
//    DuiZhan dz=new DuiZhan();
      Duilie dz=new Duilie();
      dz.push("a");
      dz.push("b");
      dz.push("c");
      dz.push("d");
      dz.push("e");
      dz.push("f");
      
      dz.bianli();
}
}
class Duilie{
private LinkedList ll=new LinkedList<>();
	
	public void push(Object obj) {
		ll.addLast(obj);
	}
	
	public Object pop() {
		return ll.removeFirst();
	}
	
	public void bianli() {
		Iterator it=ll.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
    }

在这里插入图片描述

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

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

判断list 集合中元素是否相同，依据的是元素的equals方法
Contains调用了equals
Remove调用了equals

字符串去重
list中存储的是字符串，而string的equals方法就是比的字符串值

思路：
1、对人进行描述，将数据封装进对象
2、将对象放入容器
3、去重

作者：linyaodonga
来源：CSDN
原文：https://blog.csdn.net/linyaodonga/article/details/94602783
版权声明：本文为博主原创文章，转载请附上博文链接！

public class ArrayListDemo {
 public static void main(String[] args) {
	ArrayList al=new ArrayList<>();
//	al.add("a");
//	al.add("b");
//	al.add("c");
//	al.add("d");
//	al.add("a");
	al.add(new preson("张三", 18));
	al.add(new preson("李四", 19));
	al.add(new preson("王五", 20));
	al.add(new preson("小红", 22));
	al.add(new preson("张三", 12));
	
    ArrayList newal=repeat(al);
    System.out.println(newal.size());
    System.out.println(al.size());
}
 
 public static ArrayList repeat(ArrayList al) {
	 ArrayList newal=new ArrayList<>();
	 for (Object obj : al) {
		if(!newal.contains(obj)) {
			newal.add(obj);
		}
	}
	 return newal;
 }
}
class preson{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "preson [name=" + name + ", age=" + age + "]";
	}
	public preson(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public preson() {
		super();
	}
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof preson) {
		preson p=(preson) obj;
		System.out.println(p.name+"---equals---"+this.name);
		return this.getName().equals(p.getName())&& this.getAge()==p.getAge();
	}
	return false;
}
}

Sirm3998

关注

1
点赞
踩
6

收藏

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

集合框架（简介、Collection方法、迭代器）http://tool.oschina.net/apidocs/apidoc?api=jdk-zh有兴趣的可以看看jdk源码。集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器。数据结构：数据多了用对象进行存储，对象多了用集合来进行存储。而存储数据的方式（数据结构）各有不同，所以存储的容器也就有多种，从而形成了集合框架...
复制链接

扫一扫