java集合是非常重要的一块,是每个java程序员必须掌握的内容,不仅要会使用这些集合的方法,还要对它们底层的数据结构实现原理有一定的了解。
这里就简单归纳一下List集合中关键的几个点:
List集合,有索引,元素可以重复,有序(存取一致)
用LinkedList(底层由链表实现,增删快,查询修改慢)模拟栈(队列也可模拟)
import java.util.LinkedList;
public class Test {
/**
* 用LinkedList模拟栈结构
*/
public static void main(String[] args) {
Stack s = new Stack();
s.in("a"); //进栈
s.in("b");
s.in("c");
s.in("d");
while(!s.isEmpty()) { //判断栈结构是否为空
System.out.println(s.out()); //弹栈
}
}
}
class Stack {
private LinkedList list = new LinkedList();
/*
* 模拟进栈方法
*/
public void in(Object obj) {
list.addLast(obj);
}
/*
* 模拟出栈
*/
public Object out() {
return list.removeLast();//模拟队列时出队列应该是removeFirst(),其他的和栈的代码一样
}
/*
* 模拟栈结构是否为空
*/
public boolean isEmpty() {
return list.isEmpty();
}
}
输出:
d
c
b
a
ArrayList(底层数组实现,增删慢,查询修改快)
ArrayList嵌套循环遍历:
import java.util.ArrayList;
public class Test {
/**
* 集合嵌套之ArrayList嵌套ArrayList
*/
public static void main(String[] args) {
ArrayList<ArrayList<Person>> list = new ArrayList<>();
ArrayList<Person> first = new ArrayList<>();
first.add(new Person("a", 1));
first.add(new Person("b", 2));
first.add(new Person("c", 3));
ArrayList<Person> second = new ArrayList<>();
second.add(new Person("d", 4));
second.add(new Person("e", 5));
second.add(new Person("f", 6));
list.add(first);
list.add(second);
for(ArrayList<Person> a : list) {
for(Person p : a) {
System.out.println(p);
}
}
}
}
class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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 + "]";
}
/*@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}*/
}
输出:
Person [name=a, age=1]
Person [name=b, age=2]
Person [name=c, age=3]
Person [name=d, age=4]
Person [name=e, age=5]
Person [name=f, age=6]
ArrayList去除重复元素(重复属性值或者重复对象的成员变量值,注意不是对象的引用地址值):
import java.util.ArrayList;
import java.util.Iterator;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Test {
/**
需求:ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
注意事项
* 重写equals()方法的contains方法判断是否包含,底层依赖的是equals方法
* remove方法判断是否删除,底层依赖的是equals方法
*/
public static void main(String[] args) {
ArrayList list = new ArrayList(); //创建集合对象
list.add(new Person("张三", 23));
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));
list.add(new Person("李四", 24));
ArrayList newList = getSingle(list); //调用方法去除重复
System.out.println(newList);
}
/*
* 创建新集合将重复元素去掉
* 1,明确返回值类型,返回ArrayList
* 2,明确参数列表ArrayList
*
* 分析:
* 1,创建新集合
* 2,根据传入的集合(老集合)获取迭代器
* 3,遍历老集合
* 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
*/
public static ArrayList getSingle(ArrayList list) {
ArrayList newList = new ArrayList<>(); //1,创建新集合
Iterator it = list.iterator(); //2,根据传入的集合(老集合)获取迭代器
while(it.hasNext()) { //3,遍历老集合
Object obj = it.next(); //记录住每一个元素
if(!newList.contains(obj)) { //如果新集合中不包含老集合中的元素
newList.add(obj); //将该元素添加
}
}
return newList;
}
}
class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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 + "]";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
输出:
[Person [name=张三, age=23], Person [name=李四, age=24]]
List迭代过程中集合修改出现并发修改异常的解决办法:
import java.util.ArrayList;
import java.util.Iterator;
public class Test {
/**
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可,该变量就是元素
}
增强for循环底层依赖的是迭代器(Iterator)
*/
public static void main(String[] args) {
demo1();
demo2();
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
//1,普通for循环删除,索引要--
/*for(int i = 0; i < list.size(); i++) {
if("b".equals(list.get(i))) {
list.remove(i--); //通过索引删除元素
}
}*/
//2,迭代器删除
/*Iterator<String> it = list.iterator();
while(it.hasNext()) {
if("b".equals(it.next())) {
//list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it.remove();
}
}*/
for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
if("b".equals(it2.next())) {
//list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it2.remove();
}
}
//3,增强for循环,增强for循环不能删除或者修改等操作,只能遍历
/**for (String string : list) {
if("b".equals(string)) {
list.remove("b");
}
}
*/
System.out.println(list);
}
public static void demo2() {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
list.add(new Person("王五", 25));
list.add(new Person("赵六", 26));
for (Person person : list) {
System.out.println(person);
}
}
public static void demo1() {
int[] arr = {11,22,33,44,55};
for (int i : arr) {
System.out.println(i);
}
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (String string : list) {
System.out.println(string);
}
}
}
class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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 + "]";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
输出:
11
22
33
44
55
a
b
c
d
Person [name=张三, age=23]
Person [name=李四, age=24]
Person [name=王五, age=25]
Person [name=赵六, age=26]
[a, c, d]
List还有其他一些操作比如foreach遍历,静态导入(不推荐使用),可变参数(实际就是类似传入变长数组做函数参数),AsList(数组转集合,不能增加或减少元素,可以使用其他集合中的方法),toArray(集合转数组,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size;数组的长度大于size,分配的数组长度就和指定的长度一样;基本数据类型的数组转换成集合,会将整个数组当作一个对象转换;将数组转换成集合,数组必须是引用数据类型)比较简单,就先不说了,大家自己去查资料了解一下就可以了。