首页 > 编程语言 >java_day13_ArrayList、Vector、LinkedList、泛型

java_day13_ArrayList、Vector、LinkedList、泛型

时间：2024-10-16 19:43:11浏览次数：1  
标签：java LinkedList ArrayList list1 System add println public out

一、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); // 不行


    }
}

标签：java,LinkedList,ArrayList,list1,System,add,println,public,out
From： https://www.cnblogs.com/w-ll/p/18470778

相关文章

  • java 堆oom进程还在吗 在
    java堆oom进程还在吗我整理的一些关于【Java转架构设计】的项目学习资料+视频（附讲解～～）和大家一起分享、学习一下： https://d.51cto.com/bLN8S1实现"java堆OOM进程还在吗"的步骤1.理解问题在开始解决问题之前，首先需要理解"java堆OOM进程还在吗"这个问题的含义。Java中的OOM（Out......
  • 2024年 Java 面试八股文（20w字）
    第一章-Java基础篇1、你是怎样理解OOP面向对象   难度系数：⭐面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征：继承：继承是从已有类得到继承信息创建新类的过程封装：封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口多态性：多态性是指允......
  • Java最新版面试题（全网最全、高频）
    面向对象三大特性1、面向对象的特征有哪些方面面向对象的特征主要有以下几个方面：抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。封装:封装把一个对象的属性私有......
  • java 查看jvm使用哪个垃圾回收器 -XX:+PrintCommandLineFlags
    java查看jvm使用哪个垃圾回收器在Java中，你可以通过查看JVM启动参数来确定使用的垃圾收集器。你可以使用java命令的-XX:+PrintCommandLineFlags参数来打印出JVM的启动配置，包括选择的垃圾收集器。例如，你可以通过以下命令运行Java应用程序来查看使用的垃圾收集器：java-XX:+PrintC......
  • Java中网络编程的学习
    Java网络编程学习总结本章目标了解计算机网络基础知识了解OSI七层参考模型熟悉TCP/IP协议熟悉常见网络协议掌握socket套接字编程计算机网络什么是计算机网络计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来，实现资源共......
  • Java 初学 day12
    java12集合1、Collection到目前位置，我们学习过哪些可以存储元素的容器1、数组优点：不同的数组可以存储不同数据类型的元素缺点：长度不可变2、StringBuffer|StringBuilder优点：长度可以跟随元素的数量而改变缺点：里面的元素只有一种字符数据类型我们今后会......
  • Java基础之源
    目录JDK、JRE和JVM有何区别?Java的跨平台原理是什么?描述一下JVM加载class文件的原理机制?Java有什么核心优势让其成为世界上最流行的编程语言之一?编译和执行Java程序的命令是什么?JDK、JRE和JVM有何区别?JDK包含JRE，比JRE多了开发和调试的工具，比如把Java文件编译成class文......
  • 《深入理解Java异常处理：理论与实践》
    《深入理解Java异常处理：理论与实践》引言在Java编程中，异常处理是一个非常重要的概念。它帮助开发者构建健壮、可靠的程序。本文将详细介绍Java中的异常处理机制，包括异常类的层次结构、如何捕获和处理异常，以及在编程实践中的一些最佳实践。目录异常处理的基本概念Java异常类......
  • Javascript算法——二分查找
    1.数组1.1二分查找1.搜索索引开闭matters！！！[left,right]与[left,right)/***@param{number[]}nums*@param{number}target*@return{number}*/varsearch=function(nums,target){letleft=0;letright=nums.length-1;//[left,right]，相等时......
  • java基础（6）抽象类和接口
    目录​编辑1.前言2.正文2.1抽象类2.1.1抽象类的概念2.1.2抽象类的语法2.1.3抽象类的特点2.1.4抽象类的作用2.2接口2.2.1接口的概念2.2.2接口的用法2.2.3接口的特点2.2.4实现多个接口2.2.5接口间的继承 2.2.6抽象类和接口的区别3.小结1.前言哈喽大家好吖，......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99