java day13 LIst（ArrayList、LinkedList、Vector、Stack、泛型）

最新推荐文章于 2021-01-09 17:52:39 发布

wzyyj

最新推荐文章于 2021-01-09 17:52:39 发布

阅读量168

点赞数

分类专栏： java学习日记文章标签：数据结构 java 链表

本文链接：https://blog.csdn.net/qq_43642864/article/details/110495369

版权

java学习日记专栏收录该内容

33 篇文章 0 订阅

订阅专栏

1、集合的概念

对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
位置：java.util.*;

集合和数组区别：

数组长度固定，集合长度不固定。
数组可以存储基本类型和引用类型，集合只能存储引用类型。

2、Collection体系集合

在这里插入图片描述

方法	描述
boolean add(Object obj)	添加一个对象数据
boolean addAll(Collection c)	将一个集合中的所有对象添加到此集合中
void clear()	清空此集合中的所有对象
boolean contains(Object o)	检查此集合中是否包含o对象
boolean equals(Object o)	比较此集合是否与指定对象相等
boolean isEmpty()	判断此集合是否为空
boolean remove(Object o)	在此集合中移除o对象
int size()	返回此集合中的元素个数
Object[] toArray()	将此集合转换成数组

代码示例：

package Day13_set;


import java.util.ArrayList;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 10:54
 */
public class Demo03 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        //添加
        System.out.println("----------添加-----------");
        list.add(0,"hushu");
        list.add("2");
        list.add("华为");
        list.add("荣耀");
        list.add(0,"三星");

        print(list);

        System.out.println("----------修改-----------");
        list.set(1,"Apple");
        print(list);

        System.out.println("----------删除1-----------");
        list.remove(0);
        print(list);

        System.out.println("----------删除2-----------");
        list.add(1);
        list.remove(new Integer(1));
        System.out.println();
        list.remove("华为");
        print(list);

    }

     static void print(ArrayList list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

注：遍历同时不能使用集合删除方法，否则出现并发修改异常，可使用迭代器的删除方法。

3、LIst的实现类

3.1 List接口

特点：有序、有下标、元素可以重复。
继承Collection接口。

常用方法：

方法	描述
void add(int index, Object o)	在index位置插入对象o。
boolean addAll(int index, Collection c)	将一个集合中的元素添加到此集合中的index位置。
Object get(int index)	返回集合中指定位置的元素。
List subList(int fromIndex, int toIndex)	返回fromIndex和toIndex之间的集合元素。

代码示例：

package Day13_set;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * @author wzy
 * @version 1.0
 * @date 0001 2020-12-01 20:42
 */
public class Demo02 {
    public static void main(String[] args) {
        //先创建集合对象
        List list=new ArrayList();
        //1添加元素
        list.add("苹果");
        list.add("小米");
        list.add(1, "华为");
        list.add(1, "华为");
        list.add(2, "OPPO");
        list.add(2, "VIVO");
        list.add(2, "魅族");
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //2删除元素
        //list.remove("苹果");
//		list.remove(0);
//		System.out.println("删除之后:"+list.size());
//		System.out.println(list.toString());
        //3遍历
        //3.1使用for遍历
        System.out.println("-----3.1使用for遍历-----");
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i));
        }
        //3.2使用增强for
        System.out.println("-----3.2使用增强for-----");
        for (Object object : list) {
            System.out.println(object);
        }
        //3.3使用迭代器
        Iterator it=list.iterator();
        System.out.println("-----3.3使用迭代器-----");
        ArrayList<String> set1 = new ArrayList<>();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        //3.4使用列表迭代器 ,和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
        ListIterator lit=list.listIterator();
        System.out.println("------使用列表迭代器从前往后-------");

        while(lit.hasNext()) {
            System.out.println(lit.nextIndex()+":"+lit.next());
        }

        System.out.println("------使用列表迭代器后往前-------");
        while(lit.hasPrevious()) {
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }

        //4判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());

        //5获取位置
        System.out.println("华为的索引："+list.indexOf("华为"));
    }
}

3.2 List实现类

3.2.1 Arrylist

数组结构实现，查询快、增删慢。
JDK1.2版本、线程不安全。

代码示例：

package Day13_set;


import java.util.ArrayList;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 10:54
 */
public class Demo03 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        //添加
        System.out.println("----------添加-----------");
        list.add(0,"hushu");
        list.add("2");
        list.add("华为");
        list.add("荣耀");
        list.add(0,"三星");

        print(list);

        System.out.println("----------修改-----------");
        list.set(1,"Apple");
        print(list);

        System.out.println("----------删除1-----------");
        list.remove(0);
        print(list);

        System.out.println("----------删除2-----------");
        list.add(1);
        list.remove(new Integer(1));
        System.out.println();
        list.remove("华为");
        print(list);

    }

     static void print(ArrayList list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

3.2.2 LinkedList

链表结构实现，增删快，查询慢。
JDK1.2版本、线程不安全。

package Day13_set;


import java.util.ArrayList;
import java.util.LinkedList;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 10:54
 */
public class Demo04 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        //添加
        System.out.println("----------添加-----------");
        list.add(0,"hushu");
        list.add("2");
        list.add(2);
        list.add("华为");
        list.add("荣耀");
        list.add(0,"三星");

        print(list);

        System.out.println("----------修改-----------");
        list.set(1,"Apple");
        print(list);

        System.out.println("----------删除1-----------");
        list.remove(0);
        print(list);

        System.out.println("----------删除2-----------");
        list.add(1);
        list.remove(new Integer(1));
        list.remove("华为");
        print(list);

    }

    static void print(LinkedList list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

3.2.3 Vector

底层是数组，线程安全的集合

package Day13_set.list;

import java.util.Enumeration;
import java.util.Vector;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 14:46
 *      Vector:
 *          底层是数组，线程安全的集合
 */
public class Demo04 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        //list接口重写的方法
        vector.add("a");
        //Vector本身的方法
        vector.addElement("b");
        vector.addElement("c");
        vector.addElement("d");

        Enumeration elements = vector.elements();
        System.out.println(vector.toString());
        //判断是否还包含对象
        while (elements.hasMoreElements()){
            //获取下一个对象
            System.out.println(elements.nextElement());
        }
    }
}

3.2.4 Stack

模拟堆栈的集合，特点是后进先出(LIFO)，用完即删，线程安全的集合
链表结构实现，增删快，查询慢。

package Day13_set.list;

import java.util.Stack;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 14:50
 *
 *  Stack:
 *      模拟堆栈的集合，特点是后进先出(LIFO)，用完即删，线程安全的集合
 */
public class Demo05 {
    public static void main(String[] args) {
        Stack stack = new Stack();
        //添加
        stack.push(1);
        stack.push(2);
        stack.push("a");
        stack.push("b");
        System.out.println("statck长度："+stack.size());
        System.out.println(stack.toString());

        //empty()判断是否为null
        while (!stack.empty()){
            //pop()从集合的顶部获取对象并返回
            //作业：研究pop()的底层
            System.out.println(stack.pop());
        }
        System.out.println("statck长度："+stack.size());

    }
}

4、泛型

4.1 泛型概念

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

语法：**

<T,…> T称为类型占位符，表示一种引用类型。

优点：

提高代码的重用性。
防止类型转换异常，提高代码的安全性。

package Day13_set.list;

import Day13_set.entity.User;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 16:24
 */
public class Demo07 {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList();
        list.add(new User(1,"q"));
        list.add(new User(2,"w"));
        list.add(new User(3,"e"));
        list.add(new User(4,"r"));
//        list.add


        System.out.println("-------foreach-------");
        System.out.println(list.toString());
        for (User user:list) {
            System.out.println(user.toString());
        }

        System.out.println("-------迭代器-------");
        Iterator<User> it = list.iterator();

       while(it.hasNext()){
           User user = it.next();
           System.out.println(user);
//           System.out.println(it.next());
       }
    }
}

4.2 泛型集合

参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
编译时即可检查，而非运行时抛出异常。
访问时，不必类型转换（拆箱）。
不同泛型之间引用不能相互赋值，泛型不存在多态。

package Day13_set.list;

import Day13_set.entity.Animal;
import Day13_set.entity.Person;
import Day13_set.entity.User;

import java.util.ArrayList;
import java.util.List;

/**
 * @author wzy
 * @version 1.0
 * @date 0002 2020-12-02 16:29
 */
public class Demo08 {
    public static void main(String[] args) {
        System.out.println("-------1-----------");
        Person<String> person = new Person<>();
        person.add("1");
        System.out.println(person.toString());

        System.out.println("-------2-----------");
        User user = new User(1,"wzy");
        List<User> list = add(user);
        System.out.println(list.toString());

        System.out.println("-------3-----------");
        List<Person<String>> list2 = add(person);
        System.out.println(list2.toString());

        System.out.println("-------4-----------");
        Animal animal = new Animal();
        List<Animal> list3 = add(animal);
        System.out.println(list3.toString());

    }

    //在方法中使用泛型，则传递的参数为什么类型的对象，则返回的集合泛型则为参数的类型
    public static <T> List<T> add(T t){
        ArrayList<T> list = new ArrayList();
        list.add(t);
        return list;
    }
}