java_day13_ArrayList、Vector、LinkedList、泛型
一、ArrayList
Collection[接口]:
List[接口]: 元素有序,可以发生重复,有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组,查询快,增删慢,线程不安全,效率高。
Set[接口]: 元素无序且唯一,没有索引
代码案例
public class ArrayListDemo1 {
public static void main(String[] args) {
//创建集合对象
ArrayList list1 = new ArrayList();
//创建元素对象
//将元素添加到集合中
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hadoop");
list1.add("hello");
list1.add("world");
//遍历集合
//1. 转数组遍历
Object[] objects = list1.toArray();
for(int i=0;i<objects.length;i++){
System.out.println(objects[i]);
}
System.out.println("========================");
//2. 使用迭代器的方式遍历
Iterator iterator = list1.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("========================");
//3. 使用size()和get(i) 只有List集合才拥有的遍历方式
for(int i=0;i<list1.size();i++){
System.out.println(list1.get(i));
}
}
}
ArrayList案例
去除集合中字符串的重复值(字符串的内容相同)
public class ArrayListTest1 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
//创建元素对象
//将元素添加到集合中
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hadoop");
list1.add("hello");
list1.add("world");
System.out.println("list1: " + list1);
System.out.println("-----------------------------");
//创建一个新的集合
ArrayList list2 = new ArrayList();
for (int i = 0; i < list1.size(); i++) {
String str = (String) list1.get(i);
if (!list2.contains(str)) {
list2.add(str);
}
}
System.out.println("list2: " + list2);
}
}
去除集合中自定义对象的重复值(对象的成员变量值都相同)
注:
去除集合中自定义对象的重复值(对象的成员变量值都相同)
我们按照实现去重字符串的逻辑去重自定义对象,发现自定义对象并没有去重
我们要去看contains的源码,底层判断元素是否存在新集合的逻辑是:
挨个使用待插入的元素与新集合中的元素使用equals方法比较,我们元素Student类中并没有重写equals方法
所以使用的是父类Object中的equals方法,而父类Object中的equals方法比较的是地址值
又因为每一个学生都是new出来的,所以地址值都不一样,比较的结果永远为false
要想比较内容值,需要元素类型重写equals方法,自动生成即可
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
Student s1 = new Student("李刚", 15);
Student s2 = new Student("钱志强", 16);
Student s3 = new Student("江川", 30);
Student s4 = new Student("李刚", 15);
Student s5 = new Student("祝帅", 15);
list1.add(s1);
list1.add(s2);
list1.add(s3);
list1.add(s4);
list1.add(s5);
System.out.println("list1: " + list1);
System.out.println("=================================");
ArrayList list2 = new ArrayList();
for(int i=0;i<list1.size();i++){
Student s = (Student) list1.get(i);
/*
//Student s1 = new Student("李刚", 15);
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
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;
}
*/
if(!list2.contains(s)){
list2.add(s);
}
}
System.out.println("list2: " + list2);
}
}
二、Vector
Collection[接口]:
List[接口]: 元素有序,可以发生重复,有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组,查询快,增删慢,线程不安全,效率高。
Vector[具体的子类]: 底层数据结构是数组,查询快,增删慢,先出安全,效率低。
即便Vector是线程安全的,我们以后也不会用它。
特殊的功能:
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
Set[接口]: 元素无序且唯一,没有索引
代码案例
public class VectorDemo1 {
public static void main(String[] args) {
//创建Vector集合对象
Vector v1 = new Vector();
//创建元素并添加元素
v1.add("hello");
v1.add("world");
v1.add("java");
v1.add("hadoop");
v1.add("hbase");
v1.add("java");
v1.add("hello");
System.out.println("v1: "+v1);
System.out.println("-------------------------------");
//public void addElement(Object obj) 向集合中添加元素
// v1.addElement("flink");
// System.out.println("v1: "+v1); // 效果和add方法一模一样,可以使用add方法替代
//public Object elementAt(int index) 根据索引获取元素
// System.out.println(v1.elementAt(2));// 效果和get方法一模一样,可以使用get方法替代
// System.out.println(v1.get(2));
//public Enumeration elements()
// Enumeration elements = v1.elements();// 效果和迭代器方法一模一样,可以使用迭代器方法替代
// while (elements.hasMoreElements()){
// System.out.println(elements.nextElement());
// }
}
}
三、LinkedList
Collection[接口]:
List[接口]: 元素有序,可以发生重复,有索引的概念
ArrayList[具体的子类]: 底层数据结构是数组,查询快,增删慢,线程不安全,效率高。
Vector[具体的子类]: 底层数据结构是数组,查询快,增删慢,先出安全,效率低。
即便Vector是线程安全的,我们以后也不会用它。
特殊的功能:
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
LinkedList[具体的子类]: 底层数据结构是双链表,增删快,查询慢,线程不安全,效率高
特殊功能:
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
Set[接口]: 元素无序且唯一,没有索引
代码案例
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList list1 = new LinkedList();
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("world");
list1.add("hadoop");
System.out.println("list1: "+list1);
System.out.println("=====================");
//public void addFirst(E e)及addLast(E e)
list1.addFirst("李刚");
list1.addLast("钱志强");
System.out.println("list1: "+list1);
System.out.println("----------------------");
//public Object getFirst()及getLast()
System.out.println(list1.getFirst());
System.out.println(list1.getLast());
System.out.println("list1: "+list1);
System.out.println("----------------------");
//public E removeFirst()及public E removeLast()
System.out.println(list1.removeFirst());
System.out.println(list1.removeLast());
System.out.println("list1: "+list1);
}
}
请用LinkedList模拟栈数据结构的集合,并测试
题目的本意是,自己写一个类,底层封装了LinkedList,创建这个类,把这个类当作集合类去用。
封装一个底层是LinkedList的类
public class MyStack {
private LinkedList linkedList;
MyStack(){
linkedList = new LinkedList();
}
public void addYuanSu(Object obj){
linkedList.addFirst(obj);
}
public Object getYuanSu(){
return linkedList.removeFirst();
}
public int getLength(){
return linkedList.size();
}
@Override
public String toString() {
return "MyStack{" +
"linkedList=" + linkedList +
'}';
}
}
public class LinkedListTest3 {
public static void main(String[] args) {
// LinkedList list1 = new LinkedList();
//
// list1.add("A");
// list1.add("B");
// list1.add("C");
// list1.add("D");
// list1.add("E");
// list1.add("F");
//
// for(int i=list1.size()-1;i>=0;i--){
// System.out.println(list1.get(i));
// }
MyStack myStack = new MyStack();
myStack.addYuanSu("A");
myStack.addYuanSu("B");
myStack.addYuanSu("C");
myStack.addYuanSu("D");
myStack.addYuanSu("E");
myStack.addYuanSu("F");
System.out.println("myStack: "+myStack);
System.out.println("========================");
int length = myStack.getLength();
for(int i=0;i<length;i++){
System.out.println(myStack.getYuanSu());
}
}
}
四、泛型
按照之前的写法,有几个问题
1. 程序中有大量的黄色警告
2. 在遍历的时候,迭代器不知道元素本身的类型,需要向下转型
使用泛型[参数化类型]改进集合的使用。
语法格式:<引用数据类型>
泛型是将来用于接收一个引用数据类型的,相当于一个参数
既然是参数,就需要符合标识符的命名规则
一般情况下,使用一个或多个大写字母表示
1、泛型类
public class Demo<W> {
public void fun1(W w) {
System.out.println("接收到的参数是:" + w);
}
}
class Test1{
public static void main(String[] args) {
// Demo demo = new Demo();
// demo.fun1("hello");
// demo.fun1(10);
// demo.fun1(12.34);
Demo<String> d1 = new Demo<>();
d1.fun1("hello");
// d1.fun1(10);
}
}
2、泛型方法
public class Demo1 {
//泛型方法
public <Q> void fun1(Q q) {
System.out.println("接收到的参数是:" + q);
}
//普通的方法
public void fun2(Object obj) {
System.out.println("接收到的参数是:" + obj);
}
}
class Test2{
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
demo1.fun1("hello");
demo1.fun1(100);
}
}
3、泛型接口
public interface Inter1<P> {
void show1(P p);
}
class Inter1Impl<P> implements Inter1<P> {
@Override
public void show1(P p) {
System.out.println("接收到参数值是:" + p);
}
}
class Test3{
public static void main(String[] args) {
Inter1Impl<String> stringInter1 = new Inter1Impl<>();
stringInter1.show1("hello");
// stringInter1.show1(123);
}
}
4、泛型通配符
<?>
任意类型,如果没有明确,那么就是Object以及任意的Java类了
? extends E
向下限定,E及其子类
? super E
向上限定,E及其父类
代码案例
定义三个类:Animal、Cat、Dog,Cat和Dog继承Animal
public class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
测试类
class Demo5{
public void show1(Collection<?> c1){ // 表示可以传入一个Collection集合,元素的类型是任意引用数据类型
System.out.println("任意类型泛型通配符");
}
// 表示可以传入一个Collection集合,元素的类型是Animal或Animal子类的类型
public void show2(Collection<? extends Animal> c1){
System.out.println("? extends Animal类型泛型通配符");
}
// 表示可以传入一个Collection集合,元素的类型是Dog或Dog父类的类型
public void show3(Collection<? super Dog> c1){
System.out.println("任意类型泛型通配符");
}
}
public class Demo4 {
public static void main(String[] args) {
Demo5 demo5 = new Demo5();
ArrayList<Object> list1 = new ArrayList<>();
ArrayList<Animal> list2 = new ArrayList<>();
ArrayList<Dog> list3 = new ArrayList<>();
ArrayList<Cat> list4 = new ArrayList<>();
// demo5.show1(list1);
// demo5.show1(list2);
// demo5.show1(list3);
// demo5.show1(list4);
// demo5.show2(list1); // 不行
// demo5.show2(list2);
// demo5.show2(list3);
// demo5.show2(list4);
// demo5.show3(list1);
// demo5.show3(list2);
// demo5.show3(list3);
// demo5.show3(list4); // 不行
}
}