目录
ArrayList类概述及使用
ArrayList类概述
a.底层数据结构是数组,查询快,增删慢
b.线程不安全,效率高
ArrayList案例
1.例:使用ArrayList存储字符串并遍历,并且去重。(不会遍历看 List接口 或者 Collection接口 )
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest1 {
public static void main(String[] args) {
//创建集合对象
ArrayList list1 = new ArrayList ();
//添加元素
list1.add("java");
list1.add("hive");
list1.add("hadoop");
list1.add("spark");
list1.add("java");
list1.add("world");
list1.add("hadoop");
//创建新集合去保存去重的元素
ArrayList list2=new ArrayList ();
//获取迭代器对象遍历
Iterator iterator = list1.iterator();
while (iterator.hasNext()){
//向下转型,获取元素
String s=(String) iterator.next(); //这里直接合并,也可先获取每个元素 Object o =iterator.next(); 再转型
//判断是否重复,list2不包含的元素添加到新集合
if (!list2.contains(s)){
list2.add(s);
}
}
System.out.println(list1);
System.out.println(list2);
}
}
2.使用ArrayList存储自定义对象遍历并去重(学生类)
首先创建公共的学生类 (不会的看 面向对象封装)
public class Student {
private String name;
private int age;
public Student() {} //无参勾造方法
public Student(String name, int age) { //有参构造方法
this.name = name;
this.age = age;
}
//get()方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
//set()方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
//toString重写
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
然后创建集合去重遍历
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest2 {
public static void main(String[] args) {
//创建集合对象
ArrayList list1=new ArrayList ();
//创建学生对象
Student s1 = new Student("java",20);
Student s2 = new Student("hive",22);
Student s3 = new Student("wr2324",24);
Student s4 = new Student("we",25);
Student s5 = new Student("java",20);
Student s6 = new Student("we",22);
//添加元素
list1.add(s1);
list1.add(s2);
list1.add(s4);list1.add(s3);
list1.add(s5);
list1.add(s6);
//创建新的集合存储去重的元素
ArrayList list2 = new ArrayList ();
//获取迭代器对象遍历
Iterator iterator = list1.iterator();
while (iterator.hasNext()){
//向下转型
Student s=(Student) iterator.next();
//判断是否包含元素去重
if (!list2.contains(s)){
list2.add(s);
}
}
System.out.println(list1);
System.out.println(list2);
}
}
但是这样,我们发现结果并没有去重,输出集合跟原来的集合一样。
因为contains底层调用的是equals方法,但是我们创建的Student类中没有重写equals方法,所以调用的是Object类中的equals方法,Object类中的equals方法比较的是地址值,每个学生对象的地址值都不一样,所以(!list2.contains(s))永远是true,所以所有的元素都添加到了新集合中。
contains方法原码(仅了解就行):
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
所以解决方案就是去公共类(学生类)中重写equals方法。(快捷键Alt+Insert 选equals)
@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);
}
Vector类概述及使用
Vector类概述
a.底层数据结构是数组,查询快,增删慢
b.线程安全,效率低
Vector类特有功能
public void addElement(E obj) 将元素添加到集合的末尾,效果跟add()一样
//public void addElement(E obj) 将元素添加到集合的末尾
vector.addElement("java");
vector.add("java");
vector.addElement("hive");
System.out.println(vector);
public E elementAt(int index) 获取指定索引处的元素 get( int index)
//public E elementAt(int index) 获取指定索引处的元素
System.out.println(vector);//原集合
System.out.println(vector.elementAt(0));
System.out.println(vector.get(1));
System.out.println(vector.elementAt(2));
可以看出vector特有的获取和添加方法和add()和get()效果一样,相对还麻烦一点,不如就用add和get方法
public Enumeration elements() 返回此向量的元素的枚举 (你可以把它看作迭代器,因为方法相似)
//public Enumeration elements() 返回此向量的元素的枚举
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
//向下转型
String s=(String) elements.nextElement();
System.out.println(s+" 长度:"+s.length());
}
从这可以看出vector 类除了线程安全,没有什么特点,后面会有一个线程安全的类代替它。
LinkedList类概述及使用
LinkedList类概述
a.底层数据结构是链表,查询慢,增删快
b.线程不安全,效率高
LinkedList类特有功能
1.添加功能
public void addFirst(E e) 在元素的开头添加元素
public void addLast(E e) 在集合末尾添加元素,等同add()方法
//创建LinkedList 集合对象
LinkedList linkedList = new LinkedList ();
//向集合添加元素
linkedList.add("java");
linkedList.add("hive");
linkedList.add("bigdata");
linkedList.add("Collection");
System.out.println(linkedList);
//public void addFirst(E e) 在元素的开头添加元素
linkedList.addFirst("hadoop");
System.out.println(linkedList);
//addLast(E e) 在集合末尾添加元素,等同add()方法
linkedList.addLast("Flink");
System.out.println(linkedList);
2.获取功能
public E getFirst() 获取集合中的第一个元素
public E getLast() 获取集合中的最后一个元素
System.out.println(linkedList);//原集合
//public E getFirst() 获取集合中的第一个元素
Object first = linkedList.getFirst();
System.out.println(first);
//public E getLast() 获取集合中的最后一个元素
Object last = linkedList.getLast();
System.out.println(last);
System.out.println(linkedList);//获取不改变集合
3.修改功能
public E removeFirst() 从集合中删除第一个元素并返回
public E removeLast() 从集合中删除最后一个元素并返回
System.out.println(linkedList);//原集合
//public E removeFirst() 从集合中删除第一个元素并返回
Object o1 = linkedList.removeFirst();
System.out.println(o1);
System.out.println(linkedList);
//public E removeLast() 从集合中删除最后一个元素并返回
Object o2 = linkedList.removeLast();
System.out.println(o2);
System.out.println(linkedList);
LinkedList练习
例:用LinkedList模拟栈数据结构的集合,并测试(栈:先进后出)
思路:自己创建一个集合类,底层是LinkedList,调用自己的方法实现栈数据结构
首先自己创建集合类
import java.util.LinkedList;
public class Stack {
private LinkedList linkedList;
public Stack() {
linkedList = new LinkedList(); //创建集合对象
}
public void myAdd(Object object){ //创建自己的添加方法
linkedList.addFirst(object); //用linkedList.First()方法能保证后面添加的元素在第一个
}
public Object myGet(){ //创建自己的获取方法
return linkedList.removeFirst(); //linkedList.removeFirst()方法一直获取返回的第一个元素并删除,这样就不会得到已经获取的元素
}
public boolean myIsEmpty(){ //创建判断集合是否为空的方法,因为自己的类没有办法去直接判断
return linkedList.isEmpty(); //集合为空返回true
}
}
然后测试自己创建的类,调用自己创建的方法实现
public class LinkedListTest2 {
public static void main(String[] args) {
//创建自己创建的集合类的对象
Stack stack=new Stack();
//调用添加方法
stack.myAdd("java");
stack.myAdd("hive");
stack.myAdd("hadoop");
stack.myAdd("flink");
//判断是否为空,否则自己创的myGet方法输出一个元素删除一个,元素删光了再输出会报错
while(!stack.myIsEmpty()){
Object o = stack.myGet(); //获取每一个元素
System.out.println(o);
}
}
}
这样就实现了栈的先进后出。
下次说泛型,为了简化我都省略了。