• Java学习--day16（集合）

    文章目录

    今天内容

    1.Collection

    2.List

    3.ArrayList和LinkedList区别

    4.Object类

    1.Collection

    Collection是一个接口，不能被实例化。但是Java封装了实现类。咱们可以借助于多态De形式来实例化出来父类引用【重点】

    Collection接口下面的方法，子类或者子接口能不能使用?可以的
增:
	boolean add(E e);添加一个数据到集合中
 boolean addAll(Collection c); 将一个集合数据添加到另外一个集合中
    Collection:元素 是E本类或者继承的E，才能添加到另外一个集合中
删:
	boolean remove(Object obj);删除指定的元素
 boolean removeAll(Collection c);  删除的是交集
     [a,b,c]  [b, c, d]
 void clear();清空的
查:
	int size();  查看集合中元素的个数 
 Object[] toArray(); 将集合转为Object类型数组
	boolean contains(Object obj); 集合中是否包含这个元素 如果包含返回true 
 boolean containsAll(Collection c);一个集合是否另外一个集合子集合
 boolean isEmpty();   判断集合是否为空

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    package com.qfedu.a_collection;

// 集合中的方法

import java.util.ArrayList;
import java.util.Collection;

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("马保国");
        list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println(list);
        Collection<String> str1 = new ArrayList<>();
        str1.add("a");
        str1.add("b");
        str1.add("c");
        System.out.println(str1);

        list.addAll(str1);
        System.out.println(list);
        System.out.println(list.contains("马保国"));

    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    咱们现在已经往集合里面存数据了，接下来要取数据。

    2.遍历集合中的数据

    3种：
	1.使用for循环
	2.增强for循环
	3.迭代器

    • 1
    • 2
    • 3
    • 4
    2.1for循环遍历
    package com.qfedu.a_collection;

import java.util.ArrayList;
import java.util.Collection;

// 遍历集合中的元素
public class Demo2 {
    public static void main(String[] args) {
        Collection<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);  // 打印出的是一个集合
        Object[] objects = list.toArray();  // 转成数组用objects接收
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }



    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    2.2增强for循环【重点】

    语法格式:

    for (集合中元素的数据类型 临时变量 ： 集合或者数组) {
	sout（临时变量）
}

    • 1
    • 2
    • 3

    有快捷键 : iter

    package com.qfedu.a_collection;

/*
增强for循环：
for (集合中元素的数据类型 临时变量 ： 集合或者数组) {
	sout（临时变量）
}
 */

import java.util.ArrayList;
import java.util.Collection;

public class Demo3 {
    public static void main(String[] args) {
        Collection<String> str = new ArrayList<>();
        str.add("胡歌");
        str.add("彭于晏");
        str.add("黄晓明");
        str.add("霍建华");
        str.add("周润发");
        System.out.println(str);
        for (String string : str){
            System.out.println(string);  // 将str集合进行迭代，每次取一个值赋值给string
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    2.3迭代器

    也是对集合中数据进行遍历的

    package com.qfedu.a_collection;

// 迭代器进行取值（Iterator）


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

public class Demo4 {
    public static void main(String[] args) {
        Collection<String> str = new ArrayList<>();
        str.add("胡歌");
        str.add("彭于晏");
        str.add("黄晓明");
        str.add("霍建华");
        str.add("周润发");
        System.out.println(str);
//        str.clear();

        // 创建一个迭代器对象
        Iterator<String> iterator = str.iterator();
        // hasNext() 判断集合中是否有下一个对象 返回值true/false
        // next() 方法：返回迭代中的下一个元素。
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }



    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    3.在集合中存的是自定义的对象【重点】

    package com.qfedu.a_collection;

public class Person {
    private String name;
    private int 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;
    }

    // 有参构造
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
// 重写toString方法，将内存地址转为程序员能看懂的字符串
    // demo5中输出：Person{name:胡歌,age=42}
//    @Override
//    public String toString() {
//        return "Person{" +
//                "name:" + name +
//                ",age=" + age +
//                "}";
//    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    package com.qfedu.a_collection;

import java.util.ArrayList;
import java.util.Collection;

public class Demo5 {
    public static void main(String[] args) {
        Person person = new Person("胡歌",42);

//        System.out.println(person); // Person{name:胡歌,age=42}
        Collection<Person> list = new ArrayList<>();
        list.add(person);
        list.add(new Person("杨幂",42));
        list.add(new Person("至尊宝",149));
        list.add(new Person("紫霞",20));
        Object[] objects = list.toArray();  // 这是一个Person对象数组（内存地址）

        Person person1 = (Person)objects[0];
        System.out.println(person1.getName());

    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    4.List接口

    List是Collection的子接口

    开发中用List而不用Collection。

    因为List接口下面的方法比COllection多。List在Collection基础之上添加了很多的方法

    有序的可以重复的数据

    Collection下面的方法List肯定有的，因为是继承关系。上午讲了Collection下面的方法，在List中也可以用。接下来咱们讲List独有的方法。
List独有的方法：
	增:
		void add(int index, E e);在指定的位置上插入一个元素
		boolean addAll(int index, Collection e);将一个集合插入到另外一个集合的指定的位置
	删：
		Collection删除的时候，通过元素来删除的。 remove(Object obj)
		E remove(int index);通过索引来删除指定的元素。返回的是被删除的元素
	改：
		E set(int index, E e); 通过指定的索引修改数据元素，返回值是被修改的原数据
	查:
		E get(int index);  通过索引下标去获取指定元素
		int indexOf(Object obj);通过元素获取指定的下标的
		int lastIndexOf(object obj);通过元素获取最后一次出现的元素的下标
		List subList(int formIndex, int toIndex);截取一部分出来
		

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    package com.qfedu.b_list;

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

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        //有序的  可重复的
        System.out.println(list);//[张三, 李四, 王五, 张三]
        list.add(2, "狗蛋");
        System.out.println(list);
        List<String> list1 = new ArrayList<>();
        list1.add("麻子");
        list1.add("赵四");
        list1.add("贝贝");
        list.addAll(1, list1);
        System.out.println(list);

        System.out.println(list.remove(0));//在删除
        System.out.println(list);//目的是删除以后的集合的数据展示一下
        //[麻子, 赵四, 贝贝, 李四, 狗蛋, 王五, 张三]

        System.out.println(list.set(2, "彩云"));//贝贝
        System.out.println(list);//修改之后的集合
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        //System.out.println(list.get(89));
        System.out.println(list.indexOf("麻子"));//0
        list.add(2, "张三");
        System.out.println(list.lastIndexOf("张三"));//7

        System.out.println(list);
        List<String> strings = list.subList(3, 5);
        System.out.println(strings);

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    5.遍历List集合中的数据

    1.for循环
2.增强for循环
3.迭代器

    • 1
    • 2
    • 3
    5.1for循环
    package com.qfedu.b_list;

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

public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            //通过索引获取元素
            System.out.println(list.get(i));
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    5.2增强for循环
    package com.qfedu.b_list;

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

public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        //for循环
//        for (int i = 0; i < list.size(); i++) {
//            //通过索引获取元素
//            System.out.println(list.get(i));
//        }
        //增强for循环
//        for (String s : list) {
//            System.out.println(s);
//        }
        //迭代器

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    5.3迭代器
    package com.qfedu.b_list;

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

public class Demo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        ListIterator<String> sli = list.listIterator();
        while (sli.hasNext()) {
            System.out.println(sli.next());
        }
        //此时光标已经在最下面了
        while (sli.hasPrevious()) {
            System.out.println(sli.previous());
        }

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    package com.qfedu.b_list;

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

public class Demo4 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        //可以将指针（光标）放到指定的额位置上，然后移动光标对数据进行遍历
        ListIterator<String> sli = list.listIterator(4);
        while (sli.hasPrevious()) {
            System.out.println(sli.previous());
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    6.集合中存对象

    package com.qfedu.b_list;

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


class User {
    private String name;
    private String password;
    private int age;

    public User() {
    }

    public User(String name, String password, int age) {
        this.name = name;
        this.password = password;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Demo5 {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User("张三", "222", 34));
        list.add(new User("李四", "333", 24));
        list.add(new User("老邢", "250", 89));
        list.add(new User("骚磊", "251", 94));
        System.out.println(list);
        //[user, user, user, user]
        //获取下标为1 的元素
        User user = list.get(1);//最常用方法
        System.out.println(user.getName());
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    7.ArrayList

    ArrayList底层是数组，可以扩容的。默认的容量是10.，超过10以后会自动扩容，扩容1.5倍

    特征:

    ​ 查询快，增删慢。

    ​ 为啥？

    开发就用ArrayList 因为开发的时候，主要查询多！！！

    package com.qfedu.c_arraylist;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        //一般开发的时候写成 父类的引用指向子类的对象
        //因为List接口下面的方法已经够用了
        //ArrayList独有的方法很少，几乎不用  所以List
        ArrayList<String> list = new ArrayList<>();
        list.add("狗蛋");
        list.add(1, "老邢");
        list.add("老万");
        for (String s : list) {
            System.out.println(s);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    8.LinkedList

    也是List的实现类，双向链表

    特征： 查询慢，增删快

    package com.qfedu.d_linkedList;

import java.util.LinkedList;

public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("狗蛋");
        list.add("嘻嘻");
        list.addLast("哈啊哈");
        list.addFirst("呵呵");
        System.out.println(list);
        for (String s : list) {
            System.out.println(s);
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    9.ArrayList和LinkedList和Vector的区别

    ArrayList和Vector 底层是数组，但是Vector是线程安全的，所以效率底，开发中不用Vector
接下来介绍ArrayList和linkedListu区别:
	1.ArrayList底层是数组
	 LinkedList底层是双向链表
	2.ArrayList 的特征：
		查询快： 底层是索引，有序的通过内存有序地址，直接找到 时间复杂度  o(1)
		增删慢： 增加数据和删除数据有可能扩容。每次扩1.5倍。扩容的话，浪费内存浪费时间o（n）
	3.LinkedList的特征：
		查询慢：底层是二分法查找的算法 时间复杂度是log以2为底 n的对数
		增删快：直接找前置结点 Node prev，后继结点 Node next
		。时间复杂度是 o(1)
	所以开发时候的用ArrayList
	后续还要学习ArrayList的源码

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
  • 相关阅读:
    2022江西省·振兴杯·数字经济职业技能竞赛&中国工业互联网安全大赛·江西选拔赛初赛wp
    《华为项目管理之道》第1章笔记
    关于我在uni-app练手中遇到的坑
    HTTP/3，它来了
    JAVA集合问答
    MCE | 磁珠 VS 琼脂糖珠
    二叉树：有了如此高效的散列表，为什么还需要二叉树？
    裙式给料机的全球市场在2030年前将达到64亿美元！
    在linux服务器中使用rz上传文件乱码问题解决办法
    云计算基础技术
  • 原文地址：https://blog.csdn.net/m0_46202060/article/details/133063729