一.ArrayList集合
1. 需求:使用ArrayList存储字符串并遍历(如果字符串有重复的需要去除)
public class ArrayListDemo1 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("java");
arrayList.add("hive");
arrayList.add("hadoop");
arrayList.add("spark");
arrayList.add("mysql");
arrayList.add("hive");
arrayList.add("java");
arrayList.add("hive");
System.out.println("去重前的集合为:"+arrayList);
//创建一个新的集合存储去重后的集合
ArrayList arrayList1 = new ArrayList();
//用迭代器遍历旧的集合
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
String s=(String) next;
//获取到元素之后,拿着这个元素去新集合中查找,
//如果找到说明重复,就不添加,反之添加到新集合中
if (!arrayList1.contains(s)){
arrayList1.add(s);
}
}
System.out.println("去重后的集合为:"+arrayList1);}
}
2.使用ArrayList存储自定义对象并遍历(并去重)学生对象:姓名和年龄都一样的时候,表示是同一个人。
我们按照处理字符串重复的逻辑来处理自定义对象重复,发现结果并没有进行去重
为什么呢?
要想知道为什么,就得知道问题出现在了哪一行代码中。
经过简单地分析后发现,问题出现了在判断是否包含的那一行代码中
因为只有当if语句为true的时候,才会将元素添加到新集合中
说明我们这里判断,一直都是为true的,换句话contains这个方法并没有生效
要搞清楚为什么不会生效,就得搞清楚contains这个方法底层是怎么做的。contains方法底层调用的是equals方法,但是呢,Student类中并没有重写equals方法
所以调用的是Object类中的equals方法,而Object类中的equals方法比较的是地址值,学生对象都是new出来的
地址值必然不一样,equals比较的结果永远是false,加上我们代码中的!,结果永远是为true,所以无论如何都会添加到
新集合中,最终结果没有去重。解决方法:元素类重写equals()方法 自动生成即可
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
Student1 s1=new Student1("小敏",20);
Student1 s2=new Student1("龙",40);
Student1 s3=new Student1("虎",60);
Student1 s4=new Student1("蛇",100);
Student1 s5=new Student1("猪",56);
Student1 s6=new Student1("小敏",20);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
arrayList.add(s4);
arrayList.add(s5);
arrayList.add(s6);
System.out.println("去重前的集合:"+arrayList);
ArrayList arrayList1 = new ArrayList();
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
Student1 student1=(Student1) next;
if (!arrayList1.contains(student1)){
arrayList1.add(student1);
}
}
System.out.println("去重后的集合为:"+arrayList1);
}
}
学生类:重写equals方法
package com.shujia.wyh.day02.day18;
import java.util.Objects;
public class Student1 {
private String name;
private int age;
public Student1(String name, int age) {
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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student1 student1 = (Student1) o;
return age == student1.age && Objects.equals(name, student1.name);
}
}
结果:
去重前的集合:[Student1{name=‘小敏’, age=20}, Student1{name=‘龙’, age=40}, Student1{name=‘虎’, age=60}, Student1{name=‘蛇’, age=100}, Student1{name=‘小敏’, age=20}]
去重后的集合为:[Student1{name=‘小敏’, age=20}, Student1{name=‘龙’, age=40}, Student1{name=‘虎’, age=60}, Student1{name=‘蛇’, age=100}]
二. LinkedList集合
1.LinkedList的特点:
(1)、底层数据结构是双链表,查询慢,增删
(2)、线程是不安全的,效率高
2. LinkedList特有的方法:
1、添加功能:
public void addFirst(Object e) 在集合的开头添加元素
addLast(Object e) 在结合末尾添加元素,等同于add()方法
2、获取功能:
public Object getFirst() 获取集合中的第一个元素
getLast() 获取集合中的最后一个元素
3、删除功能:
public Object removeFirst() 从集合中删除第一个元素并返回
public Object removeLast() 从集合中删除最后一个元素并返回
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
linkedList.add("bigdata");
linkedList.add("hadoop");
linkedList.add("hive");
System.out.println(linkedList);
System.out.println("===============================");
//1、添加功能:public void addFirst(Object e) 在集合的
//开头添加元素
linkedList.addFirst("Hi");
System.out.println(linkedList);
//[Hi, hello, world, java, bigdata, hadoop, hive]
// 2. addLast(Object e) 在结合末尾添加元素,等同于add()方法
linkedList.addLast("spark");
System.out.println(linkedList);
//[Hi, hello, world, java, bigdata, hadoop, hive, spark]
//3、获取功能:public Object getFirst() 获取集合中的第一个元素
System.out.println(linkedList.getFirst());//Hi
//4.getLast() 获取集合中的最后一个元素
System.out.println(linkedList.getLast());//spark
// 5、删除功能:public Object removeFirst() 从集合中删除
//第一个元素并返回
System.out.println(linkedList.removeFirst());
//Hi 这是要删除的元素
System.out.println(linkedList);
//[hello, world, java, bigdata, hadoop, hive, spark]
//6.public Object removeLast() 从集合中删除最后一个元素并返回
System.out.println(linkedList.removeLast());//spark
System.out.println(linkedList);
//[hello, world, java, bigdata, hadoop, hive
}
}
结果:
三.Vector集合
1.Vector的特点:
底层数据结构是数组,查询快,增删慢
线程安全,效率低(虽然它是线程安全的,我们今后也不会去使用它,后面会说一个线程安全的类代替它)
2.Vector特有的方法:
1.public void addElement(Object obj)
将元素添加到集合的末尾 效果上和add()一样
2. public Object elementAt(int index)
获取指定索引处的元素 get(int index)
3. public Enumeration elements()
返回此向量的组件的枚举。
public class VectorDemo1 {
public static void main(String[] args) {
//创建vector对象
Vector vector = new Vector();
//1.public void addElement(Object obj)
//将元素添加到集合的末尾 效果上和add()一样
vector.addElement("java");
vector.addElement("hive");
vector.addElement("mysql");
vector.add("web");
// 2.public Object elementAt(int index)获取指定索引处的
//元素 get(int index)
System.out.println(vector.elementAt(2));//mysql
System.out.println(vector.get(2));//mysql
//3. public Enumeration elements()返回此向量的组件的枚举。
//简单记忆 你就把这个对象看作成一个迭代器
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o = elements.nextElement();
String s=(String)o;
System.out.println(s+"-------"+s.length());
}
}
}
结果:
四.例题
测试自己定义集合类,底层是LinkedList
分析: 题目真正的意思是,自己写一个集合类,底层是LinkedList,调用自己定义的方法实现栈数据结构
MyStackTest类:
/*
测试自己定义集合类,底层是LinkedList
*/
// 题目真正的意思是,自己写一个集合类,底层是LinkedList,调用自
//己定义的方法实现栈数据结构
public class MyStackTest {
public static void main(String[] args) {
MyStack myStack = new MyStack();
myStack.myAdd("java");
myStack.myAdd("hive");
myStack.myAdd("mysql");
myStack.myAdd("web");
// System.out.println(myStack.myGet());
// System.out.println(myStack.myGet());
// System.out.println(myStack.myGet());
// System.out.println(myStack.myGet());
// System.out.println(myStack.myGet());
//NoSuchElementException
//应该在获取元素之前判断集合中还有没有元素
while (!myStack.myIsempty()){
Object o = myStack.myGet();
System.out.println(o);
}
}
}
自己定义的MyStack类:
import java.util.LinkedList;
public class MyStack {
private LinkedList linkedList;
//linkedList作为底层需要有一个linkedList的成员变量
MyStack(){
linkedList = new LinkedList();
//将来调用方法时会会先执行构造方法,就已经创建了一个LinkedList
//的对象,就可以在方法中直接调用LinkedList的方法,因此下面自定
//义的方法就可以直接调用LinkedList的方法
// 需要new一个linkedList的对象将来才可以调用方法 注意这里需要
//用成员变量去接收
}
public void myAdd(Object obj){
linkedList.addFirst(obj);
}
public Object myGet(){
// return linkedList.getFirst();
//注意这里不能用getFirst()方法,否则运行结果就一直是第一个元素web,
//因此我们每得到一个元素就要把这个元素删除
//而removeFirst()方法就满意这个条件
return linkedList.removeFirst();
}
public boolean myIsempty(){
return linkedList.isEmpty();
}
}
结果:与输入顺序相反满足了栈的要求