ArrayList类
import java.util.Objects;
/*
ArrayList类概述
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
*/
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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}'+"\n";
}
@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);
}
}
/*
使用ArrayList存储自定义对象并遍历
*/
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo1 {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList arrayList = new ArrayList();
//创建5个学生对象
Student s1 = new Student("范闲", 23);
Student s2 = new Student("范思辙", 22);
Student s3 = new Student("鸡腿菇凉", 20);
Student s4 = new Student("范若若", 21);
Student s5 = new Student("庆帝", 50);
//将学生对象添加到集合中
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
arrayList.add(s4);
arrayList.add(s5);
//遍历的第一种方式1:迭代器遍历
//获取迭代器对象
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("============================================");
//遍历的第一种方式2:get()和size()方法结合
for (int i = 0; i < arrayList.size(); i++) {
Student student = (Student) arrayList.get(i);
System.out.println(student.getName() + "---" + student.getAge());
}
}
}
Vector类
import java.util.Enumeration;
import java.util.Vector;
/*
Vector:
底层数据结构是数组,查询快,增删慢
线程安全的(被同步关键字synchronized修饰),
效率低(虽然是线程安全的,以后我们也不使用它,后面会说一个线程安全的类替代它)
Vector特有的方法:
public void addElement(Object obj)
将元素添加到集合的末尾---效果和add()一样
public Object elementAt(int index)
返回指定索引处的组件-----效果和get(int index)
public Enumeration elements()
返回此向量的组件的枚举--效果与迭代器一样
*/
public class VectorDemo1 {
public static void main(String[] args) {
//创建Vector集合对象
Vector vector = new Vector();
//向集合中添加元素
vector.addElement("hello");
//效果和add()一样
vector.add("world");
vector.addElement("java");
//public Object elementAt(int index)
Object o = vector.elementAt(0);
System.out.println(o);
System.out.println(vector.elementAt(1));
System.out.println(vector.elementAt(2));
//报错:下标越界异常3(下标索引)>=3(元素个数)
//System.out.println(vector.elementAt(3));
//效果和get(int index)
//System.out.println(vector.get(0));
//public Enumeration elements()
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o1 = elements.nextElement();
System.out.println(o1);
}
System.out.println("=====================================");
System.out.println(vector);
}
}
LinkedList类
import java.util.LinkedList;
/*
LinkedList:
底层数据结构为双链表,查询慢,增删快
线程不安全的,效率高
LinkedList特有的功能:
1、添加功能:
void addFirst(Object obj) 在该列表开头插入指定的元素。
void addLast(Object obj) 将指定的元素追加到此列表的末尾。等同于add()方法
2、获取功能:
Object getFirst() 返回此列表中的第一个元素。
Object getLast() 返回此列表中的最后一个元素。
3、删除功能:
Object removeFirst() 从此列表中删除并返回第一个元素。
Object removeLast() 从此列表中删除并返回最后一个元素。
*/
public class LinkedListDemo1 {
public static void main(String[] args) {
//创建LinkedList集合对象
LinkedList linkedList = new LinkedList();
//添加元素到集合中
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
linkedList.add("hadoop");
linkedList.add("hive");
linkedList.add("spark");
System.out.println(linkedList);
System.out.println("=======================================");
//void addFirst(Object obj) 在该列表开头插入指定的元素。
linkedList.addFirst("flink");
System.out.println(linkedList);
//void addLast(Object obj) 将指定的元素追加到此列表的末尾。
linkedList.addLast("Hbase");
System.out.println(linkedList);
//Object getFirst() 返回此列表中的第一个元素。
Object first = linkedList.getFirst();
System.out.println(first);
System.out.println(linkedList);
//Object getLast() 返回此列表中的最后一个元素。
Object last = linkedList.getLast();
System.out.println(last);
System.out.println(linkedList);
//Object removeFirst() 从此列表中删除并返回第一个元素。
Object o = linkedList.removeFirst();
System.out.println(o);
System.out.println(linkedList);
//Object removeLast() 从此列表中删除并返回最后一个元素。
Object o1 = linkedList.removeLast();
System.out.println(o1);
System.out.println(linkedList);
}
}
List集合练习
import java.util.ArrayList;
import java.util.Iterator;
/*
去除集合中字符串的重复值(字符串的内容相同)
方式:创建一个新的集合
*/
public class ArrayListTest1 {
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");
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);
}
}
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Iterator;
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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}'+"\n";
}
//之后加的
@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);
}
}
/*
去除集合中自定义对象的重复值(对象的成员变量值都相同,姓名和年龄相同)
我们按照处理字符串的形式处理重复的自定义对象,发现结果并没有去重
为什么呢?
要想知道为什么,就得知道问题处在了哪一行代码
经过简单的分析后,我们发现问题出现了在判断的时候出现了。
因为只有当if里面是true的时候,才添加到新集合中,
说明我们的代码一直都是true,换句话说,contains()方法并没有生效
怎么改呢?要想知道怎么改,看一看contains内部是怎么实现的。
底层调用的是元素的equals方法,又因为我们Student类没有重写equals方法
调用的是父类Object类中的equals方法,比较的是地址值,所以contains()方法
结果永远是false,就相当于if(!false){.....}--if语句永远是true。所以
产生了没有去重的效果。
解决办法:元素类重写equals()方法
*/
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
Student s1 = new Student("朱佳乐", 18);
Student s2 = new Student("吕常福", 19);
Student s3 = new Student("陶华根", 20);
Student s4 = new Student("朱佳乐", 18);
Student s5 = new Student("朱佳乐", 19);
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 s = (Student) iterator.next();
//if()方法判断:如果新集合中不包含旧集合中的元素就进入循环
if(!list2.contains(s)){
//观察源码发现contains()方法底层调用的==和equals()方法
//由于原先我们并没有在Student类中重写equals()方法,所以比较的是地址值
//观察源码后,我们发现contains()方法返回结果是一直是false,所以加上一个 !就变成true。
//所以进入if()语句体
list2.add(s);
}
}
System.out.println(list2);
}
}
//-----------contains()方法源码-------------------
public boolean contains(Object o) {
return indexOf(o) >= 0;//-1不大于0,所以contains()方法结果永远是false。
}
//The size of the ArrayList (the number of elements it contains).
private int size;
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData;
public int indexOf(Object o) {
if (o == null) {//--o的地址值肯定不是null
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
//o为旧集合中的元素(Student),而调用方法的是新集合
if (o.equals(elementData[i]))
return i;
}
return -1;//--返回的是-1
}
import java.util.Iterator;
import java.util.LinkedList;
/*
请用LinkedList模拟栈数据结构的集合,并测试
栈的特点:
先进后出
题目的真正意思是,自己写一个类,底层是LinkedList,调用自己写的方法实现栈数据结构
*/
public class LinkedListTest1 {
public static void main(String[] args) {
//创建集合
LinkedList linkedList = new LinkedList();
// linkedList.add("hello");
// linkedList.add("world");
// linkedList.add("java");
linkedList.addFirst("hello");
linkedList.addFirst("world");
linkedList.addFirst("java");
linkedList.addFirst("hadoop");
System.out.println(linkedList);
//遍历
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
//如果面试的时候,你按照上面的写法 0分
}
}
//--------------------正确答案-----------------------------
import java.util.LinkedList;
public class MyStack {
private LinkedList linkedList;
MyStack(){
linkedList = new LinkedList();
}
public void myAdd(Object object){
linkedList.addFirst(object);
}
public Object myGet(){
//如果用getFirst()方法获取的都是第一个元素
// return linkedList.getFirst();
return linkedList.removeFirst();
}
public boolean myIsEmpty(){
return linkedList.isEmpty();
}
}
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");
// 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();
String s = (String) o;
System.out.println(s);
}
}
}