List集合框架
1、简介、Collection方法、迭代器
2、集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）
3、集合框架LinkedList
4、集合框架ArrayList中的重复元素去重及其底层原理
Collection集合框架的视图
1、简介、Collection方法、迭代器
集合框架的由来：数据多了用对象进行存储，对象多了用集合来进行存储。而存储数据的方式（数据结构）各有不同，所以存储的容器也就有多种，从而形成了集合框架这一体系。
Collection方法：
代码如下
package com.ljy.list;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 这个类是讲解collection接口中特别的方法 Iterator 迭代器
*
* 集合的remover方法与迭代器的remove方法有什么区别?
* 1.再迭代器或者foreach循环删除的时候容易出现什么常见的问题 it.next
* 2.在迭代器中执行collection.remove方法
*
* java.util.ConcurrentModificationException(两个对象同时操作一个元素) 本质上来说,这是一个并发问题
*
*/
public class CollectionDemo {
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循环的便利
// 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(num);
// }
// }
Iterator it = c.iterator();
while (it.hasNext()) {
// System.out.println(it.next());
int num = (int) it.next();
if (num % 2 == 0) {
//System.out.println(num);
//it.remove();
//c.remove(num);
}
}
}
}
结果如图示
2、集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）
Arraylist：
数组结构 增删慢，查询快 有连续下标 线程不同步 增长因子为1.5 10
Vector：
数组结构 增删改查都慢 有连续下标 线程同步 增长因子2 10
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
Linkedlist：
链表结构 增删快，查询慢 没有连续下标
package com.ljy.list;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
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());
// }
// c.iterator();
ListIterator it = c.listIterator();
while (it.hasNext()) {//向下取值
System.out.println(it.next());
}
System.out.println("-------");//分割线
//list是有下标的
while (it.hasPrevious()) {//向上取值
System.out.println(it.previous());
}
}
}
结果如图
增长因子论证
Arraylist如何进行性能调优？ 为什么list集合底层是数据结构，但是数据长度优势固定的，而list长度又可以变？
package com.ljy.list;
import java.lang.reflect.Field;
import java.util.ArrayList;
/**
* ArrayList与array的区别
* 1.list的长度可变,数组长度固定
* 2.list可以存放各类的元素对象,而数组一旦申明,只能存放对应的类型
*
* ArrayList如何进行性能调优? 为啥list集合底层是数据结构.但是数组长度又是固定的,而list长度又可变呢? 论证增长因子
*
*/
public class ListDemo2 {
public static void main(String[] args) {
ArrayList al = new ArrayList<>();
for (int i = 0; i <= 80; i++) {
al.add(i);
System.out.print(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 | 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();
}
}
}
结果如图
3、集合框架LinkedList
链表的数据结构
特有方法
addFirst();
addLast();
获取元素但是不删除元素,如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
获取元素的同时会删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
示意图
代码演示：
package com.ljy.list;
import java.util.Iterator;
import java.util.LinkedList;
/**
* 面试题:
* 通过linkedList集合来制作一个堆栈结构的容器
* 获取制作一个队列结构的容器
* @author Felling
*
*/
public class LinkedListDemo {
public static void main(String[] args) {
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 ob) {
ll.addLast(ob);
}
public Object pop() {
return ll.removeFirst();
}
public void bianli() {
Iterator it=ll.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
DuiLie的结果
DuiZhan的结果
4、集合框架ArrayList中的重复元素去重及其底层原理
判断list 集合中元素是否相同，依据的是元素的equals方法
思路
1、对人进行描述，将数据封装进对象
2、将对象放入容器
3、去重
引用数据类型被调用了equals方法验证
package com.ljy.list;
import java.util.ArrayList;
/**
* 对ArrayList中的元素去重复
* 1.元素是字符串
* 2.元素是自定义对象
*
* @author Felling
*
*/
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList al=new ArrayList();
// al.add("张三");
// al.add("李四");
// al.add("王五");
// al.add("李四");
// al.add("赵六");
al.add(new Person("张三",11));
al.add(new Person("李四",12));
al.add(new Person("王五",13));
al.add(new Person("李四",12));
al.add(new Person("赵六",14));
ArrayList newal=repeat(al);
System.out.println(newal.size());
}
/**
* ArrayList容器中有重复的元素
* 1.建立一个新的容器
* 2.将老的容器遍历，并取出其中的元素
* 3.如果说这个元素存在于新的容器中，就不再往新的容器里添加，
* 如果不存在，就加进去
*/
public static ArrayList repeat(ArrayList al) {
ArrayList newal=new ArrayList<>();
for (Object object : al) {
if(!newal.contains(object)) {
newal.add(object);
}
}
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+"--equals--"+this.name);
return p.name.equals(this.name) && p.age==this.age;
}
}
结果如图
扫一扫
2012
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
