ArrayList：
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
使用ArrayList存储字符串并遍历（如果字符串有重复的需要去除）
package com.shujia.wyh.day18;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo1 {
public static void main(String[] args) {
//创建集合对象
ArrayList list = new ArrayList();
//向集合中添加字符串元素
list.add("hello");
list.add("world");
list.add("java");
list.add("hadoop");
list.add("hive");
list.add("hello");
list.add("spark");
list.add("java");
list.add("world");
System.out.println("去重之前的集合为：" + list);
//创建一个新的集合保存去重后的元素
ArrayList list2 = new ArrayList();
//遍历旧的集合
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String s = (String) iterator.next();
//获取到元素之后，拿着这个元素去新集合中查找，如果找到说明重复，就不添加，反之添加到新集合中
if (!list2.contains(s)) {
list2.add(s);
}
}
System.out.println("去重后的集合为：" + list2);
}
}
使用ArrayList存储自定义对象并遍历（并去重）
contains方法底层调用的是equals方法，但是Student类中并没有重写equals方法所以调用的是Object类中的equals方法，而Object类中的equals方法比较的是地址值，学生对象都是new出来的地址值必然不一样，equals比较的结果永远是false，加上我们代码中的！,结果永远是为true，所以无论如何都会添加到新集合中，最终结果没有去重。
解决方法：元素类重写equals()方法 自动生成即可
package com.shujia.wyh.day18;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.shujia.wyh.day18;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo2 {
public static void main(String[] args) {
//创建集合对象
ArrayList list = new ArrayList();
//创建学生对象
Student s1 = new Student("小王", 18);
Student s2 = new Student("小明", 17);
Student s3 = new Student("小周", 19);
Student s4 = new Student("小张", 20);
Student s5 = new Student("小王", 18);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
System.out.println(list);
System.out.println("====================================");
//创建一个新的集合存储去重后的结果
ArrayList list2 = new ArrayList();
//遍历旧的集合
Iterator iterator = list.iterator();
while (iterator.hasNext()){
Student student = (Student) iterator.next();
if(!list2.contains(student)){
list2.add(student);
}
}
System.out.println(list2);
}
}
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
Vector特有的方法：
public void addElement(Object obj)
将元素添加到集合的末尾 效果上和add()一样
public Object elementAt(int index)
获取指定索引处的元素 get(int index)
public Enumeration elements()
返回此向量的组件的枚举。
package com.shujia.wyh.day18;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
//创建Vector集合对象
Vector vector = new Vector();
//向集合添加元素
vector.addElement("hello");
vector.addElement("java");
vector.add("world");
vector.addElement("java");
//public Object elementAt(int index)获取指定索引处的元素 get(int index)
Object o = vector.elementAt(0);
System.out.println(o);
System.out.println(vector.elementAt(1));
System.out.println(vector.elementAt(2));
System.out.println(vector.elementAt(3));
System.out.println(vector.get(3));
System.out.println("=============================================");
//public Enumeration elements() 返回此向量的元素的枚举。
//简单记忆 你就把这个对象看作成一个迭代器
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
Object o1 = elements.nextElement();
String s = (String) o1;
System.out.println(s);
}
}
}
LinkedList:
1、底层数据结构是双链表，查询慢，增删快
2、线程是不安全的，效率高
LinkedList特有的方法：
1、添加功能：
public void addFirst(Object e) 在集合的开头添加元素
addLast(Object e) 在结合末尾添加元素，等同于add()方法
2、获取功能：
public Object getFirst() 获取集合中的第一个元素
getLast() 获取集合中的最后一个元素
3、删除功能：
public Object removeFirst() 从集合中删除第一个元素并返回
public Object removeLast() 从集合中删除最后一个元素并返回
package com.shujia.wyh.day18;
import java.util.LinkedList;
public class LinkedListDemo1 {
public static void main(String[] args) {
//1、创建LinkedList集合对象
LinkedList linkedList = new LinkedList();
//2、向集合中添加元素
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("=======================================");
//public void addFirst(Object e) 在集合的开头添加元素
linkedList.addFirst("spark");
System.out.println(linkedList);
//addLast(Object e) 在结合末尾添加元素，等同于add()方法
linkedList.addLast("Flink");
System.out.println(linkedList);
//public Object getFirst() 获取集合中的第一个元素
Object first = linkedList.getFirst();
System.out.println(first);
System.out.println(linkedList);
//public Object getLast() 获取集合中的最后一个元素
Object last = linkedList.getLast();
System.out.println(last);
System.out.println(linkedList);
//public Object removeFirst() 从集合中删除第一个元素并返回
Object o = linkedList.removeFirst();
System.out.println(o);
System.out.println(linkedList);
//public Object removeLast() 从集合中删除最后一个元素并返回
Object o1 = linkedList.removeLast();
System.out.println(o1);
System.out.println(linkedList);
}
}
请用LinkedList模拟栈数据结构的集合，并测试
栈的特点：先进后出
题目真正的意思是，自己写一个集合类，底层是LinkedList,调用自己定义的方法实现栈数据结构。
package com.shujia.wyh.day18;
import java.util.LinkedList;
public class MyStack {
private LinkedList linkedList;
MyStack(){
linkedList = new LinkedList();
}
public void myAdd(Object obj){
linkedList.addFirst(obj);
}
public Object myGet(){
// return linkedList.getFirst();
return linkedList.removeFirst();
}
public boolean myIsEmpty(){
return linkedList.isEmpty();
}
}
package com.shujia.wyh.day18;
public class MyStackTest {
public static void main(String[] args) {
//创建自己定义的集合类
MyStack myStack = new MyStack();
//添加元素到集合
myStack.myAdd("hello");
myStack.myAdd("world");
myStack.myAdd("java");
myStack.myAdd("bigdata");
//应该在获取元素之前判断集合中还有没有元素
while (!myStack.myIsEmpty()){
Object o = myStack.myGet();
System.out.println(o);
}
}
}
85
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
