目录
前言
一、List集合的特点
二、List集合的增删改查
如何剔除集合中的奇数
法一: for循环
法二:迭代器
法三:将奇数元素放入另一集合中
三、List集合的遍历方式
1、for循环
2、foreach
3、迭代器
四、LinkedList与ArrayList的对比
五 、堆栈与队列
1、堆栈
2、 队列
六、增长因子
七、ArrayList去除重复元素及其底层原理
总结
前言
上一次九歌分享了MySQL的安装,这一次九歌要分享的内容是集合框架中的List集合。
接下来由一张思维导图,来展示本篇文章的大纲
以下为正文
一、List集合的特点
1、有序:存取元素的顺序一致
2、可重复性
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
list.add("zs");
// 查询
System.out.println(list.get(1));
for (Object obj : list) {
System.out.println(obj);
}
}
运行结果如下:
由运行结果可以看出List的特点,可以重复,存取顺序一致
二、List集合的增删改查
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
list.add("zs");
// 查询
System.out.println("-----------查询单个---------------");
System.out.println(list.get(1));
System.out.println("-----------查询全部---------------");
for (Object obj : list) {
System.out.println(obj);
}
// 修改
list.set(1, "九歌");
System.out.println("-------------修改后-------------");
for (Object obj : list) {
System.out.println(obj);
}
// 删除
list.remove("zl");//根据值删除
System.out.println("------------删除后--------------");
for (Object obj : list) {
System.out.println(obj);
}
Object obj2 = list.remove(4);//根据下标删除;返回值是删除的元素
System.out.println("-----------打印删除值---------------");
System.out.println("删除值:"+obj2);
System.out.println("----------删除后----------------");
for (Object obj : list) {
System.out.println(obj);
}
}
运行结果如下:
接下来我们来看一个容易在面试中问到的试题:
如何剔除集合中的奇数
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
// ConcurrentModificationException:当前改变异常
// 在集合元素剔除不要再原集合遍历时操作
for (Integer i : list2) {
if(i % 2 ==1) {
list2.remove(i);
}
}
}
如果像上面的代码段中展示的操作,会有两个问题。
1、到底是根据下标删除还是根据值删除
2、在遍历的时候删除了,那么接下来的其他元素位置还和原来一致吗?
运行结果如下:
这里我们报了ConcurrentModificationException:当前改变异常
注意:在剔除集合元素时不要在原集合遍历时操作
那我们该怎么操作呢?
法一: for循环
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
for (int i=0;i
运行结果如下:
可以看到奇数元素已被剔除
法二:迭代器
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
Iterator it = list2.iterator();
while (it.hasNext()) {
if ((it.next() % 2) != 0) {
it.remove();
}
}
}
运行结果如下:
法三:将奇数元素放入另一集合中
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
ArrayList list3 = new ArrayList();
for (int i=0;i
运行结果如下:
三、List集合的遍历方式
1、for循环
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
运行结果如下:
2、foreach
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//增强for循环
for (Object obj : list) {
System.out.println(obj);
}
运行结果如下:
3、迭代器
有关迭代器的运行原理:
图画的不好不要介意。
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//迭代器
Iterator it = list.iterator();
System.out.println(it.hasNext());
System.out.println(it.next());
while(it.hasNext()) {
System.out.println(it.next());
}
运行结果如下:
四、LinkedList与ArrayList的对比
1、ArrayList集合底层是数组,而且是Object [] 类型;而LinkedList集合底层是链表。
2、ArrayList集合查询数据很快,但是增删数据很慢;LinkedList集合增删数据很快。但是查询数据很慢。
在修改与查找时ArrayList已可通过下标快速执行,所以修改和查找优于linkedlist链表结构。
在增加和删除时linkedlist只需要拆分前后两个运输,不会导致全局变化,所以增加和删除时优于Arraylist数组结构。
3、LinkedList比ArrayList开销更大,因为LinkedList的节点除了存储数据,还需要存储引用。
五 、堆栈与队列
1、堆栈
栈是一种 LIFO(Last-In-First-Out, 后进先出)的数据结构,也就是先进后出的理念
public class Demo3 {
public static void main(String[] args) {
System.out.println("=========================");
Duizhan duizhan = new Duizhan(new LinkedList<>());
duizhan.push("zs");
duizhan.push("ls");
duizhan.push("ww");
duizhan.push("zl");
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
}
}
class Duizhan{
private LinkedList ll;
public Duizhan(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.removeLast();
}
}
运行结果如下:
2、 队列
队列是一种FIFO(First-In-First-Out, 先进先出)。队列在列表的末端添加项,从列表的前端移除项
public class Demo3 {
public static void main(String[] args) {
Duilie duilie = new Duilie(new LinkedList<>());
duilie.push("zs");
duilie.push("ls");
duilie.push("ww");
duilie.push("zl");
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
}
}
class Duilie{
private LinkedList ll;
public Duilie(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.remove();
}
}
}
运行结果如下:
六、增长因子
List底层结构是数组结构 它是一个'可变数组',一旦超过默认数组长度,会自动扩容 增长因子为0.5
public class Demo4 {
public static void main(String[] args) throws Exception {
// String[] arr = new String[10];
// arr = new String[11];
// arr[11] = "zs";
// arr = new String[12];
// arr[12] = "zs";
ArrayList
运行结果如下:
由运行结果我们可以得知
增长因子 0.5,初始容量 10
当代码中出现了多次add操作,涉及到了list集合容量多次改变,这是十分耗性能的操作
那么我们怎样对List集合进行优化呢?
public class Demo4 {
public static void main(String[] args) throws Exception {
ArrayList list = new ArrayList<>(100);//定义初始长度
for (int i = 0; i < 200; i++) {
list.add(i);
getlen(list);
}
}
private static void getlen(ArrayList list) throws Exception {
Field f = list.getClass().getDeclaredField("elementData");
f.setAccessible(true);
Object[] elementData = (Object[]) f.get(list);
System.out.println("当前集合的元素个数:"+list.size()+";当前list集合的容量是:"+elementData.length);
}
}
运行结果如下:
-----------------------------------------------------------------------------------------------------------------------
由此可见设定初始容量后,扩容次数明显减少。
设定初始化容量,即可优化性能
七、ArrayList去除重复元素及其底层原理
List集合的特点之一就是可重复,但是有的时候我们不想出现重复的元素,怎么才能去重呢?
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
运行结果如下:
这时候会发现zs前面出现了一次,后面又出现了一次,去重失败,这是为什么?
因为每一次创建一个对象都是一个新的对象 ;为什么又是一个新的对象呢?明明属性都是一样的。
这是因为在java中的确进行了比较,但是比较的并不是字符串对象包含的内容,而是他们所在的内存地址的数值。
那我们该如何解决呢?
重写equals方法
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
结果如下:
重写完equals方法后会发现,已经可以去重了
总结
这次分享的内容是集合框架的List集合,希望对你能有帮助,下期预告集合框架Set。
我是九歌,一个喜欢编程的程序员。
如有错误还望指正,谢谢啦。
运行结果如下:
可以看到奇数元素已被剔除
法二:迭代器
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
Iterator it = list2.iterator();
while (it.hasNext()) {
if ((it.next() % 2) != 0) {
it.remove();
}
}
}
运行结果如下:
法三:将奇数元素放入另一集合中
public static void main(String[] args) {
// 1,4,6,9,11,13,22,12,14 剔除集合中的奇数
ArrayList list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(6);
list2.add(9);
list2.add(11);
list2.add(13);
list2.add(22);
list2.add(12);
list2.add(14);
ArrayList list3 = new ArrayList();
for (int i=0;i
运行结果如下:
三、List集合的遍历方式
1、for循环
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
运行结果如下:
2、foreach
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//增强for循环
for (Object obj : list) {
System.out.println(obj);
}
运行结果如下:
3、迭代器
有关迭代器的运行原理:
图画的不好不要介意。
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//迭代器
Iterator it = list.iterator();
System.out.println(it.hasNext());
System.out.println(it.next());
while(it.hasNext()) {
System.out.println(it.next());
}
运行结果如下:
四、LinkedList与ArrayList的对比
1、ArrayList集合底层是数组,而且是Object [] 类型;而LinkedList集合底层是链表。
2、ArrayList集合查询数据很快,但是增删数据很慢;LinkedList集合增删数据很快。但是查询数据很慢。
在修改与查找时ArrayList已可通过下标快速执行,所以修改和查找优于linkedlist链表结构。
在增加和删除时linkedlist只需要拆分前后两个运输,不会导致全局变化,所以增加和删除时优于Arraylist数组结构。
3、LinkedList比ArrayList开销更大,因为LinkedList的节点除了存储数据,还需要存储引用。
五 、堆栈与队列
1、堆栈
栈是一种 LIFO(Last-In-First-Out, 后进先出)的数据结构,也就是先进后出的理念
public class Demo3 {
public static void main(String[] args) {
System.out.println("=========================");
Duizhan duizhan = new Duizhan(new LinkedList<>());
duizhan.push("zs");
duizhan.push("ls");
duizhan.push("ww");
duizhan.push("zl");
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
}
}
class Duizhan{
private LinkedList ll;
public Duizhan(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.removeLast();
}
}
运行结果如下:
2、 队列
队列是一种FIFO(First-In-First-Out, 先进先出)。队列在列表的末端添加项,从列表的前端移除项
public class Demo3 {
public static void main(String[] args) {
Duilie duilie = new Duilie(new LinkedList<>());
duilie.push("zs");
duilie.push("ls");
duilie.push("ww");
duilie.push("zl");
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
}
}
class Duilie{
private LinkedList ll;
public Duilie(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.remove();
}
}
}
运行结果如下:
六、增长因子
List底层结构是数组结构 它是一个'可变数组',一旦超过默认数组长度,会自动扩容 增长因子为0.5
public class Demo4 {
public static void main(String[] args) throws Exception {
// String[] arr = new String[10];
// arr = new String[11];
// arr[11] = "zs";
// arr = new String[12];
// arr[12] = "zs";
ArrayList
运行结果如下:
由运行结果我们可以得知
增长因子 0.5,初始容量 10
当代码中出现了多次add操作,涉及到了list集合容量多次改变,这是十分耗性能的操作
那么我们怎样对List集合进行优化呢?
public class Demo4 {
public static void main(String[] args) throws Exception {
ArrayList list = new ArrayList<>(100);//定义初始长度
for (int i = 0; i < 200; i++) {
list.add(i);
getlen(list);
}
}
private static void getlen(ArrayList list) throws Exception {
Field f = list.getClass().getDeclaredField("elementData");
f.setAccessible(true);
Object[] elementData = (Object[]) f.get(list);
System.out.println("当前集合的元素个数:"+list.size()+";当前list集合的容量是:"+elementData.length);
}
}
运行结果如下:
-----------------------------------------------------------------------------------------------------------------------
由此可见设定初始容量后,扩容次数明显减少。
设定初始化容量,即可优化性能
七、ArrayList去除重复元素及其底层原理
List集合的特点之一就是可重复,但是有的时候我们不想出现重复的元素,怎么才能去重呢?
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
运行结果如下:
这时候会发现zs前面出现了一次,后面又出现了一次,去重失败,这是为什么?
因为每一次创建一个对象都是一个新的对象 ;为什么又是一个新的对象呢?明明属性都是一样的。
这是因为在java中的确进行了比较,但是比较的并不是字符串对象包含的内容,而是他们所在的内存地址的数值。
那我们该如何解决呢?
重写equals方法
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
结果如下:
重写完equals方法后会发现,已经可以去重了
总结
这次分享的内容是集合框架的List集合,希望对你能有帮助,下期预告集合框架Set。
我是九歌,一个喜欢编程的程序员。
如有错误还望指正,谢谢啦。
运行结果如下:
三、List集合的遍历方式
1、for循环
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
运行结果如下:
2、foreach
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//增强for循环
for (Object obj : list) {
System.out.println(obj);
}
运行结果如下:
3、迭代器
有关迭代器的运行原理:
图画的不好不要介意。
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//迭代器
Iterator it = list.iterator();
System.out.println(it.hasNext());
System.out.println(it.next());
while(it.hasNext()) {
System.out.println(it.next());
}
运行结果如下:
四、LinkedList与ArrayList的对比
1、ArrayList集合底层是数组,而且是Object [] 类型;而LinkedList集合底层是链表。
2、ArrayList集合查询数据很快,但是增删数据很慢;LinkedList集合增删数据很快。但是查询数据很慢。
在修改与查找时ArrayList已可通过下标快速执行,所以修改和查找优于linkedlist链表结构。
在增加和删除时linkedlist只需要拆分前后两个运输,不会导致全局变化,所以增加和删除时优于Arraylist数组结构。
3、LinkedList比ArrayList开销更大,因为LinkedList的节点除了存储数据,还需要存储引用。
五 、堆栈与队列
1、堆栈
栈是一种 LIFO(Last-In-First-Out, 后进先出)的数据结构,也就是先进后出的理念
栈是一种 LIFO(Last-In-First-Out, 后进先出)的数据结构,也就是先进后出的理念
public class Demo3 {
public static void main(String[] args) {
System.out.println("=========================");
Duizhan duizhan = new Duizhan(new LinkedList<>());
duizhan.push("zs");
duizhan.push("ls");
duizhan.push("ww");
duizhan.push("zl");
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
System.out.println(duizhan.pop());
}
}
class Duizhan{
private LinkedList ll;
public Duizhan(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.removeLast();
}
}
运行结果如下:
2、 队列
队列是一种FIFO(First-In-First-Out, 先进先出)。队列在列表的末端添加项,从列表的前端移除项
队列是一种FIFO(First-In-First-Out, 先进先出)。队列在列表的末端添加项,从列表的前端移除项
public class Demo3 {
public static void main(String[] args) {
Duilie duilie = new Duilie(new LinkedList<>());
duilie.push("zs");
duilie.push("ls");
duilie.push("ww");
duilie.push("zl");
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
System.out.println(duilie.pop());
}
}
class Duilie{
private LinkedList ll;
public Duilie(LinkedList ll) {
super();
this.ll = ll;
}
//存
public void push(Object obj) {
ll.add(obj);
}
//取
public Object pop() {
return ll.remove();
}
}
}
运行结果如下:
六、增长因子
List底层结构是数组结构 它是一个'可变数组',一旦超过默认数组长度,会自动扩容 增长因子为0.5
public class Demo4 {
public static void main(String[] args) throws Exception {
// String[] arr = new String[10];
// arr = new String[11];
// arr[11] = "zs";
// arr = new String[12];
// arr[12] = "zs";
ArrayList
运行结果如下:
由运行结果我们可以得知
增长因子 0.5,初始容量 10
当代码中出现了多次add操作,涉及到了list集合容量多次改变,这是十分耗性能的操作
那么我们怎样对List集合进行优化呢?
public class Demo4 {
public static void main(String[] args) throws Exception {
ArrayList list = new ArrayList<>(100);//定义初始长度
for (int i = 0; i < 200; i++) {
list.add(i);
getlen(list);
}
}
private static void getlen(ArrayList list) throws Exception {
Field f = list.getClass().getDeclaredField("elementData");
f.setAccessible(true);
Object[] elementData = (Object[]) f.get(list);
System.out.println("当前集合的元素个数:"+list.size()+";当前list集合的容量是:"+elementData.length);
}
}
运行结果如下:
-----------------------------------------------------------------------------------------------------------------------
由此可见设定初始容量后,扩容次数明显减少。
设定初始化容量,即可优化性能
七、ArrayList去除重复元素及其底层原理
List集合的特点之一就是可重复,但是有的时候我们不想出现重复的元素,怎么才能去重呢?
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
List集合的特点之一就是可重复,但是有的时候我们不想出现重复的元素,怎么才能去重呢?
运行结果如下:
这时候会发现zs前面出现了一次,后面又出现了一次,去重失败,这是为什么?
因为每一次创建一个对象都是一个新的对象 ;为什么又是一个新的对象呢?明明属性都是一样的。
这是因为在java中的确进行了比较,但是比较的并不是字符串对象包含的内容,而是他们所在的内存地址的数值。
那我们该如何解决呢?
重写equals方法
public class Demo5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 新增
list.add(new Person("zs", 11));
list.add(new Person("ls", 12));
list.add(new Person("ww", 13));
list.add(new Person("zl", 14));
list.add(new Person("zs", 11));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
for (Object obj : list) {
if(!list1.contains(obj)) {
list1.add(obj);
}
}
System.out.println(list1);
}
}
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;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
结果如下:
重写完equals方法后会发现,已经可以去重了
总结
这次分享的内容是集合框架的List集合,希望对你能有帮助,下期预告集合框架Set。
我是九歌,一个喜欢编程的程序员。
如有错误还望指正,谢谢啦。



