list集合应用
- 集合框架（简介、Collection方法、迭代器）接口：list、vector、lindenlist (list去重复）
集合框架list（arraylist特有方法，特有迭代器，具体对象特点，增长因子论证）
- 集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器数据结构。
- 集合框架的由来：数据多了用对象进行存储，对象多了用集合来进行存储。
- 存储数据的方式各有不同，所以存储的容器也就有多种，然后就有了集合框架
package com.lww.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
/**
* list所特有的方法listiterator
*
*
*
* */
public class ListDemo {
public static void main(String[] args) {
List c=new ArrayList();
c.add(22);
c.add(23);
c.add(26);
c.add(28);
c.add(55);
// Iterator it=c.iterator();
// 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());
}
}
}
package com.lww.Collection;
import java.lang.reflect.Field;
import java.util.ArrayList;
/**
* arraylist与array的区别（集合与数组的区别）
* 论证增长因子
* list的长度可变，数组长度固定
* list可存放各类元素对象，数组一旦申明，只能存放对应类型
* arraylist如何进行调优?
* 为啥list集合底层是数据结构，但是数组长度优势固定，list长度又可变呢？
*
* */
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);
}
}
/**
集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）
可以看到这类的容器是有下标，可以按照下标去取、删除...等等的方式去操作容器的元素
*
*/
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 | SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package com.lww.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import org.w3c.dom.ls.LSParserFilter;
/**
* 通过linkedlist集合来制作一个堆栈结构的容器或者制作一个队列结构的容器
*
* 往堆栈结构里添加元素
*
* */
public class LinkedListDemo {
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.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());
}
}
}
class DuiLie{
private LinkedList ll=new LinkedList<>();
public void push(Object obj) {
ll.addFirst(obj);
}
public void bianli() {
Iterator it=ll.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
package com.lww.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import org.w3c.dom.ls.LSParserFilter;
/**
* 通过linkedlist集合来制作一个堆栈结构的容器或者制作一个队列结构的容器
*
* 往堆栈结构里添加元素
*
* */
//获取元素但是不删除元素,如果集合中没有元素，会出现NoSuchElementException
//获取元素的同时会删除元素，如果集合中没有元素，会出现NoSuchElementException
//获取元素的同时会删除元素，如果集合中没有元素，会返回null
public class LinkedListDemo {
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.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());
}
}
}
class DuiLie{
private LinkedList ll=new LinkedList<>();
public void push(Object obj) {
ll.addFirst(obj);
}
public void bianli() {
Iterator it=ll.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
---------------------
package com.lww.Collection;
import java.util.ArrayList;
/**
* 对arraylist中的元素去重复
* 1.元素是字符串
* 2.元素是自定义对象
*
*
* 需求：
* 名字年龄相同就判定为是同一个人
*
* 集合collection的contains方法在调用的时候底层调用容器元素对象的equals方法
* 之前元素对象是string，现在是object（person）
*
* */
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList al=new ArrayList<>();
// al.add("ww");
// al.add("qq");
// al.add("tt");
// al.add("vk");
// al.add("ww");
al.add(new Person("ww", 17));
al.add(new Person("ac", 20));
al.add(new Person("vk", 21));
al.add(new Person("sw", 19));
al.add(new Person("ww", 17));
ArrayList newAl=repeat(al);
System.out.println(newAl.size());
}
/**
* 这个容器中是有重复元素的
* 1.建立一个新容器
* 2.遍历取出老容器中的元素
* 3.如果存在新容器中，就不再加入
* */
public static ArrayList repeat(ArrayList al) {
ArrayList newAl=new ArrayList<>();
for (Object obj : al) {
if(!newAl.contains(obj)) {
newAl.add(obj);
}
}
return newAl;
}
}
class Person{
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 "Person [name=" + name + ", age=" + age + "]";
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
}
@Override
public boolean equals(Object obj) {
Person p=(Person) obj;
// System.out.println(p.name+"---"+this.name);
// return super.equals(obj);
// return p.name.equals(this.name) && p.age==this.age;
}
}
// System.out.println(p.name+"---"+this.name);
// return super.equals(obj);这是用来元素之间的比较的
// return p.name.equals(this.name) && p.age==this.age;然后这一串是元素之间对比有无重复，有的话就去重复然后在返回对应的值
总结:
- 集合框架中特有的方法叫iterator(迭代器)
Collection.remove与iterator.remove的区别
- 在集合遍历过程中，如果调用collection.Remove方法的时候，会漏掉其中一部分元素.
- 需要明白iterator.next(()指的是指针下移
- 如果说在迭代器iterator中遍历的时候，用collection去操作容器中的元素会报concurrentmodifyexeception错误
- list集合
它常用的实现类之间的区别
Arraylist 数组结构 查询修改快，有连续下标 增加删除慢 线程不同步的 增长因子1.5倍
Vector 查询修改快，增加删除慢 有连续下标 线程同步的 增长因子2倍
Linkedlist 链表结构（它的每一个元素都会记住上一个或下一个元素的坐标） 增加删除快 查询修改慢 （没连续下标）
- 队列与堆栈的容器的结构特点，以及用linkedlist来制作一个过程
- List去重复问题
结论：list中的contains方法，底层是调用了对象的equals方法