集合框架
- Collection方法、迭代器
- ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证
- LinkedList、链表的数据结构
- ArrayList中的重复元素去重及其底层原理
Collection方法、迭代器
集合框架的由来:数据多了用对象进行存储,对象多了用集合来进行存储。
collection里所有的方法
代码片
下面展示一些 内联代码片
。
ackage com.lrc;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 讲解collection接口中的特别方法
* Iterator迭代器
*/
/*
* 集合的remove方法与迭代器的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(11);
c.add(22);
c.add(33);
c.add(44);
c.add(55);
// for (Object ob : c) {
// System.out.println(ob);
// }
//迭代器是集合所特有的遍历方式
//迭代器就相当于是娃娃机里的夹子
//迭代器通常都位于最顶端
//it.next()迭代器从最上面开始,取下一个
/*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);
}
}*/
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();
//c.remove(num);
}
}
}
}
代码效果展示图如下
ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证
可以看到这类的容器是有下标,可以按照下标去取、删除…等等的方式去操作容器的元素
- list集合相对于collection集合所特有的方法
- Iterator.remove()与Collection.remove()的区别
- Iterator与ListIterator的区别
代码片
下面展示一些 内联代码片
。
package com.lrc;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
* 讲解list中的特有的方法listIterator
*
*/
public class ListDemo {
public static void main(String[] args) {
List l=new ArrayList();
l.add(11);
l.add(22);
l.add(33);
l.add(44);
l.add(55);
// Iterator it=l.iterator();
// while(it.hasNext()) {
// System.out.println(it.next());
// }
ListIterator it=l.listIterator();
while(it.hasNext()) {//下一个
System.out.println(it.next());
}
//list是有下标的
//不能注释了上面的while,不然会取不到值,已经是在最上面了,
//还要取上一个,上面的while执行完之后,就在最下面了,这是向上取
while(it.hasPrevious()) {//上一个
System.out.println(it.previous());
}
}
}
代码效果展示图如下
增长因子论证
Arraylist如何进行性能调优? 为什么list集合底层是数据结构,但是数据长度优势固定的,而list长度又可以变?
代码片
下面展示一些 内联代码片
。
package com.lrc;
import java.lang.reflect.Field;
import java.util.ArrayList;
/**
* 增长因子论证
*
* 面试题: Arraylist和array的区别 1.list的长度可变,数组长度固定
* 2.list可以存放各类的元素对象,而数组一旦申明,只能存放对应的类型
*
* Arraylist如何进行性能调优? 为什么list集合底层是数据结构,但是数据长度优势固定的,而list长度又可以变?
* 可变的原因:一次次对底层的容器进行扩容
* 调优:给定初识容器大小
*/
public class ListDemoo {
public static void main(String[] args) {
ArrayList al=new ArrayList<>();
for (int i = 1; i <=80; i++) {
al.add(i);
System.out.println(i+"--");
getLength(al);
}
}
public static void getLength(ArrayList al) {
try {
Field f = al.getClass().getDeclaredField("elementData");
f.setAccessible(true);
Object ob = f.get(al);
Object[] elementData = (Object[]) ob;
System.out.println("当前al容器的底层数组的长度:"+elementData.length);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
代码效果展示图如下
LinkedList、链表的数据结构
特有方法
addFirst();
addLast();
代码片
下面展示一些 内联代码片
。
package com.lrc;
import java.util.Iterator;
import java.util.LinkedList;
/**
* 通过linkedList集合来制作一个堆栈结构的容器
* 堆栈结构特点:先进后出
* 或者制作一个队列结构的容器
* 队列结构特点:先进先出
*/
public class LinkedListDemo {
public static void main(String[] args) {
//DuiZhan dz=new DuiZhan();
DuiLie dz=new DuiLie();
dz.push("a");
dz.push("q");
dz.push("w");
dz.push("e");
dz.push("r");
dz.bianli();
}
}
//堆栈结构容器
class DuiZhan{
private LinkedList ll=new LinkedList<>();
/*
* 往堆栈结构的容器添加元素
*/
public void push(Object ob) {
ll.addFirst(ob);
}
// public Object pop() {
// return ll.getFirst();//一直都在,会一直是同一个,没有真的拿掉
// }
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());
}
}
}
代码效果展示图如下
public Object pop() {
return ll.getFirst();//一直都在,会一直是同一个,没有真的拿掉
}
堆栈结构的容器是先进后出,ll.getFirst();遍历出来的是最后一个,因为一直都是获取,而不是拿掉ll.removeFirst();,所以一直都是最后一个
代码效果展示图如下
public Object pop() {
return ll.removeFirst();
}
在遍历的时候是不允许进行元素的操作
ArrayList中的重复元素去重及其底层原理
判断list 集合中元素是否相同,依据的是元素的equals方法。
代码片
下面展示一些 内联代码片
。
package com.lrc;
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("huahua");
// al.add("yanyan");
// al.add("wanwan");
// al.add("yanyan");
// al.add("shishi");
al.add(new Person("huahua",11));
al.add(new Person("yanyan",12));
al.add(new Person("wanwan",13));
al.add(new Person("yanyan",12));
al.add(new Person("shishi",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;
}
}
代码效果展示图如下